ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/rmain.c
Revision: 2.24
Committed: Tue May 25 10:30:04 1993 UTC (32 years ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.23: +1 -1 lines
Log Message: 
changed ray counters to unsigned long values

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