src/rt/rcmain.c

#ifndef lint
static const char       RCSid[] = "$Id: rcmain.c,v 2.31 2023/08/15 00:46:56 greg Exp $";
#endif
/*
 *  rcmain.c - main for rtcontrib ray contribution tracer
 */

#include "copyright.h"

#include <signal.h>
#include <time.h>
#include "rcontrib.h"
#include "random.h"
#include "source.h"
#include "ambient.h"
#include "pmapray.h"
#include "pmapcontrib.h"

int     gargc;                          /* global argc */
char    **gargv;                        /* global argv */
char    *octname;                       /* global octree name */
char    *progname;                      /* global argv[0] */

char    *sigerr[NSIG];                  /* signal error messages */

int     nproc = 1;                      /* number of processes requested */
int     nchild = 0;                     /* number of children (-1 in child) */

int     inpfmt = 'a';                   /* input format */
int     outfmt = 'a';                   /* output format */

int     header = 1;                     /* output header? */
int     force_open = 0;                 /* truncate existing output? */
int     recover = 0;                    /* recover previous output? */
int     accumulate = 1;                 /* input rays per output record */
int     contrib = 0;                    /* computing contributions? */

int     xres = 0;                       /* horizontal (scan) size */
int     yres = 0;                       /* vertical resolution */

int     using_stdout = 0;               /* are we using stdout? */

int     imm_irrad = 0;                  /* compute immediate irradiance? */
int     lim_dist = 0;                   /* limit distance? */

int     report_intvl = 0;               /* reporting interval (seconds) */

char    **modname = NULL;               /* ordered modifier name list */
int     nmods = 0;                      /* number of modifiers */
int     modasiz = 0;                    /* allocated modifier array size */

void    (*addobjnotify[8])() = {ambnotify, NULL};

char    RCCONTEXT[] = "RC.";            /* our special evaluation context */

#if defined(_WIN32) || defined(_WIN64)
#define RCONTRIB_FEATURES       "Accumulation\nSummation\nRecovery\n" \
                                "Hyperspectral\nImmediateIrradiance\n" \
                                "ProgressReporting\nDistanceLimiting\n" \
                                "InputFormats=a,f,d\nOutputFormats=a,f,d,c\n" \
                                "Outputs=V,W\n"
#else
#define RCONTRIB_FEATURES       "Multiprocessing\n" \
                                "Accumulation\nSummation\nRecovery\n" \
                                "Hyperspectral\nImmediateIrradiance\n" \
                                "ProgressReporting\nDistanceLimiting\n" \
                                "InputFormats=a,f,d\nOutputFormats=a,f,d,c\n" \
                                "Outputs=V,W\n"
#endif

static void
printdefaults(void)                     /* print default values to stdout */
{
        printf("-c %-5d\t\t\t# accumulated rays per record\n", accumulate);
        if (NCSAMP > 3) {
                printf("-cs %-2d\t\t\t\t# number of spectral bins\n", NCSAMP);
                printf("-cw %3.0f %3.0f\t\t\t# wavelength limits (nm)\n",
                                WLPART[3], WLPART[0]);
        }
        printf("-V%c\t\t\t\t# output %s\n", contrib ? '+' : '-',
                        contrib ? "contributions" : "coefficients");
        if (imm_irrad)
                printf("-I+\t\t\t\t# immediate irradiance on\n");
        printf("-n %-2d\t\t\t\t# number of rendering processes\n", nproc);
        printf("-x %-9d\t\t\t# %s\n", xres,
                        yres && xres ? "x resolution" : "flush interval");
        printf("-y %-9d\t\t\t# y resolution\n", yres);
        printf(lim_dist ? "-ld+\t\t\t\t# limit distance on\n" :
                        "-ld-\t\t\t\t# limit distance off\n");
        printf(header ? "-h+\t\t\t\t# output header\n" :
                        "-h-\t\t\t\t# no header\n");
        printf("-f%c%c\t\t\t\t# format input/output = %s/%s\n",
                        inpfmt, outfmt, formstr(inpfmt), formstr(outfmt));
        printf(erract[WARNING].pf != NULL ?
                        "-w+\t\t\t\t# warning messages on\n" :
                        "-w-\t\t\t\t# warning messages off\n");
        print_rdefaults();
}


static void
onsig(                          /* fatal signal */
        int  signo
)
{
        static int  gotsig = 0;

        if (gotsig++)                   /* two signals and we're gone! */
                _exit(signo);

#ifdef SIGALRM
        alarm(15);                      /* allow 15 seconds to clean up */
        signal(SIGALRM, SIG_DFL);       /* make certain we do die */
#endif
        eputs("signal - ");
        eputs(sigerr[signo]);
        eputs("\n");
        quit(3);
}


static void
sigdie(                 /* set fatal signal */
        int  signo,
        char  *msg
)
{
        if (signal(signo, onsig) == SIG_IGN)
                signal(signo, SIG_IGN);
        sigerr[signo] = msg;
}


/* set input/output format */
static void
setformat(const char *fmt)
{
        switch (fmt[0]) {
        case 'f':
        case 'd':
                SET_FILE_BINARY(stdin);
                /* fall through */
        case 'a':
                inpfmt = fmt[0];
                break;
        default:
                goto fmterr;
        }
        switch (fmt[1]) {
        case '\0':
                outfmt = inpfmt;
                return;
        case 'a':
        case 'f':
        case 'd':
        case 'c':
                outfmt = fmt[1];
                break;
        default:
                goto fmterr;
        }
        if (!fmt[2])
                return;
fmterr:
        sprintf(errmsg, "Illegal i/o format: -f%s", fmt);
        error(USER, errmsg);
}


/* Set overriding options */
static void
override_options(void)
{
        shadthresh = 0;
        ambssamp = 0;
        ambacc = 0;
        if (accumulate <= 0)    /* no output flushing for single record */
                xres = yres = 0;
}


int
main(int argc, char *argv[])
{
#define  check(ol,al)           if (argv[i][ol] || \
                                badarg(argc-i-1,argv+i+1,al)) \
                                goto badopt
#define  check_bool(olen,var)           switch (argv[i][olen]) { \
                                case '\0': var = !var; break; \
                                case 'y': case 'Y': case 't': case 'T': \
                                case '+': case '1': var = 1; break; \
                                case 'n': case 'N': case 'f': case 'F': \
                                case '-': case '0': var = 0; break; \
                                default: goto badopt; }
        char    *curout = NULL;
        char    *prms = NULL;
        char    *binval = NULL;
        int     bincnt = 0;
        int     rval;
        int     i;
                                        /* global program name */
        progname = argv[0] = fixargv0(argv[0]);
        gargv = argv;
        gargc = argc;
                                        /* feature check only? */
        strcat(RFeatureList, RCONTRIB_FEATURES);
        if (argc > 1 && !strcmp(argv[1], "-features"))
                return feature_status(argc-2, argv+2);
#if defined(_WIN32) || defined(_WIN64)  /* increase file limit to maximum */
        for (i = 8192; i > _IOB_ENTRIES; i >>= 1)
                if (_setmaxstdio(i) == i)
                        break;
#endif
                                        /* initialize calcomp routines early */
        initfunc();
        calcontext(RCCONTEXT);
                                        /* option city */
        for (i = 1; i < argc; i++) {
                                                /* expand arguments */
                while ((rval = expandarg(&argc, &argv, i)) > 0)
                        ;
                if (rval < 0) {
                        sprintf(errmsg, "cannot expand '%s'", argv[i]);
                        error(SYSTEM, errmsg);
                }
                if (argv[i] == NULL || argv[i][0] != '-')
                        break;                  /* break from options */
                if (!strcmp(argv[i], "-version")) {
                        puts(VersionID);
                        quit(0);
                }
                if (!strcmp(argv[i], "-defaults") ||
                                !strcmp(argv[i], "-help")) {
                        override_options();
                        printdefaults();
                        quit(0);
                }
                rval = getrenderopt(argc-i, argv+i);
                if (rval >= 0) {
                        i += rval;
                        continue;
                }
                switch (argv[i][1]) {
                case 'n':                       /* number of cores */
                        check(2,"i");
                        nproc = atoi(argv[++i]);
                        if (nproc <= 0)
                                error(USER, "bad number of processes");
                        break;
                case 'V':                       /* output contributions */
                        check_bool(2,contrib);
                        break;
                case 'x':                       /* x resolution */
                        check(2,"i");
                        xres = atoi(argv[++i]);
                        break;
                case 'y':                       /* y resolution */
                        check(2,"i");
                        yres = atoi(argv[++i]);
                        break;
                case 'w':                       /* warnings */
                        rval = (erract[WARNING].pf != NULL);
                        check_bool(2,rval);
                        if (rval) erract[WARNING].pf = wputs;
                        else erract[WARNING].pf = NULL;
                        break;
                case 'e':                       /* expression */
                        check(2,"s");
                        scompile(argv[++i], NULL, 0);
                        break;
                case 'l':                       /* limit distance */
                        if (argv[i][2] != 'd')
                                goto badopt;
                        check_bool(3,lim_dist);
                        break;
                case 'I':                       /* immed. irradiance */
                        check_bool(2,imm_irrad);
                        break;
                case 'f':                       /* file or force or format */
                        if (!argv[i][2]) {
                                check(2,"s");
                                loadfunc(argv[++i]);
                                break;
                        }
                        if (argv[i][2] == 'o') {
                                check_bool(3,force_open);
                                break;
                        }
                        setformat(argv[i]+2);
                        break;
                case 'o':                       /* output */
                        check(2,"s");
                        curout = argv[++i];
                        break;
                case 'r':                       /* recover output */
                        check_bool(2,recover);
                        break;
                case 'h':                       /* header output */
                        check_bool(2,header);
                        break;
                case 'p':                       /* parameter setting(s) */
                        check(2,"s");
                        set_eparams(prms = argv[++i]);
                        break;
                case 'c':                               /* spectral sampling or count */
                        switch (argv[i][2]) {
#if MAXCSAMP>3
                        case 's':                       /* spectral bin count */
                                check(3,"i");
                                NCSAMP = atoi(argv[++i]);
                                break;
                        case 'w':                       /* wavelength extrema */
                                check(3,"ff");
                                WLPART[0] = atof(argv[++i]);
                                WLPART[3] = atof(argv[++i]);
                                break;
#endif
                        case '\0':                      /* sample count */
                                check(2,"i");
                                accumulate = atoi(argv[++i]);
                                break;
                        default:
                                goto badopt;
                        }
                        break;
                case 'b':                       /* bin expression/count */
                        if (argv[i][2] == 'n') {
                                check(3,"s");
                                bincnt = (int)(eval(argv[++i]) + .5);
                                break;
                        }
                        check(2,"s");
                        binval = argv[++i];
                        break;
                case 'm':                       /* modifier name */
                        check(2,"s");
                        addmodifier(argv[++i], curout, prms, binval, bincnt);
                        break;
                case 'M':                       /* modifier file */
                        check(2,"s");
                        addmodfile(argv[++i], curout, prms, binval, bincnt);
                        break;
                case 't':                       /* reporting interval */
                        check(2,"i");
                        report_intvl = atoi(argv[++i]);
                        break;
                default:
                        goto badopt;
                }
        }
        if (nmods <= 0)
                error(USER, "missing required modifier argument");
                                        /* override some option settings */
        override_options();
                                        /* initialize object types */
        initotypes();
                                        /* initialize urand */
        if (rand_samp) {
                srandom((long)time(0));
                initurand(0);
        } else {
                srandom(0L);
                initurand(2048);
        }
                                        /* set up signal handling */
        sigdie(SIGINT, "Interrupt");
#ifdef SIGHUP
        sigdie(SIGHUP, "Hangup");
#endif
        sigdie(SIGTERM, "Terminate");
#ifdef SIGPIPE
        sigdie(SIGPIPE, "Broken pipe");
#endif
#ifdef SIGALRM
        sigdie(SIGALRM, "Alarm clock");
#endif
#ifdef  SIGXCPU
        sigdie(SIGXCPU, "CPU limit exceeded");
        sigdie(SIGXFSZ, "File size exceeded");
#endif
#ifdef  NICE
        nice(NICE);                     /* lower priority */
#endif
                                        /* get octree */
        if (i == argc)
                octname = NULL;
        else if (i == argc-1)
                octname = argv[i];
        else
                goto badopt;
        if (octname == NULL)
                error(USER, "missing octree argument");

        readoct(octname, ~(IO_FILES|IO_INFO), &thescene, NULL);
        nsceneobjs = nobjects;

        /* PMAP: set up & load photon maps */
        ray_init_pmap();     
        
        marksources();                  /* find and mark sources */
        
        /* PMAP: init photon map for light source contributions */
        initPmapContrib(&modconttab, nmods);

        setambient();                   /* initialize ambient calculation */
        
        rcontrib();                     /* trace ray contributions (loop) */

        ambsync();                      /* flush ambient file */

        /* PMAP: free photon maps */
        ray_done_pmap();     
        
        quit(0);        /* exit clean */

badopt:
        fprintf(stderr,
"Usage: %s [-n nprocs][-V][-c count][-r][-e expr][-f source][-o ospec][-p p1=V1,p2=V2][-b binv][-bn N] {-m mod | -M file} [rtrace options] octree\n",
                        progname);
        sprintf(errmsg, "command line error at '%s'", argv[i]);
        error(USER, errmsg);
        return(1);      /* pro forma return */

#undef  check
#undef  check_bool
}


void
wputs(                          /* warning output function */
        const char      *s
)
{
        int  lasterrno = errno;
        eputs(s);
        errno = lasterrno;
}


void
eputs(                          /* put string to stderr */
        const char  *s
)
{
        static int  midline = 0;

        if (!*s)
                return;
        if (!midline++) {
                fputs(progname, stderr);
                fputs(": ", stderr);
        }
        fputs(s, stderr);
        if (s[strlen(s)-1] == '\n') {
                fflush(stderr);
                midline = 0;
        }
}
Revision:	2.32
Committed:	Wed Nov 15 18:02:53 2023 UTC (6 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.31:	+31 -9 lines
Log Message:	feat(rpict,rtrace,rcontrib,rtpict): Hyperspectral rendering (except photon map)
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.32	static const char RCSid[] = "$Id: rcmain.c,v 2.31 2023/08/15 00:46:56 greg Exp $";
3	greg	2.1	#endif
4			/*
5			* rcmain.c - main for rtcontrib ray contribution tracer
6			*/
7
8			#include "copyright.h"
9
10			#include <signal.h>
11	greg	2.10	#include <time.h>
12	greg	2.1	#include "rcontrib.h"
13	greg	2.6	#include "random.h"
14	greg	2.1	#include "source.h"
15			#include "ambient.h"
16	greg	2.14	#include "pmapray.h"
17			#include "pmapcontrib.h"
18	greg	2.1
19			int gargc; /* global argc */
20			char *gargv; / global argv */
21			char octname; / global octree name */
22			char progname; / global argv[0] */
23
24			char sigerr[NSIG]; / signal error messages */
25
26			int nproc = 1; /* number of processes requested */
27			int nchild = 0; /* number of children (-1 in child) */
28
29			int inpfmt = 'a'; /* input format */
30			int outfmt = 'a'; /* output format */
31
32			int header = 1; /* output header? */
33			int force_open = 0; /* truncate existing output? */
34			int recover = 0; /* recover previous output? */
35			int accumulate = 1; /* input rays per output record */
36			int contrib = 0; /* computing contributions? */
37
38			int xres = 0; /* horizontal (scan) size */
39			int yres = 0; /* vertical resolution */
40
41			int using_stdout = 0; /* are we using stdout? */
42
43			int imm_irrad = 0; /* compute immediate irradiance? */
44			int lim_dist = 0; /* limit distance? */
45
46	greg	2.19	int report_intvl = 0; /* reporting interval (seconds) */
47
48	greg	2.20	char *modname = NULL; / ordered modifier name list */
49			int nmods = 0; /* number of modifiers */
50			int modasiz = 0; /* allocated modifier array size */
51	greg	2.1
52	greg	2.4	void (*addobjnotify[8])() = {ambnotify, NULL};
53
54	greg	2.18	char RCCONTEXT[] = "RC."; /* our special evaluation context */
55	greg	2.1
56	greg	2.22	#if defined(_WIN32) \|\| defined(_WIN64)
57	greg	2.23	#define RCONTRIB_FEATURES "Accumulation\nSummation\nRecovery\n" \
58	greg	2.32	"Hyperspectral\nImmediateIrradiance\n" \
59	greg	2.24	"ProgressReporting\nDistanceLimiting\n" \
60	greg	2.31	"InputFormats=a,f,d\nOutputFormats=a,f,d,c\n" \
61	greg	2.24	"Outputs=V,W\n"
62	greg	2.22	#else
63			#define RCONTRIB_FEATURES "Multiprocessing\n" \
64	greg	2.23	"Accumulation\nSummation\nRecovery\n" \
65	greg	2.32	"Hyperspectral\nImmediateIrradiance\n" \
66	greg	2.24	"ProgressReporting\nDistanceLimiting\n" \
67	greg	2.31	"InputFormats=a,f,d\nOutputFormats=a,f,d,c\n" \
68	greg	2.24	"Outputs=V,W\n"
69	greg	2.22	#endif
70	greg	2.1
71			static void
72			printdefaults(void) /* print default values to stdout */
73			{
74	greg	2.3	printf("-c %-5d\t\t\t# accumulated rays per record\n", accumulate);
75	greg	2.32	if (NCSAMP > 3) {
76			printf("-cs %-2d\t\t\t\t# number of spectral bins\n", NCSAMP);
77			printf("-cw %3.0f %3.0f\t\t\t# wavelength limits (nm)\n",
78			WLPART[3], WLPART[0]);
79			}
80	greg	2.3	printf("-V%c\t\t\t\t# output %s\n", contrib ? '+' : '-',
81			contrib ? "contributions" : "coefficients");
82	greg	2.1	if (imm_irrad)
83			printf("-I+\t\t\t\t# immediate irradiance on\n");
84			printf("-n %-2d\t\t\t\t# number of rendering processes\n", nproc);
85			printf("-x %-9d\t\t\t# %s\n", xres,
86			yres && xres ? "x resolution" : "flush interval");
87			printf("-y %-9d\t\t\t# y resolution\n", yres);
88			printf(lim_dist ? "-ld+\t\t\t\t# limit distance on\n" :
89			"-ld-\t\t\t\t# limit distance off\n");
90	greg	2.32	printf(header ? "-h+\t\t\t\t# output header\n" :
91			"-h-\t\t\t\t# no header\n");
92	greg	2.1	printf("-f%c%c\t\t\t\t# format input/output = %s/%s\n",
93			inpfmt, outfmt, formstr(inpfmt), formstr(outfmt));
94			printf(erract[WARNING].pf != NULL ?
95			"-w+\t\t\t\t# warning messages on\n" :
96			"-w-\t\t\t\t# warning messages off\n");
97			print_rdefaults();
98			}
99
100
101			static void
102			onsig( /* fatal signal */
103			int signo
104			)
105			{
106			static int gotsig = 0;
107
108			if (gotsig++) /* two signals and we're gone! */
109			_exit(signo);
110
111			#ifdef SIGALRM
112			alarm(15); /* allow 15 seconds to clean up */
113			signal(SIGALRM, SIG_DFL); /* make certain we do die */
114			#endif
115			eputs("signal - ");
116			eputs(sigerr[signo]);
117			eputs("\n");
118			quit(3);
119			}
120
121
122			static void
123			sigdie( /* set fatal signal */
124			int signo,
125			char *msg
126			)
127			{
128			if (signal(signo, onsig) == SIG_IGN)
129			signal(signo, SIG_IGN);
130			sigerr[signo] = msg;
131			}
132
133
134			/* set input/output format */
135			static void
136			setformat(const char *fmt)
137			{
138			switch (fmt[0]) {
139			case 'f':
140			case 'd':
141			SET_FILE_BINARY(stdin);
142			/* fall through */
143			case 'a':
144			inpfmt = fmt[0];
145			break;
146			default:
147			goto fmterr;
148			}
149			switch (fmt[1]) {
150			case '\0':
151			outfmt = inpfmt;
152			return;
153			case 'a':
154			case 'f':
155			case 'd':
156			case 'c':
157			outfmt = fmt[1];
158			break;
159			default:
160			goto fmterr;
161			}
162			if (!fmt[2])
163			return;
164			fmterr:
165			sprintf(errmsg, "Illegal i/o format: -f%s", fmt);
166			error(USER, errmsg);
167			}
168
169
170			/* Set overriding options */
171			static void
172			override_options(void)
173			{
174			shadthresh = 0;
175			ambssamp = 0;
176			ambacc = 0;
177			if (accumulate <= 0) /* no output flushing for single record */
178			xres = yres = 0;
179			}
180
181
182			int
183			main(int argc, char *argv[])
184			{
185			#define check(ol,al) if (argv[i][ol] \|\| \
186			badarg(argc-i-1,argv+i+1,al)) \
187			goto badopt
188	schorsch	2.15	#define check_bool(olen,var) switch (argv[i][olen]) { \
189	greg	2.1	case '\0': var = !var; break; \
190			case 'y': case 'Y': case 't': case 'T': \
191			case '+': case '1': var = 1; break; \
192			case 'n': case 'N': case 'f': case 'F': \
193			case '-': case '0': var = 0; break; \
194			default: goto badopt; }
195			char *curout = NULL;
196	greg	2.12	char *prms = NULL;
197	greg	2.1	char *binval = NULL;
198			int bincnt = 0;
199			int rval;
200			int i;
201			/* global program name */
202			progname = argv[0] = fixargv0(argv[0]);
203			gargv = argv;
204			gargc = argc;
205	greg	2.22	/* feature check only? */
206			strcat(RFeatureList, RCONTRIB_FEATURES);
207	greg	2.26	if (argc > 1 && !strcmp(argv[1], "-features"))
208	greg	2.22	return feature_status(argc-2, argv+2);
209	greg	2.28	#if defined(_WIN32) \|\| defined(_WIN64) /* increase file limit to maximum */
210			for (i = 8192; i > _IOB_ENTRIES; i >>= 1)
211	greg	2.30	if (_setmaxstdio(i) == i)
212	greg	2.28	break;
213	greg	2.17	#endif
214	greg	2.1	/* initialize calcomp routines early */
215			initfunc();
216	greg	2.21	calcontext(RCCONTEXT);
217	greg	2.1	/* option city */
218			for (i = 1; i < argc; i++) {
219			/* expand arguments */
220			while ((rval = expandarg(&argc, &argv, i)) > 0)
221			;
222			if (rval < 0) {
223			sprintf(errmsg, "cannot expand '%s'", argv[i]);
224			error(SYSTEM, errmsg);
225			}
226			if (argv[i] == NULL \|\| argv[i][0] != '-')
227			break; /* break from options */
228			if (!strcmp(argv[i], "-version")) {
229			puts(VersionID);
230			quit(0);
231			}
232			if (!strcmp(argv[i], "-defaults") \|\|
233			!strcmp(argv[i], "-help")) {
234			override_options();
235			printdefaults();
236			quit(0);
237			}
238			rval = getrenderopt(argc-i, argv+i);
239			if (rval >= 0) {
240			i += rval;
241			continue;
242			}
243			switch (argv[i][1]) {
244			case 'n': /* number of cores */
245			check(2,"i");
246			nproc = atoi(argv[++i]);
247			if (nproc <= 0)
248			error(USER, "bad number of processes");
249			break;
250			case 'V': /* output contributions */
251	schorsch	2.15	check_bool(2,contrib);
252	greg	2.1	break;
253			case 'x': /* x resolution */
254			check(2,"i");
255			xres = atoi(argv[++i]);
256			break;
257			case 'y': /* y resolution */
258			check(2,"i");
259			yres = atoi(argv[++i]);
260			break;
261			case 'w': /* warnings */
262	greg	2.2	rval = (erract[WARNING].pf != NULL);
263	schorsch	2.15	check_bool(2,rval);
264	greg	2.1	if (rval) erract[WARNING].pf = wputs;
265			else erract[WARNING].pf = NULL;
266			break;
267			case 'e': /* expression */
268			check(2,"s");
269			scompile(argv[++i], NULL, 0);
270			break;
271			case 'l': /* limit distance */
272			if (argv[i][2] != 'd')
273			goto badopt;
274	schorsch	2.15	check_bool(3,lim_dist);
275	greg	2.1	break;
276			case 'I': /* immed. irradiance */
277	schorsch	2.15	check_bool(2,imm_irrad);
278	greg	2.1	break;
279			case 'f': /* file or force or format */
280			if (!argv[i][2]) {
281			check(2,"s");
282			loadfunc(argv[++i]);
283			break;
284			}
285			if (argv[i][2] == 'o') {
286	schorsch	2.15	check_bool(3,force_open);
287	greg	2.1	break;
288			}
289			setformat(argv[i]+2);
290			break;
291			case 'o': /* output */
292			check(2,"s");
293			curout = argv[++i];
294			break;
295			case 'r': /* recover output */
296	schorsch	2.15	check_bool(2,recover);
297	greg	2.1	break;
298			case 'h': /* header output */
299	schorsch	2.15	check_bool(2,header);
300	greg	2.1	break;
301	greg	2.12	case 'p': /* parameter setting(s) */
302			check(2,"s");
303	greg	2.13	set_eparams(prms = argv[++i]);
304	greg	2.12	break;
305	greg	2.32	case 'c': /* spectral sampling or count */
306			switch (argv[i][2]) {
307			#if MAXCSAMP>3
308			case 's': /* spectral bin count */
309			check(3,"i");
310			NCSAMP = atoi(argv[++i]);
311			break;
312			case 'w': /* wavelength extrema */
313			check(3,"ff");
314			WLPART[0] = atof(argv[++i]);
315			WLPART[3] = atof(argv[++i]);
316			break;
317			#endif
318			case '\0': /* sample count */
319			check(2,"i");
320			accumulate = atoi(argv[++i]);
321			break;
322			default:
323			goto badopt;
324			}
325			break;
326	greg	2.1	case 'b': /* bin expression/count */
327			if (argv[i][2] == 'n') {
328			check(3,"s");
329			bincnt = (int)(eval(argv[++i]) + .5);
330			break;
331			}
332			check(2,"s");
333			binval = argv[++i];
334			break;
335			case 'm': /* modifier name */
336			check(2,"s");
337	greg	2.12	addmodifier(argv[++i], curout, prms, binval, bincnt);
338	greg	2.1	break;
339			case 'M': /* modifier file */
340			check(2,"s");
341	greg	2.12	addmodfile(argv[++i], curout, prms, binval, bincnt);
342	greg	2.1	break;
343	greg	2.19	case 't': /* reporting interval */
344			check(2,"i");
345			report_intvl = atoi(argv[++i]);
346			break;
347	greg	2.1	default:
348			goto badopt;
349			}
350			}
351	greg	2.11	if (nmods <= 0)
352			error(USER, "missing required modifier argument");
353	greg	2.1	/* override some option settings */
354			override_options();
355			/* initialize object types */
356			initotypes();
357			/* initialize urand */
358			if (rand_samp) {
359			srandom((long)time(0));
360			initurand(0);
361			} else {
362			srandom(0L);
363			initurand(2048);
364			}
365			/* set up signal handling */
366			sigdie(SIGINT, "Interrupt");
367			#ifdef SIGHUP
368			sigdie(SIGHUP, "Hangup");
369			#endif
370			sigdie(SIGTERM, "Terminate");
371			#ifdef SIGPIPE
372			sigdie(SIGPIPE, "Broken pipe");
373			#endif
374			#ifdef SIGALRM
375			sigdie(SIGALRM, "Alarm clock");
376			#endif
377			#ifdef SIGXCPU
378			sigdie(SIGXCPU, "CPU limit exceeded");
379			sigdie(SIGXFSZ, "File size exceeded");
380			#endif
381			#ifdef NICE
382			nice(NICE); /* lower priority */
383			#endif
384			/* get octree */
385			if (i == argc)
386			octname = NULL;
387			else if (i == argc-1)
388			octname = argv[i];
389			else
390			goto badopt;
391			if (octname == NULL)
392			error(USER, "missing octree argument");
393
394			readoct(octname, ~(IO_FILES\|IO_INFO), &thescene, NULL);
395			nsceneobjs = nobjects;
396
397	greg	2.14	/* PMAP: set up & load photon maps */
398			ray_init_pmap();
399
400	greg	2.1	marksources(); /* find and mark sources */
401	greg	2.14
402			/* PMAP: init photon map for light source contributions */
403			initPmapContrib(&modconttab, nmods);
404	greg	2.1
405			setambient(); /* initialize ambient calculation */
406	greg	2.14
407	greg	2.2	rcontrib(); /* trace ray contributions (loop) */
408	greg	2.1
409			ambsync(); /* flush ambient file */
410
411	greg	2.14	/* PMAP: free photon maps */
412			ray_done_pmap();
413
414	greg	2.1	quit(0); /* exit clean */
415
416			badopt:
417			fprintf(stderr,
418	greg	2.16	"Usage: %s [-n nprocs][-V][-c count][-r][-e expr][-f source][-o ospec][-p p1=V1,p2=V2][-b binv][-bn N] {-m mod \| -M file} [rtrace options] octree\n",
419	greg	2.1	progname);
420			sprintf(errmsg, "command line error at '%s'", argv[i]);
421			error(USER, errmsg);
422			return(1); /* pro forma return */
423
424			#undef check
425	schorsch	2.15	#undef check_bool
426	greg	2.1	}
427
428
429			void
430			wputs( /* warning output function */
431	greg	2.27	const char *s
432	greg	2.1	)
433			{
434			int lasterrno = errno;
435			eputs(s);
436			errno = lasterrno;
437			}
438
439
440			void
441			eputs( /* put string to stderr */
442	greg	2.27	const char *s
443	greg	2.1	)
444			{
445			static int midline = 0;
446
447			if (!*s)
448			return;
449			if (!midline++) {
450			fputs(progname, stderr);
451			fputs(": ", stderr);
452			}
453			fputs(s, stderr);
454			if (s[strlen(s)-1] == '\n') {
455			fflush(stderr);
456			midline = 0;
457			}
458			}