src/rt/rtmain.c

#ifndef lint
static const char       RCSid[] = "$Id: rtmain.c,v 2.60 2025/06/20 03:43:17 greg Exp $";
#endif
/*
 *  rtmain.c - main for rtrace per-ray calculation program
 */

#include "copyright.h"

#include  <signal.h>

#include  "platform.h"
#include  "rtprocess.h" /* getpid() */
#include  "resolu.h"
#include  "ray.h"
#include  "func.h"
#include  "source.h"
#include  "ambient.h"
#include  "random.h"
#include  "pmapray.h"
                                        /* persistent processes define */
#ifdef  F_SETLKW
#define  PERSIST        1               /* normal persist */
#define  PARALLEL       2               /* parallel persist */
#define  PCHILD         3               /* child of normal persist */
#endif

char  *sigerr[NSIG];                    /* signal error messages */
char  *errfile = NULL;                  /* error output file */

int  nproc = 1;                         /* number of processes */

extern int  setrtoutput(void);          /* set output values */

int  inform = 'a';                      /* input format */
int  outform = 'a';                     /* output format */
char  *outvals = "v";                   /* output specification */

int  hresolu = 0;                       /* horizontal (scan) size */
int  vresolu = 0;                       /* vertical resolution */

extern int  castonly;                   /* only doing ray-casting? */

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

#ifndef MAXMODLIST
#define MAXMODLIST      1024            /* maximum modifiers we'll track */
#endif

extern void  (*addobjnotify[])();       /* object notification calls */
extern void  tranotify(OBJECT obj);

char  *tralist[MAXMODLIST];             /* list of modifers to trace (or no) */
int  traincl = -1;                      /* include == 1, exclude == 0 */

double  (*sens_curve)(const SCOLOR scol) = NULL;        /* spectral conversion for 1-channel */
double  out_scalefactor = 1;            /* output calibration scale factor */
RGBPRIMP  out_prims = stdprims;         /* output color primitives (NULL if spectral) */
static RGBPRIMS  our_prims;             /* private output color primitives */

static int  loadflags = ~IO_FILES;      /* what to load from octree */

static void onsig(int  signo);
static void sigdie(int  signo, char  *msg);
static void printdefaults(void);

#ifdef PERSIST
#define RTRACE_FEATURES "Persist\nParallelPersist\nMultiprocessing\n" \
                        "IrradianceCalc\nImmediateIrradiance\nDistanceLimiting\n" \
                        "ParticipatingMedia=Mist\n" \
                        "HessianAmbientCache\nAmbientAveraging\n" \
                        "AmbientValueSharing\nAdaptiveShadowTesting\n" \
                        "InputFormats=a,f,d\nOutputFormats=a,f,d,c\n" \
                        "Outputs=o,d,v,V,w,W,l,L,c,p,n,N,s,m,M,r,x,R,X,~\n" \
                        "OutputCS=RGB,XYZ,Y,S,M,prims,spec\n"
#else
#define RTRACE_FEATURES "IrradianceCalc\nIrradianceCalc\nDistanceLimiting\n" \
                        "ParticipatingMedia=Mist\n" \
                        "HessianAmbientCache\nAmbientAveraging\n" \
                        "AmbientValueSharing\nAdaptiveShadowTesting\n" \
                        "InputFormats=a,f,d\nOutputFormats=a,f,d,c\n" \
                        "Outputs=o,d,v,V,w,W,l,L,c,p,n,N,s,m,M,r,x,R,X,~\n" \
                        "OutputCS=RGB,XYZ,Y,S,M,prims,spec\n"
#endif


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; }
        extern char  *octname;
        int  persist = 0;
        char  *octnm = NULL;
        char  **tralp = NULL;
        int  duped1 = -1;
        int  rval;
        int  i;
                                        /* global program name */
        progname = argv[0] = fixargv0(argv[0]);
                                        /* feature check only? */
        strcat(RFeatureList, RTRACE_FEATURES);
        if (argc > 1 && !strcmp(argv[1], "-features"))
                return feature_status(argc-2, argv+2);
                                        /* initialize calcomp routines */
        initfunc();
                                        /* add trace notify function */
        for (i = 0; addobjnotify[i] != NULL; i++)
                ;
        addobjnotify[i] = tranotify;
                                        /* 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")) {
                        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 'x':                               /* x resolution */
                        check(2,"i");
                        hresolu = atoi(argv[++i]);
                        break;
                case 'y':                               /* y resolution */
                        check(2,"i");
                        vresolu = atoi(argv[++i]);
                        break;
                case 'w':                               /* warnings & spectral */
                        rval = erract[WARNING].pf != NULL;
                        check_bool(2,rval);
                        if (rval) erract[WARNING].pf = wputs;
                        else erract[WARNING].pf = NULL;
                        break;
                case 'e':                               /* error file */
                        check(2,"s");
                        errfile = argv[++i];
                        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':                               /* format i/o */
                        switch (argv[i][2]) {
                        case 'a':                               /* ascii */
                        case 'f':                               /* float */
                        case 'd':                               /* double */
                                inform = argv[i][2];
                                break;
                        default:
                                goto badopt;
                        }
                        switch (argv[i][3]) {
                        case '\0':
                                outform = inform;
                                break;
                        case 'a':                               /* ascii */
                        case 'f':                               /* float */
                        case 'd':                               /* double */
                        case 'c':                               /* color */
                                check(4,"");
                                outform = argv[i][3];
                                break;
                        default:
                                goto badopt;
                        }
                        break;
                case 'o':                               /* output */
                        outvals = argv[i]+2;
                        break;
                case 'h':                               /* header output */
                        rval = loadflags & IO_INFO;
                        check_bool(2,rval);
                        loadflags = rval ? loadflags | IO_INFO :
                                        loadflags & ~IO_INFO;
                        break;
                case 't':                               /* trace */
                        switch (argv[i][2]) {
                        case 'i':                               /* include */
                        case 'I':
                                check(3,"s");
                                if (traincl != 1) {
                                        traincl = 1;
                                        tralp = tralist;
                                }
                                if (argv[i][2] == 'I') {        /* file */
                                        rval = wordfile(tralp, MAXMODLIST-(tralp-tralist),
                                        getpath(argv[++i],getrlibpath(),R_OK));
                                        if (rval < 0) {
                                                sprintf(errmsg,
                                "cannot open trace include file \"%s\"",
                                                                argv[i]);
                                                error(SYSTEM, errmsg);
                                        }
                                        tralp += rval;
                                } else {
                                        *tralp++ = argv[++i];
                                        *tralp = NULL;
                                }
                                break;
                        case 'e':                               /* exclude */
                        case 'E':
                                check(3,"s");
                                if (traincl != 0) {
                                        traincl = 0;
                                        tralp = tralist;
                                }
                                if (argv[i][2] == 'E') {        /* file */
                                        rval = wordfile(tralp, MAXMODLIST-(tralp-tralist),
                                        getpath(argv[++i],getrlibpath(),R_OK));
                                        if (rval < 0) {
                                                sprintf(errmsg,
                                "cannot open trace exclude file \"%s\"",
                                                                argv[i]);
                                                error(SYSTEM, errmsg);
                                        }
                                        tralp += rval;
                                } else {
                                        *tralp++ = argv[++i];
                                        *tralp = NULL;
                                }
                                break;
                        default:
                                goto badopt;
                        }
                        break;
                case 'p':                               /* value output */
                        switch (argv[i][2]) {
                        case 'R':                       /* standard RGB output */
                                if (strcmp(argv[i]+2, "RGB"))
                                        goto badopt;
                                out_prims = stdprims;
                                out_scalefactor = 1;
                                sens_curve = NULL;
                                break;
                        case 'X':                       /* XYZ output */
                                if (strcmp(argv[i]+2, "XYZ"))
                                        goto badopt;
                                out_prims = xyzprims;
                                out_scalefactor = WHTEFFICACY;
                                sens_curve = NULL;
                                break;
                        case 'c': {
                                int     j;
                                check(3,"ffffffff");
                                rval = 0;
                                for (j = 0; j < 8; j++) {
                                        our_prims[0][j] = atof(argv[++i]);
                                        rval |= fabs(our_prims[0][j]-stdprims[0][j]) > .001;
                                }
                                if (rval) {
                                        if (!colorprimsOK(our_prims))
                                                error(USER, "illegal primary chromaticities");
                                        out_prims = our_prims;
                                } else
                                        out_prims = stdprims;
                                out_scalefactor = 1;
                                sens_curve = NULL;
                                } break;
                        case 'Y':                       /* photopic response */
                                if (argv[i][3])
                                        goto badopt;
                                sens_curve = scolor_photopic;
                                out_scalefactor = WHTEFFICACY;
                                break;
                        case 'S':                       /* scotopic response */
                                if (argv[i][3])
                                        goto badopt;
                                sens_curve = scolor_scotopic;
                                out_scalefactor = WHTSCOTOPIC;
                                break;
                        case 'M':                       /* melanopic response */
                                if (argv[i][3])
                                        goto badopt;
                                sens_curve = scolor_melanopic;
                                out_scalefactor = WHTMELANOPIC;
                                break;
                        default:
                                goto badopt;
                        }
                        break;
#if MAXCSAMP>3
                case 'c':                               /* output spectral results */
                        if (argv[i][2] != 'o')
                                goto badopt;
                        rval = (out_prims == NULL) & (sens_curve == NULL);
                        check_bool(3,rval);
                        if (rval) {
                                out_prims = NULL;
                                sens_curve = NULL;
                        } else if (out_prims == NULL)
                                out_prims = stdprims;
                        break;
#endif
#ifdef  PERSIST
                case 'P':                               /* persist file */
                        if (argv[i][2] == 'P') {
                                check(3,"s");
                                persist = PARALLEL;
                        } else {
                                check(2,"s");
                                persist = PERSIST;
                        }
                        persistfile(argv[++i]);
                        break;
#endif
                default:
                        goto badopt;
                }
        }
                                        /* set/check spectral sampling */
        rval = setspectrsamp(CNDX, WLPART);
        if (rval < 0)
                error(USER, "unsupported spectral sampling");
        if (sens_curve != NULL)
                out_prims = NULL;
        else if (out_prims != NULL) {
                if (!rval)
                        error(WARNING, "spectral range incompatible with color output");
        } else if (NCSAMP == 3)
                out_prims = stdprims;   /* 3 samples do not a spectrum make */
        if (nproc > 1 && persist)
                error(USER, "multiprocessing incompatible with persist file");
                                        /* initialize object types */
        initotypes();
                                        /* initialize urand */
        reset_random();
                                        /* 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
                                        /* open error file */
        if (errfile != NULL) {
                if (freopen(errfile, "a", stderr) == NULL)
                        quit(2);
                fprintf(stderr, "**************\n*** PID %5d: ",
                                getpid());
                printargs(argc, argv, stderr);
                putc('\n', stderr);
                fflush(stderr);
        }
#ifdef  NICE
        nice(NICE);                     /* lower priority */
#endif
                                        /* get octree */
        if (i == argc)
                octnm = NULL;
        else if (i == argc-1)
                octnm = argv[i];
        else
                goto badopt;
        if (octnm == NULL)
                error(USER, "missing octree argument");
                                        /* set up output */
#ifdef  PERSIST
        if (persist) {
                duped1 = dup(fileno(stdout));   /* don't lose our output */
                openheader();
        }
#endif
        if (outform != 'a')
                SET_FILE_BINARY(stdout);
        rval = setrtoutput();
        octname = savqstr(octnm);
        readoct(octname, loadflags, &thescene, NULL);
        nsceneobjs = nobjects;

        if (loadflags & IO_INFO) {      /* print header */
                printargs(i, argv, stdout);
                printf("SOFTWARE= %s\n", VersionID);
                fputnow(stdout);
                if (rval > 0)           /* saved from setrtoutput() call */
                        fputncomp(rval, stdout);
                if (NCSAMP > 3)
                        fputwlsplit(WLPART, stdout);
                if ((out_prims != stdprims) & (out_prims != NULL))
                        fputprims(out_prims, stdout);
                if ((outform == 'f') | (outform == 'd'))
                        fputendian(stdout);
                fputformat(formstr(outform), stdout);
                fputc('\n', stdout);    /* end of header */
        }

        if (!castonly) {        /* any actual ray traversal to do? */

                ray_init_pmap();        /* PMAP: set up & load photon maps */
                
                marksources();          /* find and mark sources */

                setambient();           /* initialize ambient calculation */
        } else
                distantsources();       /* else mark only distant sources */

        fflush(stdout);                 /* in case we're duplicating header */

#ifdef  PERSIST
        if (persist) {
                                                /* reconnect stdout */
                dup2(duped1, fileno(stdout));
                close(duped1);
                if (persist == PARALLEL) {      /* multiprocessing */
                        cow_memshare();         /* preloads scene */
                        while ((rval=fork()) == 0) {    /* keep on forkin' */
                                pflock(1);
                                pfhold();
                                ambsync();              /* load new values */
                        }
                        if (rval < 0)
                                error(SYSTEM, "cannot fork child for persist function");
                        pfdetach();             /* parent will run then exit */
                }
        }
runagain:
        if (persist)
                dupheader();                    /* send header to stdout */
#endif
                                        /* trace rays */
        rtrace(NULL, nproc);
                                        /* flush ambient file */
        ambsync();
#ifdef  PERSIST
        if (persist == PERSIST) {       /* first run-through */
                if ((rval=fork()) == 0) {       /* child loops until killed */
                        pflock(1);
                        persist = PCHILD;
                } else {                        /* original process exits */
                        if (rval < 0)
                                error(SYSTEM, "cannot fork child for persist function");
                        pfdetach();             /* parent exits */
                }
        }
        if (persist == PCHILD) {        /* wait for a signal then go again */
                pfhold();
                raynum = nrays = 0;             /* reinitialize */
                goto runagain;
        }
#endif

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

badopt:
        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;
        if (erract[WARNING].pf == NULL)
                return;         /* called by calcomp or someone */
        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;
        }
}


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;
}


static void
printdefaults(void)                     /* print default values to stdout */
{
        char  *cp;

        printf(erract[WARNING].pf != NULL ?
                        "-w+\t\t\t\t# warning messages on\n" :
                        "-w-\t\t\t\t# warning messages off\n");
        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", hresolu,
                        vresolu && hresolu ? "x resolution" : "flush interval");
        printf("-y %-9d\t\t\t# y resolution\n", vresolu);
        printf(lim_dist ? "-ld+\t\t\t\t# limit distance on\n" :
                        "-ld-\t\t\t\t# limit distance off\n");
        printf(loadflags & IO_INFO ? "-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",
                        inform, outform, formstr(inform), formstr(outform));
        printf("-o%-9s\t\t\t# output", outvals);
        for (cp = outvals; *cp; cp++)
                switch (*cp) {
                case 't': case 'T': printf(" trace"); break;
                case 'o': printf(" origin"); break;
                case 'd': printf(" direction"); break;
                case 'r': printf(" reflect_contrib"); break;
                case 'R': printf(" reflect_length"); break;
                case 'x': printf(" unreflect_contrib"); break;
                case 'X': printf(" unreflect_length"); break;
                case 'v': printf(" value"); break;
                case 'V': printf(" contribution"); break;
                case 'l': printf(" length"); break;
                case 'L': printf(" first_length"); break;
                case 'p': printf(" point"); break;
                case 'n': printf(" normal"); break;
                case 'N': printf(" unperturbed_normal"); break;
                case 's': printf(" surface"); break;
                case 'w': printf(" weight"); break;
                case 'W': printf(" coefficient"); break;
                case 'm': printf(" modifier"); break;
                case 'M': printf(" material"); break;
                case '~': printf(" tilde"); break;
                }
        fputc('\n', stdout);
        if (sens_curve == scolor_photopic)
                printf("-pY\t\t\t\t# photopic output\n");
        else if (sens_curve == scolor_scotopic)
                printf("-pS\t\t\t\t# scotopic output\n");
        else if (sens_curve == scolor_melanopic)
                printf("-pM\t\t\t\t# melanopic output\n");
        else if (out_prims == stdprims)
                printf("-pRGB\t\t\t\t# standard RGB color output\n");
        else if (out_prims == xyzprims)
                printf("-pXYZ\t\t\t\t# CIE XYZ color output\n");
        else if (out_prims != NULL)
                printf("-pc %.4f %.4f %.4f %.4f %.4f %.4f %.4f %.4f\t# output color primaries and white point\n",
                                out_prims[RED][0], out_prims[RED][1],
                                out_prims[GRN][0], out_prims[GRN][1],
                                out_prims[BLU][0], out_prims[BLU][1],
                                out_prims[WHT][0], out_prims[WHT][1]);
        if ((sens_curve == NULL) & (NCSAMP > 3))
                printf(out_prims != NULL ? "-co-\t\t\t\t# output tristimulus colors\n" :
                                "-co+\t\t\t\t# output spectral values\n");
        print_rdefaults();
}
Revision:	2.61
Committed:	Fri Jun 20 16:34:23 2025 UTC (4 hours, 55 minutes ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 2.60:	+1 -4 lines
Log Message:	fix: Avoid array bounds errors in dimlist[] in deep ray trees
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.61	static const char RCSid[] = "$Id: rtmain.c,v 2.60 2025/06/20 03:43:17 greg Exp $";
3	greg	2.1	#endif
4			/*
5			* rtmain.c - main for rtrace per-ray calculation program
6			*/
7
8	greg	2.2	#include "copyright.h"
9	greg	2.1
10	schorsch	2.4	#include <signal.h>
11
12			#include "platform.h"
13	schorsch	2.7	#include "rtprocess.h" /* getpid() */
14	schorsch	2.9	#include "resolu.h"
15	greg	2.1	#include "ray.h"
16	greg	2.58	#include "func.h"
17	greg	2.1	#include "source.h"
18			#include "ambient.h"
19			#include "random.h"
20	greg	2.23	#include "pmapray.h"
21	greg	2.1	/* persistent processes define */
22			#ifdef F_SETLKW
23			#define PERSIST 1 /* normal persist */
24			#define PARALLEL 2 /* parallel persist */
25			#define PCHILD 3 /* child of normal persist */
26			#endif
27
28			char sigerr[NSIG]; / signal error messages */
29			char errfile = NULL; / error output file */
30
31	greg	2.18	int nproc = 1; /* number of processes */
32
33	greg	2.31	extern int setrtoutput(void); /* set output values */
34	greg	2.32
35	greg	2.18	int inform = 'a'; /* input format */
36			int outform = 'a'; /* output format */
37			char outvals = "v"; / output specification */
38	greg	2.1
39	greg	2.18	int hresolu = 0; /* horizontal (scan) size */
40			int vresolu = 0; /* vertical resolution */
41	greg	2.1
42	greg	2.33	extern int castonly; /* only doing ray-casting? */
43	greg	2.32
44	greg	2.18	int imm_irrad = 0; /* compute immediate irradiance? */
45			int lim_dist = 0; /* limit distance? */
46
47			#ifndef MAXMODLIST
48			#define MAXMODLIST 1024 /* maximum modifiers we'll track */
49			#endif
50	greg	2.1
51	greg	2.18	extern void (addobjnotify[])(); / object notification calls */
52			extern void tranotify(OBJECT obj);
53
54			char tralist[MAXMODLIST]; / list of modifers to trace (or no) */
55			int traincl = -1; /* include == 1, exclude == 0 */
56	greg	2.1
57	greg	2.54	double (sens_curve)(const SCOLOR scol) = NULL; / spectral conversion for 1-channel */
58	greg	2.47	double out_scalefactor = 1; /* output calibration scale factor */
59			RGBPRIMP out_prims = stdprims; /* output color primitives (NULL if spectral) */
60			static RGBPRIMS our_prims; /* private output color primitives */
61
62	greg	2.10	static int loadflags = ~IO_FILES; /* what to load from octree */
63
64	schorsch	2.9	static void onsig(int signo);
65			static void sigdie(int signo, char *msg);
66			static void printdefaults(void);
67	greg	2.1
68	greg	2.38	#ifdef PERSIST
69	greg	2.45	#define RTRACE_FEATURES "Persist\nParallelPersist\nMultiprocessing\n" \
70	greg	2.38	"IrradianceCalc\nImmediateIrradiance\nDistanceLimiting\n" \
71	greg	2.48	"ParticipatingMedia=Mist\n" \
72	greg	2.39	"HessianAmbientCache\nAmbientAveraging\n" \
73	greg	2.40	"AmbientValueSharing\nAdaptiveShadowTesting\n" \
74	greg	2.45	"InputFormats=a,f,d\nOutputFormats=a,f,d,c\n" \
75	greg	2.51	"Outputs=o,d,v,V,w,W,l,L,c,p,n,N,s,m,M,r,x,R,X,~\n" \
76			"OutputCS=RGB,XYZ,Y,S,M,prims,spec\n"
77	greg	2.38	#else
78			#define RTRACE_FEATURES "IrradianceCalc\nIrradianceCalc\nDistanceLimiting\n" \
79	greg	2.48	"ParticipatingMedia=Mist\n" \
80	greg	2.39	"HessianAmbientCache\nAmbientAveraging\n" \
81	greg	2.40	"AmbientValueSharing\nAdaptiveShadowTesting\n" \
82	greg	2.45	"InputFormats=a,f,d\nOutputFormats=a,f,d,c\n" \
83	greg	2.52	"Outputs=o,d,v,V,w,W,l,L,c,p,n,N,s,m,M,r,x,R,X,~\n" \
84	greg	2.51	"OutputCS=RGB,XYZ,Y,S,M,prims,spec\n"
85	greg	2.38	#endif
86
87	greg	2.1
88			int
89	schorsch	2.9	main(int argc, char *argv[])
90	greg	2.1	{
91			#define check(ol,al) if (argv[i][ol] \|\| \
92			badarg(argc-i-1,argv+i+1,al)) \
93			goto badopt
94	schorsch	2.26	#define check_bool(olen,var) switch (argv[i][olen]) { \
95	greg	2.1	case '\0': var = !var; break; \
96			case 'y': case 'Y': case 't': case 'T': \
97			case '+': case '1': var = 1; break; \
98			case 'n': case 'N': case 'f': case 'F': \
99			case '-': case '0': var = 0; break; \
100			default: goto badopt; }
101	greg	2.25	extern char *octname;
102	greg	2.1	int persist = 0;
103	greg	2.18	char *octnm = NULL;
104	greg	2.22	char **tralp = NULL;
105			int duped1 = -1;
106	greg	2.1	int rval;
107			int i;
108			/* global program name */
109			progname = argv[0] = fixargv0(argv[0]);
110	greg	2.38	/* feature check only? */
111			strcat(RFeatureList, RTRACE_FEATURES);
112	greg	2.43	if (argc > 1 && !strcmp(argv[1], "-features"))
113	greg	2.38	return feature_status(argc-2, argv+2);
114	greg	2.58	/* initialize calcomp routines */
115			initfunc();
116	greg	2.18	/* add trace notify function */
117			for (i = 0; addobjnotify[i] != NULL; i++)
118			;
119			addobjnotify[i] = tranotify;
120	greg	2.1	/* option city */
121			for (i = 1; i < argc; i++) {
122			/* expand arguments */
123			while ((rval = expandarg(&argc, &argv, i)) > 0)
124			;
125			if (rval < 0) {
126			sprintf(errmsg, "cannot expand '%s'", argv[i]);
127			error(SYSTEM, errmsg);
128			}
129			if (argv[i] == NULL \|\| argv[i][0] != '-')
130			break; /* break from options */
131			if (!strcmp(argv[i], "-version")) {
132			puts(VersionID);
133			quit(0);
134			}
135			if (!strcmp(argv[i], "-defaults") \|\|
136			!strcmp(argv[i], "-help")) {
137			printdefaults();
138			quit(0);
139			}
140			rval = getrenderopt(argc-i, argv+i);
141			if (rval >= 0) {
142			i += rval;
143			continue;
144			}
145			switch (argv[i][1]) {
146	greg	2.18	case 'n': /* number of cores */
147			check(2,"i");
148			nproc = atoi(argv[++i]);
149			if (nproc <= 0)
150			error(USER, "bad number of processes");
151			break;
152	greg	2.1	case 'x': /* x resolution */
153			check(2,"i");
154			hresolu = atoi(argv[++i]);
155			break;
156			case 'y': /* y resolution */
157			check(2,"i");
158			vresolu = atoi(argv[++i]);
159			break;
160	greg	2.47	case 'w': /* warnings & spectral */
161	greg	2.1	rval = erract[WARNING].pf != NULL;
162	schorsch	2.26	check_bool(2,rval);
163	greg	2.1	if (rval) erract[WARNING].pf = wputs;
164			else erract[WARNING].pf = NULL;
165			break;
166			case 'e': /* error file */
167			check(2,"s");
168			errfile = argv[++i];
169			break;
170			case 'l': /* limit distance */
171			if (argv[i][2] != 'd')
172			goto badopt;
173	schorsch	2.26	check_bool(3,lim_dist);
174	greg	2.1	break;
175			case 'I': /* immed. irradiance */
176	schorsch	2.26	check_bool(2,imm_irrad);
177	greg	2.1	break;
178			case 'f': /* format i/o */
179			switch (argv[i][2]) {
180			case 'a': /* ascii */
181			case 'f': /* float */
182			case 'd': /* double */
183			inform = argv[i][2];
184			break;
185			default:
186			goto badopt;
187			}
188			switch (argv[i][3]) {
189			case '\0':
190			outform = inform;
191			break;
192			case 'a': /* ascii */
193			case 'f': /* float */
194			case 'd': /* double */
195			case 'c': /* color */
196			check(4,"");
197			outform = argv[i][3];
198			break;
199			default:
200			goto badopt;
201			}
202			break;
203			case 'o': /* output */
204			outvals = argv[i]+2;
205			break;
206			case 'h': /* header output */
207			rval = loadflags & IO_INFO;
208	schorsch	2.26	check_bool(2,rval);
209	greg	2.1	loadflags = rval ? loadflags \| IO_INFO :
210			loadflags & ~IO_INFO;
211			break;
212			case 't': /* trace */
213			switch (argv[i][2]) {
214			case 'i': /* include */
215			case 'I':
216			check(3,"s");
217			if (traincl != 1) {
218			traincl = 1;
219			tralp = tralist;
220			}
221			if (argv[i][2] == 'I') { /* file */
222	greg	2.27	rval = wordfile(tralp, MAXMODLIST-(tralp-tralist),
223	greg	2.3	getpath(argv[++i],getrlibpath(),R_OK));
224	greg	2.1	if (rval < 0) {
225			sprintf(errmsg,
226			"cannot open trace include file \"%s\"",
227			argv[i]);
228			error(SYSTEM, errmsg);
229			}
230			tralp += rval;
231			} else {
232			*tralp++ = argv[++i];
233			*tralp = NULL;
234			}
235			break;
236			case 'e': /* exclude */
237			case 'E':
238			check(3,"s");
239			if (traincl != 0) {
240			traincl = 0;
241			tralp = tralist;
242			}
243			if (argv[i][2] == 'E') { /* file */
244	greg	2.27	rval = wordfile(tralp, MAXMODLIST-(tralp-tralist),
245	greg	2.3	getpath(argv[++i],getrlibpath(),R_OK));
246	greg	2.1	if (rval < 0) {
247			sprintf(errmsg,
248			"cannot open trace exclude file \"%s\"",
249			argv[i]);
250			error(SYSTEM, errmsg);
251			}
252			tralp += rval;
253			} else {
254			*tralp++ = argv[++i];
255			*tralp = NULL;
256			}
257			break;
258			default:
259			goto badopt;
260			}
261			break;
262	greg	2.47	case 'p': /* value output */
263			switch (argv[i][2]) {
264			case 'R': /* standard RGB output */
265			if (strcmp(argv[i]+2, "RGB"))
266			goto badopt;
267			out_prims = stdprims;
268			out_scalefactor = 1;
269			sens_curve = NULL;
270			break;
271			case 'X': /* XYZ output */
272			if (strcmp(argv[i]+2, "XYZ"))
273			goto badopt;
274			out_prims = xyzprims;
275			out_scalefactor = WHTEFFICACY;
276			sens_curve = NULL;
277			break;
278			case 'c': {
279			int j;
280			check(3,"ffffffff");
281			rval = 0;
282			for (j = 0; j < 8; j++) {
283			our_prims[0][j] = atof(argv[++i]);
284			rval \|= fabs(our_prims[0][j]-stdprims[0][j]) > .001;
285			}
286			if (rval) {
287			if (!colorprimsOK(our_prims))
288			error(USER, "illegal primary chromaticities");
289			out_prims = our_prims;
290			} else
291			out_prims = stdprims;
292			out_scalefactor = 1;
293			sens_curve = NULL;
294			} break;
295			case 'Y': /* photopic response */
296	greg	2.50	if (argv[i][3])
297			goto badopt;
298	greg	2.47	sens_curve = scolor_photopic;
299			out_scalefactor = WHTEFFICACY;
300			break;
301			case 'S': /* scotopic response */
302	greg	2.50	if (argv[i][3])
303			goto badopt;
304	greg	2.47	sens_curve = scolor_scotopic;
305			out_scalefactor = WHTSCOTOPIC;
306			break;
307			case 'M': /* melanopic response */
308	greg	2.50	if (argv[i][3])
309			goto badopt;
310	greg	2.47	sens_curve = scolor_melanopic;
311			out_scalefactor = WHTMELANOPIC;
312			break;
313			default:
314			goto badopt;
315			}
316			break;
317			#if MAXCSAMP>3
318	greg	2.48	case 'c': /* output spectral results */
319			if (argv[i][2] != 'o')
320	greg	2.47	goto badopt;
321	greg	2.49	rval = (out_prims == NULL) & (sens_curve == NULL);
322	greg	2.48	check_bool(3,rval);
323	greg	2.49	if (rval) {
324			out_prims = NULL;
325			sens_curve = NULL;
326			} else if (out_prims == NULL)
327			out_prims = stdprims;
328	greg	2.47	break;
329			#endif
330	greg	2.1	#ifdef PERSIST
331			case 'P': /* persist file */
332			if (argv[i][2] == 'P') {
333			check(3,"s");
334			persist = PARALLEL;
335			} else {
336			check(2,"s");
337			persist = PERSIST;
338			}
339			persistfile(argv[++i]);
340			break;
341			#endif
342			default:
343			goto badopt;
344			}
345			}
346	greg	2.47	/* set/check spectral sampling */
347			rval = setspectrsamp(CNDX, WLPART);
348			if (rval < 0)
349			error(USER, "unsupported spectral sampling");
350	greg	2.57	if (sens_curve != NULL)
351			out_prims = NULL;
352			else if (out_prims != NULL) {
353	greg	2.47	if (!rval)
354			error(WARNING, "spectral range incompatible with color output");
355			} else if (NCSAMP == 3)
356			out_prims = stdprims; /* 3 samples do not a spectrum make */
357	greg	2.34	if (nproc > 1 && persist)
358			error(USER, "multiprocessing incompatible with persist file");
359	greg	2.1	/* initialize object types */
360			initotypes();
361			/* initialize urand */
362	greg	2.60	reset_random();
363	greg	2.1	/* set up signal handling */
364			sigdie(SIGINT, "Interrupt");
365	schorsch	2.5	#ifdef SIGHUP
366	greg	2.1	sigdie(SIGHUP, "Hangup");
367	schorsch	2.5	#endif
368	greg	2.1	sigdie(SIGTERM, "Terminate");
369	schorsch	2.5	#ifdef SIGPIPE
370	greg	2.1	sigdie(SIGPIPE, "Broken pipe");
371	schorsch	2.5	#endif
372			#ifdef SIGALRM
373	greg	2.1	sigdie(SIGALRM, "Alarm clock");
374	schorsch	2.5	#endif
375	greg	2.1	#ifdef SIGXCPU
376			sigdie(SIGXCPU, "CPU limit exceeded");
377			sigdie(SIGXFSZ, "File size exceeded");
378			#endif
379			/* open error file */
380			if (errfile != NULL) {
381			if (freopen(errfile, "a", stderr) == NULL)
382			quit(2);
383			fprintf(stderr, "************\n* PID %5d: ",
384			getpid());
385			printargs(argc, argv, stderr);
386			putc('\n', stderr);
387			fflush(stderr);
388			}
389			#ifdef NICE
390			nice(NICE); /* lower priority */
391			#endif
392			/* get octree */
393			if (i == argc)
394	greg	2.18	octnm = NULL;
395	greg	2.1	else if (i == argc-1)
396	greg	2.18	octnm = argv[i];
397	greg	2.1	else
398			goto badopt;
399	greg	2.18	if (octnm == NULL)
400	greg	2.1	error(USER, "missing octree argument");
401			/* set up output */
402			#ifdef PERSIST
403			if (persist) {
404			duped1 = dup(fileno(stdout)); /* don't lose our output */
405			openheader();
406			}
407			#endif
408			if (outform != 'a')
409	schorsch	2.4	SET_FILE_BINARY(stdout);
410	greg	2.31	rval = setrtoutput();
411	greg	2.41	octname = savqstr(octnm);
412			readoct(octname, loadflags, &thescene, NULL);
413	greg	2.1	nsceneobjs = nobjects;
414
415			if (loadflags & IO_INFO) { /* print header */
416			printargs(i, argv, stdout);
417			printf("SOFTWARE= %s\n", VersionID);
418			fputnow(stdout);
419	greg	2.31	if (rval > 0) /* saved from setrtoutput() call */
420	greg	2.47	fputncomp(rval, stdout);
421			if (NCSAMP > 3)
422			fputwlsplit(WLPART, stdout);
423			if ((out_prims != stdprims) & (out_prims != NULL))
424			fputprims(out_prims, stdout);
425	greg	2.30	if ((outform == 'f') \| (outform == 'd'))
426			fputendian(stdout);
427	greg	2.1	fputformat(formstr(outform), stdout);
428	greg	2.47	fputc('\n', stdout); /* end of header */
429	greg	2.1	}
430
431	greg	2.32	if (!castonly) { /* any actual ray traversal to do? */
432
433			ray_init_pmap(); /* PMAP: set up & load photon maps */
434
435			marksources(); /* find and mark sources */
436
437			setambient(); /* initialize ambient calculation */
438	greg	2.33	} else
439			distantsources(); /* else mark only distant sources */
440	greg	2.35
441	greg	2.36	fflush(stdout); /* in case we're duplicating header */
442	greg	2.35
443	greg	2.1	#ifdef PERSIST
444			if (persist) {
445			/* reconnect stdout */
446			dup2(duped1, fileno(stdout));
447			close(duped1);
448			if (persist == PARALLEL) { /* multiprocessing */
449	greg	2.55	cow_memshare(); /* preloads scene */
450	greg	2.1	while ((rval=fork()) == 0) { /* keep on forkin' */
451			pflock(1);
452			pfhold();
453	greg	2.15	ambsync(); /* load new values */
454	greg	2.1	}
455			if (rval < 0)
456			error(SYSTEM, "cannot fork child for persist function");
457	greg	2.15	pfdetach(); /* parent will run then exit */
458	greg	2.1	}
459			}
460			runagain:
461			if (persist)
462			dupheader(); /* send header to stdout */
463			#endif
464			/* trace rays */
465	greg	2.19	rtrace(NULL, nproc);
466	greg	2.1	/* flush ambient file */
467			ambsync();
468			#ifdef PERSIST
469			if (persist == PERSIST) { /* first run-through */
470			if ((rval=fork()) == 0) { /* child loops until killed */
471			pflock(1);
472			persist = PCHILD;
473			} else { /* original process exits */
474			if (rval < 0)
475			error(SYSTEM, "cannot fork child for persist function");
476			pfdetach(); /* parent exits */
477			}
478			}
479			if (persist == PCHILD) { /* wait for a signal then go again */
480			pfhold();
481			raynum = nrays = 0; /* reinitialize */
482			goto runagain;
483			}
484			#endif
485	greg	2.23
486			ray_done_pmap(); /* PMAP: free photon maps */
487
488	greg	2.1	quit(0);
489
490			badopt:
491			sprintf(errmsg, "command line error at '%s'", argv[i]);
492			error(USER, errmsg);
493	schorsch	2.9	return 1; /* pro forma return */
494	greg	2.1
495			#undef check
496	schorsch	2.26	#undef check_bool
497	greg	2.1	}
498
499
500			void
501	schorsch	2.9	wputs( /* warning output function */
502	greg	2.44	const char *s
503	schorsch	2.9	)
504	greg	2.1	{
505			int lasterrno = errno;
506	greg	2.56	if (erract[WARNING].pf == NULL)
507			return; /* called by calcomp or someone */
508	greg	2.1	eputs(s);
509			errno = lasterrno;
510			}
511
512
513			void
514	schorsch	2.9	eputs( /* put string to stderr */
515	greg	2.44	const char *s
516	schorsch	2.9	)
517	greg	2.1	{
518			static int midline = 0;
519
520			if (!*s)
521			return;
522			if (!midline++) {
523			fputs(progname, stderr);
524			fputs(": ", stderr);
525			}
526			fputs(s, stderr);
527			if (s[strlen(s)-1] == '\n') {
528			fflush(stderr);
529			midline = 0;
530			}
531			}
532
533
534	schorsch	2.9	static void
535			onsig( /* fatal signal */
536			int signo
537			)
538	greg	2.1	{
539			static int gotsig = 0;
540
541			if (gotsig++) /* two signals and we're gone! */
542			_exit(signo);
543
544	schorsch	2.5	#ifdef SIGALRM
545	greg	2.1	alarm(15); /* allow 15 seconds to clean up */
546			signal(SIGALRM, SIG_DFL); /* make certain we do die */
547	schorsch	2.5	#endif
548	greg	2.1	eputs("signal - ");
549			eputs(sigerr[signo]);
550			eputs("\n");
551			quit(3);
552			}
553
554
555	schorsch	2.9	static void
556			sigdie( /* set fatal signal */
557			int signo,
558			char *msg
559			)
560	greg	2.1	{
561			if (signal(signo, onsig) == SIG_IGN)
562			signal(signo, SIG_IGN);
563			sigerr[signo] = msg;
564			}
565
566
567	schorsch	2.9	static void
568	schorsch	2.8	printdefaults(void) /* print default values to stdout */
569	greg	2.1	{
570	greg	2.38	char *cp;
571	greg	2.1
572	greg	2.49	printf(erract[WARNING].pf != NULL ?
573			"-w+\t\t\t\t# warning messages on\n" :
574			"-w-\t\t\t\t# warning messages off\n");
575	greg	2.1	if (imm_irrad)
576			printf("-I+\t\t\t\t# immediate irradiance on\n");
577	greg	2.18	printf("-n %-2d\t\t\t\t# number of rendering processes\n", nproc);
578	greg	2.21	printf("-x %-9d\t\t\t# %s\n", hresolu,
579			vresolu && hresolu ? "x resolution" : "flush interval");
580	greg	2.16	printf("-y %-9d\t\t\t# y resolution\n", vresolu);
581	greg	2.1	printf(lim_dist ? "-ld+\t\t\t\t# limit distance on\n" :
582			"-ld-\t\t\t\t# limit distance off\n");
583	greg	2.47	printf(loadflags & IO_INFO ? "-h+\t\t\t\t# output header\n" :
584			"-h-\t\t\t\t# no header\n");
585	greg	2.1	printf("-f%c%c\t\t\t\t# format input/output = %s/%s\n",
586			inform, outform, formstr(inform), formstr(outform));
587	greg	2.10	printf("-o%-9s\t\t\t# output", outvals);
588	greg	2.1	for (cp = outvals; *cp; cp++)
589			switch (*cp) {
590	greg	2.10	case 't': case 'T': printf(" trace"); break;
591	greg	2.1	case 'o': printf(" origin"); break;
592			case 'd': printf(" direction"); break;
593	greg	2.28	case 'r': printf(" reflect_contrib"); break;
594			case 'R': printf(" reflect_length"); break;
595			case 'x': printf(" unreflect_contrib"); break;
596			case 'X': printf(" unreflect_length"); break;
597	greg	2.1	case 'v': printf(" value"); break;
598	greg	2.13	case 'V': printf(" contribution"); break;
599	greg	2.1	case 'l': printf(" length"); break;
600			case 'L': printf(" first_length"); break;
601			case 'p': printf(" point"); break;
602			case 'n': printf(" normal"); break;
603			case 'N': printf(" unperturbed_normal"); break;
604			case 's': printf(" surface"); break;
605			case 'w': printf(" weight"); break;
606	greg	2.13	case 'W': printf(" coefficient"); break;
607	greg	2.1	case 'm': printf(" modifier"); break;
608	greg	2.10	case 'M': printf(" material"); break;
609	greg	2.37	case '~': printf(" tilde"); break;
610	greg	2.1	}
611	greg	2.47	fputc('\n', stdout);
612			if (sens_curve == scolor_photopic)
613			printf("-pY\t\t\t\t# photopic output\n");
614			else if (sens_curve == scolor_scotopic)
615			printf("-pS\t\t\t\t# scotopic output\n");
616			else if (sens_curve == scolor_melanopic)
617			printf("-pM\t\t\t\t# melanopic output\n");
618			else if (out_prims == stdprims)
619			printf("-pRGB\t\t\t\t# standard RGB color output\n");
620			else if (out_prims == xyzprims)
621			printf("-pXYZ\t\t\t\t# CIE XYZ color output\n");
622			else if (out_prims != NULL)
623			printf("-pc %.4f %.4f %.4f %.4f %.4f %.4f %.4f %.4f\t# output color primaries and white point\n",
624			out_prims[RED][0], out_prims[RED][1],
625			out_prims[GRN][0], out_prims[GRN][1],
626			out_prims[BLU][0], out_prims[BLU][1],
627			out_prims[WHT][0], out_prims[WHT][1]);
628	greg	2.53	if ((sens_curve == NULL) & (NCSAMP > 3))
629	greg	2.49	printf(out_prims != NULL ? "-co-\t\t\t\t# output tristimulus colors\n" :
630			"-co+\t\t\t\t# output spectral values\n");
631	greg	2.1	print_rdefaults();
632			}