src/hd/rholo.c

/* Copyright (c) 1997 Silicon Graphics, Inc. */

#ifndef lint
static char SCCSid[] = "$SunId$ SGI";
#endif

/*
 * Radiance holodeck generation controller
 */

#include "rholo.h"
#include "paths.h"
#include <sys/types.h>

                        /* the following must be consistent with rholo.h */
int     NVARS = NRHVARS;                /* total number of variables */

VARIABLE        vv[] = RHVINIT;         /* variable-value pairs */

char    *progname;              /* our program name */
char    *hdkfile;               /* holodeck file name */
char    froot[MAXPATH];         /* root file name */

int     nowarn = 0;             /* turn warnings off? */

double  expval = 1.;            /* global exposure value */

int     ncprocs = 0;            /* desired number of compute processes */

char    *outdev = NULL;         /* output device name */

time_t  starttime;              /* time we got started */
time_t  endtime;                /* time we should end by */
time_t  reporttime;             /* time for next report */

long    maxdisk;                /* maximum file space (bytes) */

int     rtargc = 1;             /* rtrace command */
char    *rtargv[128] = {"rtrace", NULL};

long    nraysdone = 0L;         /* number of rays done */
long    npacksdone = 0L;        /* number of packets done */

PACKET  *freepacks;             /* available packets */

extern time_t   time();


main(argc, argv)
int     argc;
char    *argv[];
{
        HDGRID  hdg;
        int     i;
        int     force = 0;
                                                /* mark start time */
        starttime = time(NULL);
        progname = argv[0];                     /* get arguments */
        for (i = 1; i < argc && argv[i][0] == '-'; i++)
                switch (argv[i][1]) {
                case 'w':                       /* turn off warnings */
                        nowarn++;
                        break;
                case 'f':                       /* force overwrite */
                        force++;
                        break;
                case 'n':                       /* compute processes */
                        if (i >= argc-2)
                                goto userr;
                        ncprocs = atoi(argv[++i]);
                        break;
                case 'o':                       /* output display */
                        if (i >= argc-2)
                                goto userr;
                        outdev = argv[++i];
                        break;
                default:
                        goto userr;
                }
                                                /* do we have a job? */
        if (outdev == NULL && ncprocs <= 0)
                goto userr;
                                                /* get root file name */
        rootname(froot, hdkfile=argv[i++]);
                                                /* load... */
        if (i < argc) {                         /* variables */
                loadvars(argv[i++]);
                                                        /* cmdline settings */
                for ( ; i < argc; i++)
                        if (setvariable(argv[i], matchvar) < 0) {
                                sprintf(errmsg, "unknown variable: %s",
                                                argv[i]);
                                error(USER, errmsg);
                        }
                                                        /* check settings */
                checkvalues();
                                                        /* load RIF if any */
                if (vdef(RIF))
                        getradfile(vval(RIF));
                                                        /* set defaults */
                setdefaults(&hdg);
                                                        /* holodeck exists? */
                if (!force && access(hdkfile, R_OK|W_OK) == 0)
                        error(USER,
                                "holodeck file exists -- use -f to overwrite");
                                                        /* create holodeck */
                creatholo(&hdg);
        } else {                                /* else load holodeck */
                loadholo();
                if (vdef(RIF))                          /* load RIF if any */
                        getradfile(vval(RIF));
        }
                                                /* initialize */
        initrholo();
                                                /* run */
        while (rholo())
                ;
                                                /* done */
        quit(0);
userr:
        fprintf(stderr,
"Usage: %s {-n nprocs|-o disp} [-w][-f] output.hdk [control.hif [VAR=val ..]]\n",
                        progname);
        quit(1);
}


initrholo()                     /* get our holodeck running */
{
        extern int      global_packet();
        register int    i;

        if (outdev != NULL)                     /* open output device */
                disp_open(outdev);
        else if (ncprocs > 0)                   /* else use global ray feed */
                init_global();
                                                /* record disk space limit */
        if (!vdef(DISKSPACE))
                maxdisk = 0;
        else
                maxdisk = 1024.*1024.*vflt(DISKSPACE);
                                                /* record end time */
        if (!vdef(TIME) || vflt(TIME) <= FTINY)
                endtime = 0;
        else
                endtime = starttime + vflt(TIME)*3600.;
                                                /* set up memory cache */
        if (outdev == NULL)
                hdcachesize = 0;        /* manual flushing */
        else if (vdef(CACHE))
                hdcachesize = 1024.*1024.*vflt(CACHE);
                                                /* open report file */
        if (vdef(REPORT)) {
                register char   *s = sskip2(vval(REPORT), 1);
                if (*s && freopen(s, "a", stderr) == NULL)
                        quit(2);
        }
                                                /* start rtrace */
        if (ncprocs > 0) {
                i = start_rtrace();
                if (i < 1)
                        error(USER, "cannot start rtrace process");
                if (vdef(REPORT)) {             /* make first report */
                        printargs(rtargc, rtargv, stderr);
                        report(0);
                }
                                                /* allocate packets */
                freepacks = (PACKET *)bmalloc(i*sizeof(PACKET));
                if (freepacks == NULL)
                        goto memerr;
                freepacks[--i].nr = 0;
                freepacks[i].next = NULL;
                if (!vbool(OBSTRUCTIONS)) {
                        freepacks[i].offset = (float *)bmalloc(
                                        RPACKSIZ*sizeof(float)*(i+1) );
                        if (freepacks[i].offset == NULL)
                                goto memerr;
                } else
                        freepacks[i].offset = NULL;
                while (i--) {
                        freepacks[i].nr = 0;
                        freepacks[i].offset = freepacks[i+1].offset == NULL ?
                                        NULL : freepacks[i+1].offset+RPACKSIZ ;
                        freepacks[i].next = &freepacks[i+1];
                }
        }
        return;
memerr:
        error(SYSTEM, "out of memory in initrholo");
}


rholo()                         /* holodeck main loop */
{
        static int      idle = 1;
        PACKET  *pl = NULL, *plend;
        register PACKET *p;
        time_t  t;
        long    l;

        if (outdev != NULL)             /* check display */
                if (!disp_check(idle))
                        return(0);
                                        /* display only? */
        if (ncprocs <= 0)
                return(1);
                                        /* check file size */
        if (maxdisk > 0 && hdfilen(hdlist[0]->fd) >= maxdisk) {
                error(WARNING, "file limit exceeded");
                return(0);
        }
                                        /* check time */
        if (endtime > 0 || reporttime > 0)
                t = time(NULL);
        if (endtime > 0 && t >= endtime) {
                error(WARNING, "time limit exceeded");
                return(0);
        }
        if (reporttime > 0 && t >= reporttime)
                report(t);
                                        /* get packets to process */
        while (freepacks != NULL) {
                p = freepacks; freepacks = p->next; p->next = NULL;
                if (!next_packet(p)) {
                        p->next = freepacks; freepacks = p;
                        break;
                }
                if (pl == NULL) pl = p;
                else plend->next = p;
                plend = p;
        }
        idle = pl == NULL && freepacks != NULL;
                                        /* are we out of stuff to do? */
        if (idle && outdev == NULL)
                return(0);
                                        /* else process packets */
        done_packets(do_packets(pl));
        return(1);                      /* and continue */
}


report(t)                       /* report progress so far */
time_t  t;
{
        if (t == 0)
                t = time(NULL);
        fprintf(stderr, "%s: %ld packets (%ld rays) done after %.2f hours\n",
                        progname, npacksdone, nraysdone, (t-starttime)/3600.);
        fflush(stderr);
        if (vdef(REPORT))
                reporttime = t + (time_t)(vflt(REPORT)*60.+.5);
}


setdefaults(gp)                 /* set default values */
register HDGRID *gp;
{
        extern char     *atos();
        register int    i;
        double  len[3], maxlen, d;
        char    buf[64];

        if (!vdef(SECTION)) {
                sprintf(errmsg, "%s must be defined", vnam(SECTION));
                error(USER, errmsg);
        }
        if (vdef(SECTION) > 1) {
                sprintf(errmsg, "ignoring all but first %s", vnam(SECTION));
                error(WARNING, errmsg);
        }
        if (sscanf(vval(SECTION),
                        "%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf",
                        &gp->orig[0], &gp->orig[1], &gp->orig[2],
                        &gp->xv[0][0], &gp->xv[0][1], &gp->xv[0][2],
                        &gp->xv[1][0], &gp->xv[1][1], &gp->xv[1][2],
                        &gp->xv[2][0], &gp->xv[2][1], &gp->xv[2][2]) != 12)
                badvalue(SECTION);
        maxlen = 0.;
        for (i = 0; i < 3; i++)
                if ((len[i] = VLEN(gp->xv[i])) > maxlen)
                        maxlen = len[i];
        if (!vdef(GRID)) {
                sprintf(buf, "%.4f", maxlen/8.);
                vval(GRID) = savqstr(buf);
                vdef(GRID)++;
        }
        if ((d = vflt(GRID)) <= FTINY)
                badvalue(GRID);
        for (i = 0; i < 3; i++)
                gp->grid[i] = len[i]/d + (1.-FTINY);
        if (!vdef(EXPOSURE)) {
                sprintf(errmsg, "%s must be defined", vnam(EXPOSURE));
                error(USER, errmsg);
        }
        expval = vval(EXPOSURE)[0] == '-' || vval(EXPOSURE)[0] == '+' ?
                        pow(2., vflt(EXPOSURE)) : vflt(EXPOSURE);
        if (!vdef(OCTREE)) {
                if ((vval(OCTREE) = bmalloc(strlen(froot)+5)) == NULL)
                        error(SYSTEM, "out of memory");
                sprintf(vval(OCTREE), "%s.oct", froot);
                vdef(OCTREE)++;
        }
        if (!vdef(OBSTRUCTIONS)) {
                vval(OBSTRUCTIONS) = "T";
                vdef(OBSTRUCTIONS)++;
        }
        if (!vdef(OCCUPANCY)) {
                vval(OCCUPANCY) = "U";
                vdef(OCCUPANCY)++;
        }
                                /* append rendering options */
        if (vdef(RENDER))
                rtargc += wordstring(rtargv+rtargc, vval(RENDER));
}


creatholo(gp)                   /* create a holodeck output file */
HDGRID  *gp;
{
        long    endloc = 0;
        FILE    *fp;
                                        /* open & truncate file */
        if ((fp = fopen(hdkfile, "w+")) == NULL) {
                sprintf(errmsg, "cannot open \"%s\" for writing", hdkfile);
                error(SYSTEM, errmsg);
        }
                                        /* write information header */
        newheader("RADIANCE", fp);
        printvars(fp);
        fputformat(HOLOFMT, fp);
        fputc('\n', fp);
        putw(HOLOMAGIC, fp);            /* put magic number & terminus */
        fwrite(&endloc, sizeof(long), 1, fp);
        fflush(fp);                     /* flush buffer */
        hdinit(fileno(fp), gp);         /* allocate and initialize index */
                        /* we're dropping fp here.... */
}


headline(s)                     /* process information header line */
char    *s;
{
        extern char     FMTSTR[];
        register char   *cp;
        char    fmt[32];

        if (formatval(fmt, s)) {
                if (strcmp(fmt, HOLOFMT)) {
                        sprintf(errmsg, "%s file \"%s\" has %s%s",
                                        HOLOFMT, hdkfile, FMTSTR, fmt);
                        error(USER, errmsg);
                }
                return;
        }
        for (cp = s; *cp; cp++)         /* take off any comments */
                if (*cp == '#') {
                        *cp = '\0';
                        break;
                }
        setvariable(s, matchvar);       /* don't flag errors */
}


loadholo()                      /* start loading a holodeck from fname */
{
        FILE    *fp;
        long    endloc;
                                        /* open holodeck file */
        if ((fp = fopen(hdkfile, ncprocs>0 ? "r+" : "r")) == NULL) {
                sprintf(errmsg, "cannot open \"%s\" for %s", hdkfile,
                                ncprocs>0 ? "appending" : "reading");
                error(SYSTEM, errmsg);
        }
                                        /* load variables from header */
        getheader(fp, headline, NULL);
                                        /* check magic number */
        if (getw(fp) != HOLOMAGIC) {
                sprintf(errmsg, "bad magic number in holodeck file \"%s\"",
                                hdkfile);
                error(USER, errmsg);
        }
        fread(&endloc, sizeof(long), 1, fp);
        if (endloc != 0)
                error(WARNING, "ignoring multiple sections in holodeck file");
        fseek(fp, 0L, 1);                       /* align system file pointer */
        hdinit(fileno(fp), NULL);               /* allocate and load index */
                        /* we're dropping fp here.... */
}


done_packets(pl)                /* handle finished packets */
PACKET  *pl;
{
        static int      nunflushed = 0;
        register PACKET *p;

        while (pl != NULL) {
                p = pl; pl = p->next; p->next = NULL;
                if (p->nr > 0) {                /* add to holodeck */
                        bcopy((char *)p->ra,
                                (char *)hdnewrays(hdlist[p->hd],p->bi,p->nr),
                                p->nr*sizeof(RAYVAL));
                        if (outdev != NULL)     /* display it */
                                disp_packet((PACKHEAD *)p);
                        else
                                nunflushed += p->nr;
                        nraysdone += p->nr;
                        npacksdone++;
                }
                p->nr = 0;                      /* push onto free list */
                p->next = freepacks;
                freepacks = p;
        }
        if (nunflushed >= 256*RPACKSIZ) {
                hdflush(NULL);                  /* flush holodeck buffers */
                nunflushed = 0;
        }
}


getradfile(rfargs)              /* run rad and get needed variables */
char    *rfargs;
{
        static short    mvar[] = {OCTREE,EXPOSURE,-1};
        static char     tf1[] = TEMPLATE;
        char    tf2[64];
        char    combuf[256];
        char    *pippt;
        register int    i;
        register char   *cp;
                                        /* create rad command */
        mktemp(tf1);
        sprintf(tf2, "%s.rif", tf1);
        sprintf(combuf,
                "rad -v 0 -s -e -w %s OPTFILE=%s | egrep '^[ \t]*(NOMATCH",
                        rfargs, tf1);
        cp = combuf;
        while (*cp){
                if (*cp == '|') pippt = cp;
                cp++;
        }                               /* match unset variables */
        for (i = 0; mvar[i] >= 0; i++)
                if (!vdef(mvar[i])) {
                        *cp++ = '|';
                        strcpy(cp, vnam(mvar[i]));
                        while (*cp) cp++;
                        pippt = NULL;
                }
        if (pippt != NULL)
                strcpy(pippt, "> /dev/null");   /* nothing to match */
        else
                sprintf(cp, ")[ \t]*=' > %s", tf2);
        if (system(combuf)) {
                error(SYSTEM, "cannot execute rad command");
                unlink(tf2);                    /* clean up */
                unlink(tf1);
                quit(1);
        }
        if (pippt == NULL) {
                loadvars(tf2);                  /* load variables */
                unlink(tf2);
        }
        rtargc += wordfile(rtargv+rtargc, tf1); /* get rtrace options */
        unlink(tf1);                    /* clean up */
}


rootname(rn, fn)                /* remove tail from end of fn */
register char   *rn, *fn;
{
        char    *tp, *dp;

        for (tp = NULL, dp = rn; *rn = *fn++; rn++)
                if (ISDIRSEP(*rn))
                        dp = rn;
                else if (*rn == '.')
                        tp = rn;
        if (tp != NULL && tp > dp)
                *tp = '\0';
}


badvalue(vc)                    /* report bad variable value and exit */
int     vc;
{
        sprintf(errmsg, "bad value for variable '%s'", vnam(vc));
        error(USER, errmsg);
}


eputs(s)                        /* put error message to stderr */
register char  *s;
{
        static int  midline = 0;

        if (!*s)
                return;
        if (!midline++) {       /* prepend line with program name */
                fputs(progname, stderr);
                fputs(": ", stderr);
        }
        fputs(s, stderr);
        if (s[strlen(s)-1] == '\n') {
                fflush(stderr);
                midline = 0;
        }
}


wputs(s)                        /* put warning string to stderr */
char    *s;
{
        if (!nowarn)
                eputs(s);
}


quit(ec)                        /* exit program gracefully */
int     ec;
{
        int     status = 0;

        if (outdev != NULL)             /* close display */
                disp_close();
        if (hdlist[0] != NULL) {        /* flush holodeck */
                if (ncprocs > 0) {
                        done_packets(flush_queue());
                        status = end_rtrace();  /* close rtrace */
                        hdflush(NULL);
                        if (vdef(REPORT)) {
                                long    fsiz, fuse;
                                report(0);
                                fsiz = hdfilen(hdlist[0]->fd);
                                fuse = hdfiluse(hdlist[0]->fd, 1);
                                fprintf(stderr,
                        "%s: %.1f Mbyte holodeck file, %.1f%% fragmentation\n",
                                                hdkfile, fsiz/(1024.*1024.),
                                                100.*(fsiz-fuse)/fsiz);
                        }
                } else
                        hdflush(NULL);
        }
        exit(ec ? ec : status);         /* exit */
}
Revision:	3.9
Committed:	Tue Nov 11 11:31:54 1997 UTC (28 years ago) by gregl
Content type:	text/plain
Branch:	MAIN
Changes since 3.8:	+4 -4 lines
Log Message:	made file length testing more efficient
#	User	Rev	Content
1	gregl	3.1	/* Copyright (c) 1997 Silicon Graphics, Inc. */
2
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ SGI";
5			#endif
6
7			/*
8			* Radiance holodeck generation controller
9			*/
10
11			#include "rholo.h"
12			#include "paths.h"
13			#include <sys/types.h>
14
15			/* the following must be consistent with rholo.h */
16			int NVARS = NRHVARS; /* total number of variables */
17
18			VARIABLE vv[] = RHVINIT; /* variable-value pairs */
19
20			char progname; / our program name */
21			char hdkfile; / holodeck file name */
22			char froot[MAXPATH]; /* root file name */
23
24			int nowarn = 0; /* turn warnings off? */
25
26			double expval = 1.; /* global exposure value */
27
28			int ncprocs = 0; /* desired number of compute processes */
29
30			char outdev = NULL; / output device name */
31
32			time_t starttime; /* time we got started */
33			time_t endtime; /* time we should end by */
34			time_t reporttime; /* time for next report */
35
36	gregl	3.8	long maxdisk; /* maximum file space (bytes) */
37
38	gregl	3.1	int rtargc = 1; /* rtrace command */
39			char *rtargv[128] = {"rtrace", NULL};
40
41			long nraysdone = 0L; /* number of rays done */
42			long npacksdone = 0L; /* number of packets done */
43
44			PACKET freepacks; / available packets */
45
46			extern time_t time();
47
48
49			main(argc, argv)
50			int argc;
51			char *argv[];
52			{
53			HDGRID hdg;
54			int i;
55			int force = 0;
56	gregl	3.3	/* mark start time */
57			starttime = time(NULL);
58	gregl	3.1	progname = argv[0]; /* get arguments */
59			for (i = 1; i < argc && argv[i][0] == '-'; i++)
60			switch (argv[i][1]) {
61			case 'w': /* turn off warnings */
62			nowarn++;
63			break;
64			case 'f': /* force overwrite */
65			force++;
66			break;
67			case 'n': /* compute processes */
68			if (i >= argc-2)
69			goto userr;
70			ncprocs = atoi(argv[++i]);
71			break;
72			case 'o': /* output display */
73			if (i >= argc-2)
74			goto userr;
75			outdev = argv[++i];
76			break;
77			default:
78			goto userr;
79			}
80			/* do we have a job? */
81			if (outdev == NULL && ncprocs <= 0)
82			goto userr;
83			/* get root file name */
84			rootname(froot, hdkfile=argv[i++]);
85			/* load... */
86			if (i < argc) { /* variables */
87			loadvars(argv[i++]);
88			/* cmdline settings */
89			for ( ; i < argc; i++)
90			if (setvariable(argv[i], matchvar) < 0) {
91			sprintf(errmsg, "unknown variable: %s",
92			argv[i]);
93			error(USER, errmsg);
94			}
95			/* check settings */
96			checkvalues();
97			/* load RIF if any */
98			if (vdef(RIF))
99			getradfile(vval(RIF));
100			/* set defaults */
101			setdefaults(&hdg);
102			/* holodeck exists? */
103			if (!force && access(hdkfile, R_OK\|W_OK) == 0)
104			error(USER,
105			"holodeck file exists -- use -f to overwrite");
106			/* create holodeck */
107			creatholo(&hdg);
108	gregl	3.3	} else { /* else load holodeck */
109	gregl	3.1	loadholo();
110	gregl	3.3	if (vdef(RIF)) /* load RIF if any */
111			getradfile(vval(RIF));
112			}
113	gregl	3.1	/* initialize */
114			initrholo();
115			/* run */
116			while (rholo())
117			;
118			/* done */
119			quit(0);
120			userr:
121			fprintf(stderr,
122			"Usage: %s {-n nprocs\|-o disp} [-w][-f] output.hdk [control.hif [VAR=val ..]]\n",
123			progname);
124			quit(1);
125			}
126
127
128			initrholo() /* get our holodeck running */
129			{
130			extern int global_packet();
131			register int i;
132	gregl	3.4
133			if (outdev != NULL) /* open output device */
134			disp_open(outdev);
135	gregl	3.1	else if (ncprocs > 0) /* else use global ray feed */
136			init_global();
137	gregl	3.8	/* record disk space limit */
138			if (!vdef(DISKSPACE))
139			maxdisk = 0;
140			else
141	gregl	3.9	maxdisk = 1024.1024.vflt(DISKSPACE);
142	gregl	3.3	/* record end time */
143	gregl	3.1	if (!vdef(TIME) \|\| vflt(TIME) <= FTINY)
144			endtime = 0;
145			else
146			endtime = starttime + vflt(TIME)*3600.;
147			/* set up memory cache */
148	gregl	3.5	if (outdev == NULL)
149			hdcachesize = 0; /* manual flushing */
150			else if (vdef(CACHE))
151			hdcachesize = 1024.1024.vflt(CACHE);
152	gregl	3.1	/* open report file */
153			if (vdef(REPORT)) {
154			register char *s = sskip2(vval(REPORT), 1);
155			if (*s && freopen(s, "a", stderr) == NULL)
156			quit(2);
157			}
158			/* start rtrace */
159			if (ncprocs > 0) {
160			i = start_rtrace();
161			if (i < 1)
162			error(USER, "cannot start rtrace process");
163			if (vdef(REPORT)) { /* make first report */
164			printargs(rtargc, rtargv, stderr);
165			report(0);
166			}
167			/* allocate packets */
168			freepacks = (PACKET )bmalloc(isizeof(PACKET));
169			if (freepacks == NULL)
170			goto memerr;
171			freepacks[--i].nr = 0;
172			freepacks[i].next = NULL;
173			if (!vbool(OBSTRUCTIONS)) {
174			freepacks[i].offset = (float *)bmalloc(
175			RPACKSIZsizeof(float)(i+1) );
176			if (freepacks[i].offset == NULL)
177			goto memerr;
178			} else
179			freepacks[i].offset = NULL;
180			while (i--) {
181			freepacks[i].nr = 0;
182			freepacks[i].offset = freepacks[i+1].offset == NULL ?
183			NULL : freepacks[i+1].offset+RPACKSIZ ;
184			freepacks[i].next = &freepacks[i+1];
185			}
186			}
187			return;
188			memerr:
189			error(SYSTEM, "out of memory in initrholo");
190			}
191
192
193			rholo() /* holodeck main loop */
194			{
195			static int idle = 1;
196			PACKET pl = NULL, plend;
197			register PACKET *p;
198			time_t t;
199			long l;
200	gregl	3.4
201			if (outdev != NULL) /* check display */
202			if (!disp_check(idle))
203			return(0);
204	gregl	3.1	/* display only? */
205			if (ncprocs <= 0)
206			return(1);
207			/* check file size */
208	gregl	3.9	if (maxdisk > 0 && hdfilen(hdlist[0]->fd) >= maxdisk) {
209	gregl	3.8	error(WARNING, "file limit exceeded");
210	gregl	3.1	return(0);
211	gregl	3.8	}
212	gregl	3.1	/* check time */
213	gregl	3.3	if (endtime > 0 \|\| reporttime > 0)
214	gregl	3.1	t = time(NULL);
215	gregl	3.8	if (endtime > 0 && t >= endtime) {
216			error(WARNING, "time limit exceeded");
217	gregl	3.1	return(0);
218	gregl	3.8	}
219	gregl	3.3	if (reporttime > 0 && t >= reporttime)
220	gregl	3.1	report(t);
221			/* get packets to process */
222			while (freepacks != NULL) {
223			p = freepacks; freepacks = p->next; p->next = NULL;
224			if (!next_packet(p)) {
225			p->next = freepacks; freepacks = p;
226			break;
227			}
228			if (pl == NULL) pl = p;
229			else plend->next = p;
230			plend = p;
231			}
232			idle = pl == NULL && freepacks != NULL;
233			/* are we out of stuff to do? */
234			if (idle && outdev == NULL)
235			return(0);
236			/* else process packets */
237			done_packets(do_packets(pl));
238			return(1); /* and continue */
239			}
240
241
242			report(t) /* report progress so far */
243			time_t t;
244			{
245			if (t == 0)
246			t = time(NULL);
247	gregl	3.2	fprintf(stderr, "%s: %ld packets (%ld rays) done after %.2f hours\n",
248	gregl	3.1	progname, npacksdone, nraysdone, (t-starttime)/3600.);
249	gregl	3.2	fflush(stderr);
250	gregl	3.3	if (vdef(REPORT))
251			reporttime = t + (time_t)(vflt(REPORT)*60.+.5);
252	gregl	3.1	}
253
254
255			setdefaults(gp) /* set default values */
256			register HDGRID *gp;
257			{
258			extern char *atos();
259			register int i;
260			double len[3], maxlen, d;
261			char buf[64];
262
263			if (!vdef(SECTION)) {
264			sprintf(errmsg, "%s must be defined", vnam(SECTION));
265			error(USER, errmsg);
266			}
267			if (vdef(SECTION) > 1) {
268			sprintf(errmsg, "ignoring all but first %s", vnam(SECTION));
269			error(WARNING, errmsg);
270			}
271			if (sscanf(vval(SECTION),
272			"%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf",
273			&gp->orig[0], &gp->orig[1], &gp->orig[2],
274			&gp->xv[0][0], &gp->xv[0][1], &gp->xv[0][2],
275			&gp->xv[1][0], &gp->xv[1][1], &gp->xv[1][2],
276			&gp->xv[2][0], &gp->xv[2][1], &gp->xv[2][2]) != 12)
277			badvalue(SECTION);
278			maxlen = 0.;
279			for (i = 0; i < 3; i++)
280			if ((len[i] = VLEN(gp->xv[i])) > maxlen)
281			maxlen = len[i];
282			if (!vdef(GRID)) {
283	gregl	3.2	sprintf(buf, "%.4f", maxlen/8.);
284	gregl	3.1	vval(GRID) = savqstr(buf);
285			vdef(GRID)++;
286			}
287			if ((d = vflt(GRID)) <= FTINY)
288			badvalue(GRID);
289			for (i = 0; i < 3; i++)
290			gp->grid[i] = len[i]/d + (1.-FTINY);
291			if (!vdef(EXPOSURE)) {
292			sprintf(errmsg, "%s must be defined", vnam(EXPOSURE));
293			error(USER, errmsg);
294			}
295			expval = vval(EXPOSURE)[0] == '-' \|\| vval(EXPOSURE)[0] == '+' ?
296			pow(2., vflt(EXPOSURE)) : vflt(EXPOSURE);
297			if (!vdef(OCTREE)) {
298			if ((vval(OCTREE) = bmalloc(strlen(froot)+5)) == NULL)
299			error(SYSTEM, "out of memory");
300			sprintf(vval(OCTREE), "%s.oct", froot);
301			vdef(OCTREE)++;
302			}
303			if (!vdef(OBSTRUCTIONS)) {
304			vval(OBSTRUCTIONS) = "T";
305			vdef(OBSTRUCTIONS)++;
306			}
307			if (!vdef(OCCUPANCY)) {
308			vval(OCCUPANCY) = "U";
309			vdef(OCCUPANCY)++;
310			}
311			/* append rendering options */
312			if (vdef(RENDER))
313			rtargc += wordstring(rtargv+rtargc, vval(RENDER));
314			}
315
316
317			creatholo(gp) /* create a holodeck output file */
318			HDGRID *gp;
319			{
320			long endloc = 0;
321			FILE *fp;
322			/* open & truncate file */
323			if ((fp = fopen(hdkfile, "w+")) == NULL) {
324			sprintf(errmsg, "cannot open \"%s\" for writing", hdkfile);
325			error(SYSTEM, errmsg);
326			}
327			/* write information header */
328			newheader("RADIANCE", fp);
329			printvars(fp);
330			fputformat(HOLOFMT, fp);
331			fputc('\n', fp);
332			putw(HOLOMAGIC, fp); /* put magic number & terminus */
333			fwrite(&endloc, sizeof(long), 1, fp);
334			fflush(fp); /* flush buffer */
335	gregl	3.2	hdinit(fileno(fp), gp); /* allocate and initialize index */
336	gregl	3.1	/* we're dropping fp here.... */
337			}
338
339
340			headline(s) /* process information header line */
341			char *s;
342			{
343			extern char FMTSTR[];
344			register char *cp;
345			char fmt[32];
346
347	gregl	3.2	if (formatval(fmt, s)) {
348	gregl	3.1	if (strcmp(fmt, HOLOFMT)) {
349			sprintf(errmsg, "%s file \"%s\" has %s%s",
350			HOLOFMT, hdkfile, FMTSTR, fmt);
351			error(USER, errmsg);
352			}
353			return;
354			}
355			for (cp = s; cp; cp++) / take off any comments */
356			if (*cp == '#') {
357			*cp = '\0';
358			break;
359			}
360			setvariable(s, matchvar); /* don't flag errors */
361			}
362
363
364			loadholo() /* start loading a holodeck from fname */
365			{
366			FILE *fp;
367			long endloc;
368	gregl	3.4	/* open holodeck file */
369			if ((fp = fopen(hdkfile, ncprocs>0 ? "r+" : "r")) == NULL) {
370			sprintf(errmsg, "cannot open \"%s\" for %s", hdkfile,
371			ncprocs>0 ? "appending" : "reading");
372	gregl	3.1	error(SYSTEM, errmsg);
373			}
374			/* load variables from header */
375			getheader(fp, headline, NULL);
376			/* check magic number */
377			if (getw(fp) != HOLOMAGIC) {
378			sprintf(errmsg, "bad magic number in holodeck file \"%s\"",
379			hdkfile);
380			error(USER, errmsg);
381			}
382			fread(&endloc, sizeof(long), 1, fp);
383			if (endloc != 0)
384			error(WARNING, "ignoring multiple sections in holodeck file");
385			fseek(fp, 0L, 1); /* align system file pointer */
386	gregl	3.2	hdinit(fileno(fp), NULL); /* allocate and load index */
387	gregl	3.1	/* we're dropping fp here.... */
388			}
389
390
391			done_packets(pl) /* handle finished packets */
392			PACKET *pl;
393			{
394	gregl	3.5	static int nunflushed = 0;
395	gregl	3.1	register PACKET *p;
396
397			while (pl != NULL) {
398			p = pl; pl = p->next; p->next = NULL;
399			if (p->nr > 0) { /* add to holodeck */
400			bcopy((char *)p->ra,
401			(char *)hdnewrays(hdlist[p->hd],p->bi,p->nr),
402			p->nr*sizeof(RAYVAL));
403			if (outdev != NULL) /* display it */
404	gregl	3.7	disp_packet((PACKHEAD *)p);
405	gregl	3.5	else
406			nunflushed += p->nr;
407	gregl	3.6	nraysdone += p->nr;
408			npacksdone++;
409	gregl	3.1	}
410			p->nr = 0; /* push onto free list */
411			p->next = freepacks;
412			freepacks = p;
413	gregl	3.5	}
414			if (nunflushed >= 256*RPACKSIZ) {
415			hdflush(NULL); /* flush holodeck buffers */
416			nunflushed = 0;
417	gregl	3.1	}
418			}
419
420
421			getradfile(rfargs) /* run rad and get needed variables */
422			char *rfargs;
423			{
424	gregl	3.9	static short mvar[] = {OCTREE,EXPOSURE,-1};
425	gregl	3.1	static char tf1[] = TEMPLATE;
426			char tf2[64];
427			char combuf[256];
428	gregl	3.3	char *pippt;
429	gregl	3.1	register int i;
430			register char *cp;
431			/* create rad command */
432			mktemp(tf1);
433			sprintf(tf2, "%s.rif", tf1);
434			sprintf(combuf,
435			"rad -v 0 -s -e -w %s OPTFILE=%s \| egrep '^[ \t]*(NOMATCH",
436			rfargs, tf1);
437			cp = combuf;
438	gregl	3.3	while (*cp){
439			if (*cp == '\|') pippt = cp;
440			cp++;
441			} /* match unset variables */
442	gregl	3.1	for (i = 0; mvar[i] >= 0; i++)
443			if (!vdef(mvar[i])) {
444			*cp++ = '\|';
445			strcpy(cp, vnam(mvar[i]));
446			while (*cp) cp++;
447	gregl	3.3	pippt = NULL;
448	gregl	3.1	}
449	gregl	3.3	if (pippt != NULL)
450			strcpy(pippt, "> /dev/null"); /* nothing to match */
451			else
452			sprintf(cp, ")[ \t]*=' > %s", tf2);
453	gregl	3.1	if (system(combuf)) {
454			error(SYSTEM, "cannot execute rad command");
455			unlink(tf2); /* clean up */
456			unlink(tf1);
457			quit(1);
458			}
459	gregl	3.3	if (pippt == NULL) {
460			loadvars(tf2); /* load variables */
461			unlink(tf2);
462			}
463	gregl	3.1	rtargc += wordfile(rtargv+rtargc, tf1); /* get rtrace options */
464	gregl	3.3	unlink(tf1); /* clean up */
465	gregl	3.1	}
466
467
468			rootname(rn, fn) /* remove tail from end of fn */
469			register char rn, fn;
470			{
471			char tp, dp;
472
473			for (tp = NULL, dp = rn; rn = fn++; rn++)
474			if (ISDIRSEP(*rn))
475			dp = rn;
476			else if (*rn == '.')
477			tp = rn;
478			if (tp != NULL && tp > dp)
479			*tp = '\0';
480			}
481
482
483			badvalue(vc) /* report bad variable value and exit */
484			int vc;
485			{
486			sprintf(errmsg, "bad value for variable '%s'", vnam(vc));
487			error(USER, errmsg);
488			}
489
490
491			eputs(s) /* put error message to stderr */
492			register char *s;
493			{
494			static int midline = 0;
495
496			if (!*s)
497			return;
498			if (!midline++) { /* prepend line with program name */
499			fputs(progname, stderr);
500			fputs(": ", stderr);
501			}
502			fputs(s, stderr);
503			if (s[strlen(s)-1] == '\n') {
504			fflush(stderr);
505			midline = 0;
506			}
507			}
508
509
510			wputs(s) /* put warning string to stderr */
511			char *s;
512			{
513			if (!nowarn)
514			eputs(s);
515			}
516
517
518			quit(ec) /* exit program gracefully */
519			int ec;
520			{
521			int status = 0;
522
523	gregl	3.4	if (outdev != NULL) /* close display */
524			disp_close();
525	gregl	3.1	if (hdlist[0] != NULL) { /* flush holodeck */
526			if (ncprocs > 0) {
527			done_packets(flush_queue());
528			status = end_rtrace(); /* close rtrace */
529			hdflush(NULL);
530			if (vdef(REPORT)) {
531			long fsiz, fuse;
532			report(0);
533	gregl	3.9	fsiz = hdfilen(hdlist[0]->fd);
534	gregl	3.1	fuse = hdfiluse(hdlist[0]->fd, 1);
535			fprintf(stderr,
536	gregl	3.3	"%s: %.1f Mbyte holodeck file, %.1f%% fragmentation\n",
537	gregl	3.1	hdkfile, fsiz/(1024.*1024.),
538			100.*(fsiz-fuse)/fsiz);
539			}
540			} else
541			hdflush(NULL);
542			}
543			exit(ec ? ec : status); /* exit */
544			}