ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/rmain.c
Revision: 2.32
Committed: Mon Nov 22 09:20:36 1993 UTC (31 years, 6 months ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.31: +7 -5 lines
Log Message: 
compatibility fixes

File Contents

# User Rev Content
1 greg 2.20 /* Copyright (c) 1993 Regents of the University of California */
2 greg 1.1
3     #ifndef lint
4     static char SCCSid[] = "$SunId$ LBL";
5     #endif
6    
7     /*
8     * rmain.c - main for ray tracing programs
9     *
10     * 3/24/87
11     */
12    
13     /* for flaky pre-processors */
14 greg 2.10 #ifndef RPICT
15     #define RPICT 0
16 greg 1.1 #endif
17 greg 2.10 #ifndef RTRACE
18     #define RTRACE 0
19 greg 1.1 #endif
20 greg 2.10 #ifndef RVIEW
21     #define RVIEW 0
22 greg 1.1 #endif
23    
24     #include "ray.h"
25    
26 greg 1.50 #include "resolu.h"
27    
28 greg 1.1 #include "octree.h"
29    
30 greg 2.32 #include <sys/types.h>
31    
32 greg 1.1 #include <signal.h>
33    
34     #include "view.h"
35    
36 greg 2.10 #include "paths.h"
37 greg 2.23 /* persistent processes define */
38     #ifdef F_SETLKW
39     #if RPICT|RTRACE
40 greg 2.27 #define PERSIST 1 /* normal persist */
41     #define PARALLEL 2 /* parallel persist */
42     #define PCHILD 3 /* child of normal persist */
43 greg 2.23 #endif
44     #endif
45 greg 1.1
46     char *progname; /* argv[0] */
47    
48 greg 1.19 char *octname; /* octree name */
49    
50 greg 1.1 char *libpath; /* library directory list */
51    
52     char *sigerr[NSIG]; /* signal error messages */
53    
54 greg 1.46 extern char VersionID[]; /* version ID string */
55    
56 greg 1.1 extern int stderr_v(); /* standard error output */
57     int (*errvec)() = stderr_v; /* error output vector */
58     int (*wrnvec)() = stderr_v; /* warning output vector */
59     int (*cmdvec)() = NULL; /* command error vector */
60    
61     int (*trace)() = NULL; /* trace call */
62 greg 1.36 int do_irrad = 0; /* compute irradiance? */
63 greg 1.1
64 greg 2.32 extern time_t time();
65     time_t tstart; /* start time */
66 greg 1.34
67 greg 1.24 extern int ambnotify(); /* new object notify functions */
68 greg 2.25 #if RTRACE
69     extern int tranotify();
70     int (*addobjnotify[])() = {ambnotify, tranotify, NULL};
71     extern char *tralist[]; /* trace include/exclude list */
72     extern int traincl; /* include == 1, exclude == 0 */
73     #else
74 greg 1.24 int (*addobjnotify[])() = {ambnotify, NULL};
75 greg 2.25 #endif
76 greg 1.24
77 greg 1.1 CUBE thescene; /* our scene */
78 greg 2.10 OBJECT nsceneobjs; /* number of objects in our scene */
79 greg 1.1
80 greg 2.24 extern unsigned long raynum, nrays; /* ray counts */
81 greg 2.22
82 greg 1.36 extern int imm_irrad; /* calculate immediate irradiance? */
83    
84 greg 1.1 extern int ralrm; /* seconds between reports */
85    
86     extern int greyscale; /* map colors to brightness? */
87     extern char *devname; /* output device name */
88 greg 2.30 extern double exposure; /* exposure compensation */
89 greg 1.1
90 greg 2.8 extern char *formstr(); /* string from format */
91 greg 1.1 extern int inform; /* input format */
92     extern int outform; /* output format */
93     extern char *outvals; /* output values */
94    
95     extern VIEW ourview; /* viewing parameters */
96    
97 greg 2.28 extern char rifname[]; /* rad input file name */
98    
99 greg 1.1 extern int hresolu; /* horizontal resolution */
100     extern int vresolu; /* vertical resolution */
101 greg 1.22 extern double pixaspect; /* pixel aspect ratio */
102 greg 1.1
103     extern int psample; /* pixel sample size */
104     extern double maxdiff; /* max. sample difference */
105 greg 1.11 extern double dstrpix; /* square pixel distribution */
106 greg 1.1
107     extern double dstrsrc; /* square source distribution */
108 greg 1.11 extern double shadthresh; /* shadow threshold */
109 greg 1.15 extern double shadcert; /* shadow testing certainty */
110 greg 1.39 extern int directrelay; /* number of source relays */
111 greg 1.40 extern int vspretest; /* virtual source pretest density */
112 greg 2.17 extern int directvis; /* light sources visible to eye? */
113 greg 1.47 extern double srcsizerat; /* maximum source size/dist. ratio */
114 greg 1.1
115 greg 2.4 extern double specthresh; /* specular sampling threshold */
116     extern double specjitter; /* specular sampling jitter */
117    
118 greg 1.1 extern int maxdepth; /* maximum recursion depth */
119     extern double minweight; /* minimum ray weight */
120    
121     extern COLOR ambval; /* ambient value */
122     extern double ambacc; /* ambient accuracy */
123     extern int ambres; /* ambient resolution */
124     extern int ambdiv; /* ambient divisions */
125     extern int ambssamp; /* ambient super-samples */
126     extern int ambounce; /* ambient bounces */
127     extern char *amblist[]; /* ambient include/exclude list */
128     extern int ambincl; /* include == 1, exclude == 0 */
129    
130    
131     main(argc, argv)
132     int argc;
133     char *argv[];
134     {
135 greg 2.10 #define check(ol,al) if (argv[i][ol] || \
136 greg 1.49 badarg(argc-i-1,argv+i+1,al)) \
137     goto badopt
138 greg 2.10 #define bool(olen,var) switch (argv[i][olen]) { \
139 greg 1.43 case '\0': var = !var; break; \
140     case 'y': case 'Y': case 't': case 'T': \
141     case '+': case '1': var = 1; break; \
142     case 'n': case 'N': case 'f': case 'F': \
143     case '-': case '0': var = 0; break; \
144     default: goto badopt; }
145 greg 1.1 char *err;
146     char *recover = NULL;
147 greg 2.7 char *outfile = NULL;
148 greg 1.20 char *zfile = NULL;
149 greg 1.1 char *errfile = NULL;
150     char *ambfile = NULL;
151     int loadflags = ~IO_FILES;
152 greg 2.7 int seqstart = 0;
153 greg 2.29 int persist = 0;
154 greg 2.25 char **amblp;
155     char **tralp;
156 greg 2.18 int duped1;
157 greg 2.7 int rval;
158 greg 1.1 int i;
159 greg 1.34 /* record start time */
160 greg 2.32 tstart = time((time_t *)NULL);
161 greg 1.1 /* global program name */
162 greg 2.11 progname = argv[0] = fixargv0(argv[0]);
163 greg 1.1 /* get library path */
164     if ((libpath = getenv(ULIBVAR)) == NULL)
165     libpath = DEFPATH;
166 greg 1.31 /* initialize object types */
167     initotypes();
168 greg 1.37 /* initialize urand */
169 greg 1.41 initurand(2048);
170 greg 1.10 /* option city */
171 greg 2.12 for (i = 1; i < argc; i++) {
172 greg 2.13 /* expand arguments */
173     while (rval = expandarg(&argc, &argv, i))
174     if (rval < 0) {
175     sprintf(errmsg, "cannot expand '%s'", argv[i]);
176     error(SYSTEM, errmsg);
177     }
178 greg 2.15 if (argv[i] == NULL || argv[i][0] != '-')
179 greg 2.12 break; /* break from options */
180 greg 1.46 if (!strcmp(argv[i], "-version")) {
181     puts(VersionID);
182     quit(0);
183     }
184 greg 1.18 if (!strcmp(argv[i], "-defaults") ||
185     !strcmp(argv[i], "-help")) {
186 greg 1.1 printdefaults();
187     quit(0);
188     }
189     #if RVIEW
190     if (!strcmp(argv[i], "-devices")) {
191     printdevices();
192     quit(0);
193     }
194     #endif
195 greg 1.21 #if RPICT|RVIEW
196     rval = getviewopt(&ourview, argc-i, argv+i);
197     if (rval >= 0) {
198     i += rval;
199     continue;
200     }
201     #endif
202 greg 1.1 switch (argv[i][1]) {
203     #if RPICT|RVIEW
204 greg 1.21 case 'v': /* view file */
205     if (argv[i][2] != 'f')
206 greg 1.10 goto badopt;
207 greg 1.49 check(3,"s");
208 greg 1.50 rval = viewfile(argv[++i], &ourview, NULL);
209 greg 1.21 if (rval < 0) {
210     sprintf(errmsg,
211     "cannot open view file \"%s\"",
212     argv[i]);
213     error(SYSTEM, errmsg);
214     } else if (rval == 0) {
215     sprintf(errmsg,
216     "bad view file \"%s\"",
217     argv[i]);
218     error(USER, errmsg);
219 greg 2.7 }
220 greg 1.1 break;
221     #endif
222 greg 1.11 case 'd': /* direct */
223 greg 1.1 switch (argv[i][2]) {
224 greg 1.13 case 't': /* threshold */
225 greg 1.49 check(3,"f");
226 greg 1.11 shadthresh = atof(argv[++i]);
227 greg 1.1 break;
228 greg 1.15 case 'c': /* certainty */
229 greg 1.49 check(3,"f");
230 greg 1.15 shadcert = atof(argv[++i]);
231     break;
232 greg 1.11 case 'j': /* jitter */
233 greg 1.49 check(3,"f");
234 greg 1.1 dstrsrc = atof(argv[++i]);
235     break;
236 greg 1.47 case 'r': /* relays */
237 greg 1.49 check(3,"i");
238 greg 1.39 directrelay = atoi(argv[++i]);
239     break;
240 greg 1.47 case 'p': /* pretest */
241 greg 1.49 check(3,"i");
242 greg 1.40 vspretest = atoi(argv[++i]);
243 greg 1.42 break;
244 greg 2.17 case 'v': /* visibility */
245     bool(3,directvis);
246 greg 1.40 break;
247 greg 1.47 case 's': /* size */
248 greg 1.49 check(3,"f");
249 greg 1.47 srcsizerat = atof(argv[++i]);
250     break;
251 greg 1.1 default:
252 greg 1.10 goto badopt;
253 greg 1.1 }
254     break;
255 greg 2.4 case 's': /* specular */
256     switch (argv[i][2]) {
257     case 't': /* threshold */
258     check(3,"f");
259     specthresh = atof(argv[++i]);
260     break;
261     case 'j': /* jitter */
262     check(3,"f");
263     specjitter = atof(argv[++i]);
264     break;
265     default:
266     goto badopt;
267     }
268     break;
269 greg 1.1 #if RPICT|RVIEW
270 greg 2.4 case 'p': /* pixel */
271 greg 1.1 switch (argv[i][2]) {
272 greg 2.4 case 's': /* sample */
273 greg 1.49 check(3,"i");
274 greg 1.1 psample = atoi(argv[++i]);
275     break;
276 greg 1.13 case 't': /* threshold */
277 greg 1.49 check(3,"f");
278 greg 1.1 maxdiff = atof(argv[++i]);
279     break;
280 greg 1.11 #if RPICT
281     case 'j': /* jitter */
282 greg 1.49 check(3,"f");
283 greg 1.11 dstrpix = atof(argv[++i]);
284     break;
285 greg 2.4 case 'a': /* aspect */
286     check(3,"f");
287     pixaspect = atof(argv[++i]);
288     break;
289 greg 1.11 #endif
290 greg 2.30 #if RVIEW
291     case 'e': /* exposure */
292     check(3,"f");
293     exposure = atof(argv[++i]);
294     if (argv[i][0] == '+' || argv[i][0] == '-')
295     exposure = pow(2.0, exposure);
296     break;
297     #endif
298 greg 1.1 default:
299 greg 1.10 goto badopt;
300 greg 1.1 }
301     break;
302     #endif
303 greg 1.22 #if RPICT|RTRACE
304 greg 1.1 case 'x': /* x resolution */
305 greg 1.49 check(2,"i");
306 greg 1.1 hresolu = atoi(argv[++i]);
307     break;
308     case 'y': /* y resolution */
309 greg 1.49 check(2,"i");
310 greg 1.1 vresolu = atoi(argv[++i]);
311     break;
312 greg 1.22 #endif
313 greg 1.1 case 'w': /* warnings */
314 greg 1.43 rval = wrnvec != NULL;
315     bool(2,rval);
316 greg 2.6 if (rval) wrnvec = stderr_v;
317     else wrnvec = NULL;
318 greg 1.1 break;
319     case 'e': /* error file */
320 greg 1.49 check(2,"s");
321 greg 1.1 errfile = argv[++i];
322     break;
323     case 'l': /* limit */
324     switch (argv[i][2]) {
325     case 'r': /* recursion */
326 greg 1.49 check(3,"i");
327 greg 1.1 maxdepth = atoi(argv[++i]);
328     break;
329     case 'w': /* weight */
330 greg 1.49 check(3,"f");
331 greg 1.1 minweight = atof(argv[++i]);
332     break;
333     default:
334 greg 1.10 goto badopt;
335 greg 1.1 }
336     break;
337 greg 1.36 case 'i': /* irradiance */
338 greg 1.43 bool(2,do_irrad);
339 greg 1.36 break;
340 greg 1.1 #if RPICT
341 greg 2.7 case 'S': /* slave index */
342     check(2,"i");
343     seqstart = atoi(argv[++i]);
344     break;
345     case 'o': /* output file */
346     check(2,"s");
347     outfile = argv[++i];
348     break;
349 greg 1.20 case 'z': /* z file */
350 greg 1.49 check(2,"s");
351 greg 1.20 zfile = argv[++i];
352     break;
353 greg 1.1 case 'r': /* recover file */
354 greg 2.16 if (argv[i][2] == 'o') { /* +output */
355     check(3,"s");
356     outfile = argv[i+1];
357     } else
358     check(2,"s");
359 greg 1.1 recover = argv[++i];
360     break;
361     case 't': /* timer */
362 greg 1.49 check(2,"i");
363 greg 1.1 ralrm = atoi(argv[++i]);
364     break;
365     #endif
366     case 'a': /* ambient */
367     switch (argv[i][2]) {
368     case 'v': /* value */
369 greg 1.49 check(3,"fff");
370 greg 1.1 setcolor(ambval, atof(argv[i+1]),
371     atof(argv[i+2]),
372     atof(argv[i+3]));
373     i += 3;
374     break;
375     case 'a': /* accuracy */
376 greg 1.49 check(3,"f");
377 greg 1.1 ambacc = atof(argv[++i]);
378     break;
379     case 'r': /* resolution */
380 greg 1.49 check(3,"i");
381 greg 1.1 ambres = atoi(argv[++i]);
382     break;
383     case 'd': /* divisions */
384 greg 1.49 check(3,"i");
385 greg 1.1 ambdiv = atoi(argv[++i]);
386     break;
387     case 's': /* super-samp */
388 greg 1.49 check(3,"i");
389 greg 1.1 ambssamp = atoi(argv[++i]);
390     break;
391     case 'b': /* bounces */
392 greg 1.49 check(3,"i");
393 greg 1.1 ambounce = atoi(argv[++i]);
394     break;
395     case 'i': /* include */
396 greg 2.5 case 'I':
397 greg 1.49 check(3,"s");
398 greg 1.1 if (ambincl != 1) {
399     ambincl = 1;
400     amblp = amblist;
401     }
402 greg 2.5 if (argv[i][2] == 'I') { /* file */
403 greg 2.13 rval = wordfile(amblp,
404     getpath(argv[++i],libpath,R_OK));
405 greg 2.5 if (rval < 0) {
406     sprintf(errmsg,
407     "cannot open ambient include file \"%s\"",
408     argv[i]);
409     error(SYSTEM, errmsg);
410     }
411     amblp += rval;
412 greg 2.25 } else {
413 greg 2.5 *amblp++ = argv[++i];
414 greg 2.25 *amblp = NULL;
415     }
416 greg 1.1 break;
417     case 'e': /* exclude */
418 greg 2.5 case 'E':
419 greg 1.49 check(3,"s");
420 greg 1.1 if (ambincl != 0) {
421     ambincl = 0;
422     amblp = amblist;
423     }
424 greg 2.5 if (argv[i][2] == 'E') { /* file */
425 greg 2.13 rval = wordfile(amblp,
426     getpath(argv[++i],libpath,R_OK));
427 greg 2.5 if (rval < 0) {
428     sprintf(errmsg,
429     "cannot open ambient exclude file \"%s\"",
430     argv[i]);
431     error(SYSTEM, errmsg);
432     }
433     amblp += rval;
434 greg 2.25 } else {
435 greg 2.5 *amblp++ = argv[++i];
436 greg 2.25 *amblp = NULL;
437     }
438 greg 1.1 break;
439     case 'f': /* file */
440 greg 1.49 check(3,"s");
441 greg 1.1 ambfile= argv[++i];
442     break;
443     default:
444 greg 1.10 goto badopt;
445 greg 1.1 }
446     break;
447     #if RTRACE
448 greg 1.36 case 'I': /* immed. irradiance */
449 greg 1.43 bool(2,imm_irrad);
450 greg 1.36 break;
451 greg 1.1 case 'f': /* format i/o */
452     switch (argv[i][2]) {
453     case 'a': /* ascii */
454     case 'f': /* float */
455     case 'd': /* double */
456     inform = argv[i][2];
457     break;
458     default:
459 greg 1.10 goto badopt;
460 greg 1.1 }
461     switch (argv[i][3]) {
462     case '\0':
463     outform = inform;
464     break;
465     case 'a': /* ascii */
466     case 'f': /* float */
467     case 'd': /* double */
468 greg 2.7 case 'c': /* color */
469 greg 1.49 check(4,"");
470 greg 1.1 outform = argv[i][3];
471     break;
472     default:
473 greg 1.10 goto badopt;
474 greg 1.1 }
475     break;
476     case 'o': /* output */
477     outvals = argv[i]+2;
478     break;
479 greg 1.44 case 'h': /* header output */
480     rval = loadflags & IO_INFO;
481     bool(2,rval);
482     loadflags = rval ? loadflags | IO_INFO :
483     loadflags & ~IO_INFO;
484 greg 1.1 break;
485 greg 2.25 case 't': /* trace */
486     switch (argv[i][2]) {
487     case 'i': /* include */
488     case 'I':
489     check(3,"s");
490     if (traincl != 1) {
491     traincl = 1;
492     tralp = tralist;
493     }
494     if (argv[i][2] == 'I') { /* file */
495     rval = wordfile(tralp,
496     getpath(argv[++i],libpath,R_OK));
497     if (rval < 0) {
498     sprintf(errmsg,
499     "cannot open trace include file \"%s\"",
500     argv[i]);
501     error(SYSTEM, errmsg);
502     }
503     tralp += rval;
504     } else {
505     *tralp++ = argv[++i];
506     *tralp = NULL;
507     }
508     break;
509     case 'e': /* exclude */
510     case 'E':
511     check(3,"s");
512     if (traincl != 0) {
513     traincl = 0;
514     tralp = tralist;
515     }
516     if (argv[i][2] == 'E') { /* file */
517     rval = wordfile(tralp,
518     getpath(argv[++i],libpath,R_OK));
519     if (rval < 0) {
520     sprintf(errmsg,
521     "cannot open trace exclude file \"%s\"",
522     argv[i]);
523     error(SYSTEM, errmsg);
524     }
525     tralp += rval;
526     } else {
527     *tralp++ = argv[++i];
528     *tralp = NULL;
529     }
530     break;
531     default:
532     goto badopt;
533     }
534     break;
535 greg 1.1 #endif
536     #if RVIEW
537     case 'b': /* black and white */
538 greg 1.49 bool(2,greyscale);
539 greg 1.1 break;
540     case 'o': /* output device */
541 greg 1.49 check(2,"s");
542 greg 1.1 devname = argv[++i];
543 greg 2.28 break;
544     case 'R': /* render input file */
545     check(2,"s");
546     strcpy(rifname, argv[++i]);
547 greg 1.1 break;
548     #endif
549 greg 2.18 #ifdef PERSIST
550     case 'P': /* persist file */
551     if (argv[i][2] == 'P') {
552     check(3,"s");
553 greg 2.27 persist = PARALLEL;
554 greg 2.18 } else {
555     check(2,"s");
556 greg 2.27 persist = PERSIST;
557 greg 2.18 }
558     persistfile(argv[++i]);
559     break;
560     #endif
561 greg 1.1 default:
562 greg 1.19 goto badopt;
563 greg 1.1 }
564     }
565     #if RPICT|RVIEW
566     err = setview(&ourview); /* set viewing parameters */
567     if (err != NULL)
568     error(USER, err);
569     #endif
570     /* set up signal handling */
571     sigdie(SIGINT, "Interrupt");
572     sigdie(SIGHUP, "Hangup");
573     sigdie(SIGTERM, "Terminate");
574     sigdie(SIGPIPE, "Broken pipe");
575 greg 1.45 sigdie(SIGALRM, "Alarm clock");
576 greg 2.10 #ifdef SIGXCPU
577 greg 1.1 sigdie(SIGXCPU, "CPU limit exceeded");
578     sigdie(SIGXFSZ, "File size exceeded");
579     #endif
580     /* open error file */
581     if (errfile != NULL) {
582     if (freopen(errfile, "a", stderr) == NULL)
583 greg 1.14 quit(2);
584 greg 1.1 fprintf(stderr, "**************\n*** PID %5d: ",
585     getpid());
586     printargs(argc, argv, stderr);
587 greg 2.12 putc('\n', stderr);
588 greg 1.1 fflush(stderr);
589     }
590 greg 2.10 #ifdef NICE
591 greg 1.1 nice(NICE); /* lower priority */
592     #endif
593 greg 1.19 /* get octree */
594 greg 1.1 #if RVIEW
595     loadflags &= ~IO_INFO;
596     #endif
597     if (i == argc)
598 greg 1.19 octname = NULL;
599     else if (i == argc-1)
600     octname = argv[i];
601 greg 1.1 else
602 greg 1.19 goto badopt;
603 greg 2.7 if (
604     #if RPICT
605     seqstart > 0 &&
606     #endif
607     octname == NULL)
608 greg 1.19 error(USER, "missing octree argument");
609 greg 2.26 /* set up output */
610 greg 2.18 #ifdef PERSIST
611     if (persist) {
612 greg 2.7 #if RPICT
613 greg 2.26 if (recover != NULL)
614     error(USER, "persist option used with recover file");
615 greg 2.18 if (seqstart <= 0)
616     error(USER, "persist option only for sequences");
617 greg 2.26 if (outfile == NULL)
618 greg 2.18 #endif
619     duped1 = dup(fileno(stdout)); /* don't lose our output */
620     openheader();
621     }
622     #if RPICT
623 greg 2.27 else
624     #endif
625     #endif
626     #if RPICT
627 greg 2.7 if (outfile != NULL)
628     openheader();
629 greg 1.1 #endif
630 greg 2.10 #ifdef MSDOS
631     #if RTRACE
632     if (outform != 'a')
633     #endif
634     setmode(fileno(stdout), O_BINARY);
635     if (octname == NULL)
636     setmode(fileno(stdin), O_BINARY);
637     #endif
638 greg 1.19 readoct(octname, loadflags, &thescene, NULL);
639 greg 2.9 nsceneobjs = nobjects;
640 greg 1.1
641     if (loadflags & IO_INFO) { /* print header */
642     printargs(i, argv, stdout);
643 greg 1.46 printf("SOFTWARE= %s\n", VersionID);
644 greg 2.8 #if RTRACE
645     fputformat(formstr(outform), stdout);
646     putchar('\n');
647     #endif
648 greg 1.1 }
649    
650     marksources(); /* find and mark sources */
651    
652 greg 1.24 setambient(ambfile); /* initialize ambient calculation */
653 greg 1.1
654 greg 2.18 #ifdef PERSIST
655     if (persist) {
656 greg 2.26 fflush(stdout);
657     if (outfile == NULL) { /* reconnect stdout */
658     dup2(duped1, fileno(stdout));
659     close(duped1);
660     }
661 greg 2.27 if (persist == PARALLEL) { /* multiprocessing */
662 greg 2.18 preload_objs(); /* preload scene */
663     while ((rval=fork()) == 0) { /* keep on forkin' */
664     pflock(1);
665     pfhold();
666 greg 2.32 tstart = time((time_t *)NULL);
667 greg 2.18 }
668     if (rval < 0)
669     error(SYSTEM, "cannot fork child for persist function");
670 greg 2.27 pfdetach(); /* parent exits */
671 greg 2.18 }
672     }
673     runagain:
674 greg 2.27 if (persist)
675     if (outfile == NULL) /* if out to stdout */
676     dupheader(); /* send header */
677     else /* if out to file */
678     duped1 = dup(fileno(stdout)); /* hang onto pipe */
679 greg 2.18 #endif
680 greg 1.1 #if RPICT
681 greg 2.7 rpict(seqstart, outfile, zfile, recover);
682 greg 1.1 #endif
683     #if RTRACE
684 greg 2.8 rtrace(NULL);
685 greg 1.1 #endif
686     #if RVIEW
687 greg 2.8 rview();
688 greg 2.18 #endif
689 greg 2.21 ambsync(); /* flush ambient file */
690 greg 2.18 #ifdef PERSIST
691 greg 2.27 if (persist == PERSIST) { /* first run-through */
692 greg 2.20 if ((rval=fork()) == 0) { /* child loops until killed */
693     pflock(1);
694 greg 2.27 persist = PCHILD;
695 greg 2.20 } else { /* original process exits */
696     if (rval < 0)
697     error(SYSTEM, "cannot fork child for persist function");
698 greg 2.27 pfdetach(); /* parent exits */
699 greg 2.20 }
700     }
701 greg 2.27 if (persist == PCHILD) { /* wait for a signal then go again */
702     if (outfile != NULL)
703     close(duped1); /* release output handle */
704 greg 2.20 pfhold();
705 greg 2.32 tstart = time((time_t *)NULL); /* reinitialize */
706 greg 2.22 raynum = nrays = 0;
707 greg 2.18 goto runagain;
708     }
709 greg 1.1 #endif
710     quit(0);
711 greg 1.19
712     badopt:
713     sprintf(errmsg, "command line error at '%s'", argv[i]);
714     error(USER, errmsg);
715    
716 greg 2.10 #undef check
717     #undef bool
718 greg 1.1 }
719    
720    
721     eputs(s) /* error output */
722     char *s;
723     {
724     if (errvec != NULL)
725     (*errvec)(s);
726     }
727    
728    
729     wputs(s) /* warning output */
730     char *s;
731     {
732 greg 2.3 int lasterrno = errno; /* save errno */
733    
734 greg 1.1 if (wrnvec != NULL)
735     (*wrnvec)(s);
736 greg 2.3
737     errno = lasterrno;
738 greg 1.1 }
739    
740    
741     cputs(s) /* command error output */
742     char *s;
743     {
744     if (cmdvec != NULL)
745     (*cmdvec)(s);
746     }
747    
748    
749     stderr_v(s) /* put string to stderr */
750     register char *s;
751     {
752 greg 1.26 static int midline = 0;
753 greg 1.1
754 greg 1.27 if (!*s)
755     return;
756 greg 1.26 if (!midline++) {
757 greg 1.1 fputs(progname, stderr);
758     fputs(": ", stderr);
759     }
760     fputs(s, stderr);
761 greg 1.27 if (s[strlen(s)-1] == '\n') {
762 greg 1.1 fflush(stderr);
763 greg 1.26 midline = 0;
764 greg 1.1 }
765     }
766    
767    
768     onsig(signo) /* fatal signal */
769     int signo;
770     {
771 greg 1.8 static int gotsig = 0;
772    
773     if (gotsig++) /* two signals and we're gone! */
774 greg 1.9 _exit(signo);
775 greg 1.8
776 greg 1.48 alarm(15); /* allow 15 seconds to clean up */
777     signal(SIGALRM, SIG_DFL); /* make certain we do die */
778 greg 1.1 eputs("signal - ");
779     eputs(sigerr[signo]);
780     eputs("\n");
781 greg 1.14 quit(3);
782 greg 1.1 }
783    
784    
785     sigdie(signo, msg) /* set fatal signal */
786     int signo;
787     char *msg;
788     {
789     if (signal(signo, onsig) == SIG_IGN)
790     signal(signo, SIG_IGN);
791     sigerr[signo] = msg;
792     }
793    
794    
795     printdefaults() /* print default values to stdout */
796     {
797     register char *cp;
798    
799 greg 1.43 #if RTRACE
800     if (imm_irrad)
801     printf("-I+\t\t\t\t# immediate irradiance on\n");
802     else
803     #endif
804     printf(do_irrad ? "-i+\t\t\t\t# irradiance calculation on\n" :
805     "-i-\t\t\t\t# irradiance calculation off\n");
806 greg 1.49 #if RVIEW
807     printf(greyscale ? "-b+\t\t\t\t# greyscale on\n" :
808     "-b-\t\t\t\t# greyscale off\n");
809     #endif
810 greg 1.1 #if RPICT|RVIEW
811 greg 1.7 printf("-vt%c\t\t\t\t# view type %s\n", ourview.type,
812 greg 1.1 ourview.type==VT_PER ? "perspective" :
813     ourview.type==VT_PAR ? "parallel" :
814 greg 1.28 ourview.type==VT_HEM ? "hemispherical" :
815     ourview.type==VT_ANG ? "angular" :
816 greg 1.1 "unknown");
817     printf("-vp %f %f %f\t# view point\n",
818     ourview.vp[0], ourview.vp[1], ourview.vp[2]);
819 greg 2.11 printf("-vd %f %f %f\t# view direction\n",
820 greg 1.1 ourview.vdir[0], ourview.vdir[1], ourview.vdir[2]);
821 greg 2.11 printf("-vu %f %f %f\t# view up\n",
822 greg 1.1 ourview.vup[0], ourview.vup[1], ourview.vup[2]);
823     printf("-vh %f\t\t\t# view horizontal size\n", ourview.horiz);
824     printf("-vv %f\t\t\t# view vertical size\n", ourview.vert);
825 greg 1.22 printf("-vs %f\t\t\t# view shift\n", ourview.hoff);
826     printf("-vl %f\t\t\t# view lift\n", ourview.voff);
827 greg 1.1 #endif
828 greg 1.22 #if RPICT|RTRACE
829 greg 1.1 printf("-x %-9d\t\t\t# x resolution\n", hresolu);
830     printf("-y %-9d\t\t\t# y resolution\n", vresolu);
831 greg 1.22 #endif
832     #if RPICT
833 greg 2.4 printf("-pa %f\t\t\t# pixel aspect ratio\n", pixaspect);
834     printf("-pj %f\t\t\t# pixel jitter\n", dstrpix);
835 greg 2.30 #endif
836     #if RVIEW
837     printf("-pe %f\t\t\t# pixel exposure\n", exposure);
838 greg 1.22 #endif
839 greg 1.1 #if RPICT|RVIEW
840 greg 2.4 printf("-ps %-9d\t\t\t# pixel sample\n", psample);
841     printf("-pt %f\t\t\t# pixel threshold\n", maxdiff);
842 greg 1.22 #endif
843 greg 1.29 printf("-dt %f\t\t\t# direct threshold\n", shadthresh);
844     printf("-dc %f\t\t\t# direct certainty\n", shadcert);
845     printf("-dj %f\t\t\t# direct jitter\n", dstrsrc);
846 greg 1.47 printf("-ds %f\t\t\t# direct sampling\n", srcsizerat);
847 greg 1.39 printf("-dr %-9d\t\t\t# direct relays\n", directrelay);
848 greg 1.40 printf("-dp %-9d\t\t\t# direct pretest density\n", vspretest);
849 greg 2.17 printf(directvis ? "-dv+\t\t\t\t# direct visibility on\n" :
850     "-dv-\t\t\t\t# direct visibility off\n");
851 greg 2.4 printf("-sj %f\t\t\t# specular jitter\n", specjitter);
852     printf("-st %f\t\t\t# specular threshold\n", specthresh);
853 greg 1.1 printf("-av %f %f %f\t# ambient value\n", colval(ambval,RED),
854     colval(ambval,GRN), colval(ambval, BLU));
855     printf("-ab %-9d\t\t\t# ambient bounces\n", ambounce);
856     printf("-aa %f\t\t\t# ambient accuracy\n", ambacc);
857     printf("-ar %-9d\t\t\t# ambient resolution\n", ambres);
858     printf("-ad %-9d\t\t\t# ambient divisions\n", ambdiv);
859     printf("-as %-9d\t\t\t# ambient super-samples\n", ambssamp);
860     printf("-lr %-9d\t\t\t# limit reflection\n", maxdepth);
861     printf("-lw %f\t\t\t# limit weight\n", minweight);
862     #if RPICT
863     printf("-t %-9d\t\t\t# time between reports\n", ralrm);
864     #endif
865     #if RVIEW
866     printf("-o %s\t\t\t\t# output device\n", devname);
867     #endif
868     #if RTRACE
869     printf("-f%c%c\t\t\t\t# format input/output = %s/%s\n",
870 greg 2.7 inform, outform, formstr(inform), formstr(outform));
871 greg 1.1 printf("-o%s\t\t\t\t# output", outvals);
872     for (cp = outvals; *cp; cp++)
873     switch (*cp) {
874     case 't': printf(" trace"); break;
875     case 'o': printf(" origin"); break;
876     case 'd': printf(" direction"); break;
877     case 'v': printf(" value"); break;
878     case 'l': printf(" length"); break;
879 greg 2.14 case 'L': printf(" first_length"); break;
880 greg 1.1 case 'p': printf(" point"); break;
881     case 'n': printf(" normal"); break;
882 greg 2.14 case 'N': printf(" unperturbed_normal"); break;
883 greg 1.1 case 's': printf(" surface"); break;
884     case 'w': printf(" weight"); break;
885     case 'm': printf(" modifier"); break;
886     }
887 greg 2.7 putchar('\n');
888 greg 1.1 #endif
889 greg 1.43 printf(wrnvec != NULL ? "-w+\t\t\t\t# warning messages on\n" :
890     "-w-\t\t\t\t# warning messages off\n");
891 greg 1.1 }