--- ray/src/rt/rtrace.c 1990/08/18 10:34:47 1.11 +++ ray/src/rt/rtrace.c 2009/12/14 07:31:37 2.62 @@ -1,15 +1,12 @@ -/* Copyright (c) 1986 Regents of the University of California */ - #ifndef lint -static char SCCSid[] = "$SunId$ LBL"; +static const char RCSid[] = "$Id: rtrace.c,v 2.62 2009/12/14 07:31:37 greg Exp $"; #endif - /* * rtrace.c - program and variables for individual ray tracing. - * - * 6/11/86 */ +#include "copyright.h" + /* * Input is in the form: * @@ -20,65 +17,107 @@ static char SCCSid[] = "$SunId$ LBL"; * All values default to ascii representation of real * numbers. Binary representations can be selected * with '-ff' for float or '-fd' for double. By default, - * radiance is computed. The '-i' option indicates that + * radiance is computed. The '-i' or '-I' options indicate that * irradiance values are desired. */ -#include "ray.h" +#include -#include "octree.h" - +#include "platform.h" +#include "ray.h" +#include "ambient.h" +#include "source.h" #include "otypes.h" +#include "resolu.h" +#include "random.h" -int inform = 'a'; /* input format */ -int outform = 'a'; /* output format */ -char *outvals = "v"; /* output specification */ +extern int inform; /* input format */ +extern int outform; /* output format */ +extern char *outvals; /* output values */ -int hresolu = 0; /* horizontal (scan) size */ -int vresolu = 0; /* vertical resolution */ +extern int imm_irrad; /* compute immediate irradiance? */ +extern int lim_dist; /* limit distance? */ -double dstrsrc = 0.0; /* square source distribution */ -double shadthresh = .05; /* shadow threshold */ -double shadcert = .5; /* shadow certainty */ +extern char *tralist[]; /* list of modifers to trace (or no) */ +extern int traincl; /* include == 1, exclude == 0 */ -int maxdepth = 6; /* maximum recursion depth */ -double minweight = 4e-3; /* minimum ray weight */ +extern int hresolu; /* horizontal resolution */ +extern int vresolu; /* vertical resolution */ -COLOR ambval = BLKCOLOR; /* ambient value */ -double ambacc = 0.2; /* ambient accuracy */ -int ambres = 32; /* ambient resolution */ -int ambdiv = 128; /* ambient divisions */ -int ambssamp = 0; /* ambient super-samples */ -int ambounce = 0; /* ambient bounces */ -char *amblist[128]; /* ambient include/exclude list */ -int ambincl = -1; /* include == 1, exclude == 0 */ +static int castonly = 0; +#ifndef MAXTSET +#define MAXTSET 8191 /* maximum number in trace set */ +#endif +OBJECT traset[MAXTSET+1]={0}; /* trace include/exclude set */ + static RAY thisray; /* for our convenience */ -static int oputo(), oputd(), oputv(), oputl(), - oputp(), oputn(), oputs(), oputw(), oputm(); +typedef void putf_t(double v); +static putf_t puta, putd, putf; -static int (*ray_out[10])(), (*every_out[10])(); -static int castonly; +typedef void oputf_t(RAY *r); +static oputf_t oputo, oputd, oputv, oputV, oputl, oputL, oputc, oputp, + oputn, oputN, oputs, oputw, oputW, oputm, oputM, oputtilde; -static int puta(), putf(), putd(); +static void setoutput(char *vs); +extern void tranotify(OBJECT obj); +static void bogusray(void); +static void raycast(RAY *r); +static void rayirrad(RAY *r); +static void rtcompute(FVECT org, FVECT dir, double dmax); +static int printvals(RAY *r); +static int getvec(FVECT vec, int fmt, FILE *fp); +static void tabin(RAY *r); +static void ourtrace(RAY *r); -static int (*putreal)(); +static oputf_t *ray_out[16], *every_out[16]; +static putf_t *putreal; -quit(code) /* quit program */ -int code; +void +quit( /* quit program */ + int code +) { + if (ray_pnprocs > 0) /* close children if any */ + ray_pclose(0); +#ifndef NON_POSIX + else if (!ray_pnprocs) { + headclean(); /* delete header file */ + pfclean(); /* clean up persist files */ + } +#endif exit(code); } -rtrace(fname) /* trace rays from file */ -char *fname; +char * +formstr( /* return format identifier */ + int f +) { - long vcount = hresolu>1 ? hresolu*vresolu : vresolu; + switch (f) { + case 'a': return("ascii"); + case 'f': return("float"); + case 'd': return("double"); + case 'c': return(COLRFMT); + } + return("unknown"); +} + + +extern void +rtrace( /* trace rays from file */ + char *fname, + int nproc +) +{ + unsigned long vcount = (hresolu > 1) ? (unsigned long)hresolu*vresolu + : vresolu; long nextflush = hresolu; FILE *fp; + double d; FVECT orig, direc; /* set up input */ if (fname == NULL) @@ -87,52 +126,102 @@ char *fname; sprintf(errmsg, "cannot open input file \"%s\"", fname); error(SYSTEM, errmsg); } + if (inform != 'a') + SET_FILE_BINARY(fp); /* set up output */ setoutput(outvals); + if (imm_irrad) + castonly = 0; + else if (castonly) + nproc = 1; /* don't bother multiprocessing */ switch (outform) { case 'a': putreal = puta; break; case 'f': putreal = putf; break; case 'd': putreal = putd; break; + case 'c': + if (strcmp(outvals, "v")) + error(USER, "color format with value output only"); + break; + default: + error(CONSISTENCY, "botched output format"); } + if (nproc > 1) { /* start multiprocessing */ + ray_popen(nproc); + ray_fifo_out = printvals; + } + if (hresolu > 0) { + if (vresolu > 0) + fprtresolu(hresolu, vresolu, stdout); + fflush(stdout); + } /* process file */ while (getvec(orig, inform, fp) == 0 && getvec(direc, inform, fp) == 0) { - if (normalize(direc) == 0.0) { /* zero ==> flush */ - fflush(stdout); - continue; - } - /* compute and print */ - if (outvals[0] == 'i') - irrad(orig, direc); - else - radiance(orig, direc); + d = normalize(direc); + if (d == 0.0) { /* zero ==> flush */ + if (nproc > 1 && ray_fifo_flush() < 0) + error(USER, "lost children"); + bogusray(); + if (--nextflush <= 0 || !vcount) { + fflush(stdout); + nextflush = hresolu; + } + } else { /* compute and print */ + rtcompute(orig, direc, lim_dist ? d : 0.0); /* flush if time */ - if (--nextflush == 0) { - fflush(stdout); - nextflush = hresolu; + if (!--nextflush) { + if (nproc > 1 && ray_fifo_flush() < 0) + error(USER, "lost children"); + fflush(stdout); + nextflush = hresolu; + } } if (ferror(stdout)) error(SYSTEM, "write error"); - if (--vcount == 0) /* check for end */ + if (vcount && !--vcount) /* check for end */ break; } - if (vcount > 0) - error(USER, "read error"); - fclose(fp); + if (nproc > 1) { /* clean up children */ + if (ray_fifo_flush() < 0) + error(USER, "unable to complete processing"); + ray_pclose(0); + } + if (fflush(stdout) < 0) + error(SYSTEM, "write error"); + if (vcount) + error(USER, "unexpected EOF on input"); + if (fname != NULL) + fclose(fp); } -setoutput(vs) /* set up output tables */ -register char *vs; +static void +trace_sources(void) /* trace rays to light sources, also */ { - extern int ourtrace(), (*trace)(); - register int (**table)() = ray_out; + int sn; + + for (sn = 0; sn < nsources; sn++) + source[sn].sflags |= SFOLLOW; +} + +static void +setoutput( /* set up output tables */ + char *vs +) +{ + oputf_t **table = ray_out; + castonly = 1; while (*vs) switch (*vs++) { + case 'T': /* trace sources */ + if (!*vs) break; + trace_sources(); + /* fall through */ case 't': /* trace */ + if (!*vs) break; *table = NULL; table = every_out; trace = ourtrace; @@ -148,136 +237,260 @@ register char *vs; *table++ = oputv; castonly = 0; break; - case 'l': /* length */ + case 'V': /* contribution */ + *table++ = oputV; + if (ambounce > 0 && (ambacc > FTINY || ambssamp > 0)) + error(WARNING, + "-otV accuracy depends on -aa 0 -as 0"); + break; + case 'l': /* effective distance */ *table++ = oputl; castonly = 0; break; + case 'c': /* local coordinates */ + *table++ = oputc; + break; + case 'L': /* single ray length */ + *table++ = oputL; + break; case 'p': /* point */ *table++ = oputp; break; - case 'n': /* normal */ + case 'n': /* perturbed normal */ *table++ = oputn; + castonly = 0; break; + case 'N': /* unperturbed normal */ + *table++ = oputN; + break; case 's': /* surface */ *table++ = oputs; break; case 'w': /* weight */ *table++ = oputw; break; + case 'W': /* coefficient */ + *table++ = oputW; + if (ambounce > 0 && (ambacc > FTINY || ambssamp > 0)) + error(WARNING, + "-otW accuracy depends on -aa 0 -as 0"); + break; case 'm': /* modifier */ *table++ = oputm; break; + case 'M': /* material */ + *table++ = oputM; + break; + case '~': /* tilde */ + *table++ = oputtilde; + break; } *table = NULL; } -radiance(org, dir) /* compute radiance value */ -FVECT org, dir; +static void +bogusray(void) /* print out empty record */ { - register int (**tp)(); + thisray.rorg[0] = thisray.rorg[1] = thisray.rorg[2] = + thisray.rdir[0] = thisray.rdir[1] = thisray.rdir[2] = 0.0; + thisray.rmax = 0.0; + rayorigin(&thisray, PRIMARY, NULL, NULL); + printvals(&thisray); +} - VCOPY(thisray.rorg, org); - VCOPY(thisray.rdir, dir); - rayorigin(&thisray, NULL, PRIMARY, 1.0); - if (castonly) - localhit(&thisray, &thescene) || sourcehit(&thisray); - else - rayvalue(&thisray); - if (ray_out[0] == NULL) - return; - for (tp = ray_out; *tp != NULL; tp++) - (**tp)(&thisray); - if (outform == 'a') - putchar('\n'); +static void +raycast( /* compute first ray intersection only */ + RAY *r +) +{ + if (!localhit(r, &thescene)) { + if (r->ro == &Aftplane) { /* clipped */ + r->ro = NULL; + r->rot = FHUGE; + } else + sourcehit(r); + } } -irrad(org, dir) /* compute irradiance value */ -FVECT org, dir; +static void +rayirrad( /* compute irradiance rather than radiance */ + RAY *r +) { - static double Lambfa[5] = {PI, PI, PI, 0.0, 0.0}; - static OBJREC Lamb = { - OVOID, MAT_PLASTIC, "Lambertian", - {0, 5, NULL, Lambfa}, NULL, -1, - }; - register int i; + void (*old_revf)(RAY *) = r->revf; - for (i = 0; i < 3; i++) { - thisray.rorg[i] = org[i] + dir[i]; - thisray.rdir[i] = -dir[i]; + r->rot = 1e-5; /* pretend we hit surface */ + VSUM(r->rop, r->rorg, r->rdir, r->rot); + r->ron[0] = -r->rdir[0]; + r->ron[1] = -r->rdir[1]; + r->ron[2] = -r->rdir[2]; + r->rod = 1.0; + /* compute result */ + r->revf = raytrace; + (*ofun[Lamb.otype].funp)(&Lamb, r); + r->revf = old_revf; +} + + +static void +rtcompute( /* compute and print ray value(s) */ + FVECT org, + FVECT dir, + double dmax +) +{ + /* set up ray */ + rayorigin(&thisray, PRIMARY, NULL, NULL); + if (imm_irrad) { + VSUM(thisray.rorg, org, dir, 1.1e-4); + thisray.rdir[0] = -dir[0]; + thisray.rdir[1] = -dir[1]; + thisray.rdir[2] = -dir[2]; + thisray.rmax = 0.0; + thisray.revf = rayirrad; + } else { + VCOPY(thisray.rorg, org); + VCOPY(thisray.rdir, dir); + thisray.rmax = dmax; + if (castonly) + thisray.revf = raycast; } - rayorigin(&thisray, NULL, PRIMARY, 1.0); - /* pretend we hit surface */ - thisray.rot = 1.0; - thisray.rod = 1.0; - VCOPY(thisray.ron, dir); - for (i = 0; i < 3; i++) /* fudge factor */ - thisray.rop[i] = org[i] + 1e-4*dir[i]; - /* compute and print */ - (*ofun[Lamb.otype].funp)(&Lamb, &thisray); - oputv(&thisray); + if (ray_pnprocs > 1) { /* multiprocessing FIFO? */ + if (ray_fifo_in(&thisray) < 0) + error(USER, "lost children"); + return; + } + samplendx++; /* else do it ourselves */ + rayvalue(&thisray); + printvals(&thisray); +} + + +static int +printvals( /* print requested ray values */ + RAY *r +) +{ + oputf_t **tp; + + if (ray_out[0] == NULL) + return(0); + for (tp = ray_out; *tp != NULL; tp++) + (**tp)(r); if (outform == 'a') putchar('\n'); + return(1); } -getvec(vec, fmt, fp) /* get a vector from fp */ -register FVECT vec; -int fmt; -FILE *fp; +static int +getvec( /* get a vector from fp */ + FVECT vec, + int fmt, + FILE *fp +) { static float vf[3]; + static double vd[3]; + char buf[32]; + int i; switch (fmt) { case 'a': /* ascii */ - if (fscanf(fp, "%lf %lf %lf", vec, vec+1, vec+2) != 3) - return(-1); + for (i = 0; i < 3; i++) { + if (fgetword(buf, sizeof(buf), fp) == NULL || + !isflt(buf)) + return(-1); + vec[i] = atof(buf); + } break; case 'f': /* binary float */ if (fread((char *)vf, sizeof(float), 3, fp) != 3) return(-1); - vec[0] = vf[0]; vec[1] = vf[1]; vec[2] = vf[2]; + VCOPY(vec, vf); break; case 'd': /* binary double */ - if (fread((char *)vec, sizeof(double), 3, fp) != 3) + if (fread((char *)vd, sizeof(double), 3, fp) != 3) return(-1); + VCOPY(vec, vd); break; + default: + error(CONSISTENCY, "botched input format"); } return(0); } -static -ourtrace(r) /* print ray values */ -RAY *r; +void +tranotify( /* record new modifier */ + OBJECT obj +) { - register int (**tp)(); + static int hitlimit = 0; + OBJREC *o = objptr(obj); + char **tralp; + if (obj == OVOID) { /* starting over */ + traset[0] = 0; + hitlimit = 0; + return; + } + if (hitlimit || !ismodifier(o->otype)) + return; + for (tralp = tralist; *tralp != NULL; tralp++) + if (!strcmp(o->oname, *tralp)) { + if (traset[0] >= MAXTSET) { + error(WARNING, "too many modifiers in trace list"); + hitlimit++; + return; /* should this be fatal? */ + } + insertelem(traset, obj); + return; + } +} + + +static void +ourtrace( /* print ray values */ + RAY *r +) +{ + oputf_t **tp; + if (every_out[0] == NULL) return; + if (r->ro == NULL) { + if (traincl == 1) + return; + } else if (traincl != -1 && traincl != inset(traset, r->ro->omod)) + return; tabin(r); for (tp = every_out; *tp != NULL; tp++) (**tp)(r); - putchar('\n'); + if (outform == 'a') + putchar('\n'); } -static -tabin(r) /* tab in appropriate amount */ -RAY *r; +static void +tabin( /* tab in appropriate amount */ + RAY *r +) { - register RAY *rp; + const RAY *rp; for (rp = r->parent; rp != NULL; rp = rp->parent) putchar('\t'); } -static -oputo(r) /* print origin */ -register RAY *r; +static void +oputo( /* print origin */ + RAY *r +) { (*putreal)(r->rorg[0]); (*putreal)(r->rorg[1]); @@ -285,9 +498,10 @@ register RAY *r; } -static -oputd(r) /* print direction */ -register RAY *r; +static void +oputd( /* print direction */ + RAY *r +) { (*putreal)(r->rdir[0]); (*putreal)(r->rdir[1]); @@ -295,28 +509,73 @@ register RAY *r; } -static -oputv(r) /* print value */ -register RAY *r; +static void +oputv( /* print value */ + RAY *r +) { + if (outform == 'c') { + COLR cout; + setcolr(cout, colval(r->rcol,RED), + colval(r->rcol,GRN), + colval(r->rcol,BLU)); + fwrite((char *)cout, sizeof(cout), 1, stdout); + return; + } (*putreal)(colval(r->rcol,RED)); (*putreal)(colval(r->rcol,GRN)); (*putreal)(colval(r->rcol,BLU)); } -static -oputl(r) /* print length */ -register RAY *r; +static void +oputV( /* print value contribution */ + RAY *r +) { + double contr[3]; + + raycontrib(contr, r, PRIMARY); + multcolor(contr, r->rcol); + (*putreal)(contr[RED]); + (*putreal)(contr[GRN]); + (*putreal)(contr[BLU]); +} + + +static void +oputl( /* print effective distance */ + RAY *r +) +{ (*putreal)(r->rt); } -static -oputp(r) /* print point */ -register RAY *r; +static void +oputL( /* print single ray length */ + RAY *r +) { + (*putreal)(r->rot); +} + + +static void +oputc( /* print local coordinates */ + RAY *r +) +{ + (*putreal)(r->uv[0]); + (*putreal)(r->uv[1]); +} + + +static void +oputp( /* print point */ + RAY *r +) +{ if (r->rot < FHUGE) { (*putreal)(r->rop[0]); (*putreal)(r->rop[1]); @@ -329,9 +588,10 @@ register RAY *r; } -static -oputn(r) /* print normal */ -register RAY *r; +static void +oputN( /* print unperturbed normal */ + RAY *r +) { if (r->rot < FHUGE) { (*putreal)(r->ron[0]); @@ -345,10 +605,31 @@ register RAY *r; } -static -oputs(r) /* print name */ -register RAY *r; +static void +oputn( /* print perturbed normal */ + RAY *r +) { + FVECT pnorm; + + if (r->rot >= FHUGE) { + (*putreal)(0.0); + (*putreal)(0.0); + (*putreal)(0.0); + return; + } + raynormal(pnorm, r); + (*putreal)(pnorm[0]); + (*putreal)(pnorm[1]); + (*putreal)(pnorm[2]); +} + + +static void +oputs( /* print name */ + RAY *r +) +{ if (r->ro != NULL) fputs(r->ro->oname, stdout); else @@ -357,35 +638,82 @@ register RAY *r; } -static -oputw(r) /* print weight */ -register RAY *r; +static void +oputw( /* print weight */ + RAY *r +) { (*putreal)(r->rweight); } -static -oputm(r) /* print modifier */ -register RAY *r; +static void +oputW( /* print coefficient */ + RAY *r +) { + double contr[3]; + + raycontrib(contr, r, PRIMARY); + (*putreal)(contr[RED]); + (*putreal)(contr[GRN]); + (*putreal)(contr[BLU]); +} + + +static void +oputm( /* print modifier */ + RAY *r +) +{ if (r->ro != NULL) - fputs(objptr(r->ro->omod)->oname, stdout); + if (r->ro->omod != OVOID) + fputs(objptr(r->ro->omod)->oname, stdout); + else + fputs(VOIDID, stdout); else putchar('*'); putchar('\t'); } -static -puta(v) /* print ascii value */ -double v; +static void +oputM( /* print material */ + RAY *r +) { + OBJREC *mat; + + if (r->ro != NULL) { + if ((mat = findmaterial(r->ro)) != NULL) + fputs(mat->oname, stdout); + else + fputs(VOIDID, stdout); + } else + putchar('*'); + putchar('\t'); +} + + +static void +oputtilde( /* output tilde (spacer) */ + RAY *r +) +{ + fputs("~\t", stdout); +} + + +static void +puta( /* print ascii value */ + double v +) +{ printf("%e\t", v); } -static +static void putd(v) /* print binary double */ double v; { @@ -393,7 +721,7 @@ double v; } -static +static void putf(v) /* print binary float */ double v; {