ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/rmain.c
Revision: 2.27
Committed: Mon Aug 2 13:34:06 1993 UTC (31 years, 9 months ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.26: +24 -20 lines
Log Message: 
fixes for persist function

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