ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/rmain.c
Revision: 2.45
Committed: Mon Dec 1 09:56:27 1997 UTC (27 years, 5 months ago) by gregl
Content type: text/plain
Branch: MAIN
Changes since 2.44: +2 -0 lines
Log Message: 
added define to eliminate initurand() reference for -DMC

File Contents

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