ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/rmain.c
Revision: 2.40
Committed: Wed Apr 17 14:02:00 1996 UTC (29 years, 1 month ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.39: +8 -4 lines
Log Message: 
changed albedo to 3-color parameter

File Contents

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