--- ray/src/rt/rtrace.c 2006/02/05 22:22:20 2.51 +++ ray/src/rt/rtrace.c 2023/11/18 16:21:58 2.108 @@ -1,5 +1,5 @@ #ifndef lint -static const char RCSid[] = "$Id: rtrace.c,v 2.51 2006/02/05 22:22:20 greg Exp $"; +static const char RCSid[] = "$Id: rtrace.c,v 2.108 2023/11/18 16:21:58 greg Exp $"; #endif /* * rtrace.c - program and variables for individual ray tracing. @@ -28,112 +28,91 @@ static const char RCSid[] = "$Id: rtrace.c,v 2.51 2006 #include "ambient.h" #include "source.h" #include "otypes.h" +#include "otspecial.h" #include "resolu.h" #include "random.h" -CUBE thescene; /* our scene */ -OBJECT nsceneobjs; /* number of objects in our scene */ +extern int inform; /* input format */ +extern int outform; /* output format */ +extern char *outvals; /* output values */ -int dimlist[MAXDIM]; /* sampling dimensions */ -int ndims = 0; /* number of sampling dimensions */ -int samplendx = 0; /* index for this sample */ +extern int imm_irrad; /* compute immediate irradiance? */ +extern int lim_dist; /* limit distance? */ -int imm_irrad = 0; /* compute immediate irradiance? */ -int lim_dist = 0; /* limit distance? */ +extern char *tralist[]; /* list of modifers to trace (or no) */ +extern int traincl; /* include == 1, exclude == 0 */ -int inform = 'a'; /* input format */ -int outform = 'a'; /* output format */ -char *outvals = "v"; /* output specification */ +extern int hresolu; /* horizontal resolution */ +extern int vresolu; /* vertical resolution */ -int do_irrad = 0; /* compute irradiance? */ +extern int castonly; /* only doing ray-casting? */ -int rand_samp = 0; /* pure Monte Carlo sampling? */ +extern double (*sens_curve)(SCOLOR scol); /* spectral conversion for 1-channel */ +extern double out_scalefactor; /* output calibration scale factor */ +extern RGBPRIMP out_prims; /* output color primitives (NULL if spectral) */ -void (*trace)() = NULL; /* trace call */ - -char *tralist[128]; /* list of modifers to trace (or no) */ -int traincl = -1; /* include == 1, exclude == 0 */ #ifndef MAXTSET -#define MAXTSET 1024 /* maximum number in trace set */ +#define MAXTSET 8191 /* maximum number in trace set */ #endif OBJECT traset[MAXTSET+1]={0}; /* trace include/exclude set */ -int hresolu = 0; /* horizontal (scan) size */ -int vresolu = 0; /* vertical resolution */ +static int Tflag = 0; /* source tracing enabled? */ -double dstrsrc = 0.0; /* square source distribution */ -double shadthresh = .03; /* shadow threshold */ -double shadcert = .75; /* shadow certainty */ -int directrelay = 2; /* number of source relays */ -int vspretest = 512; /* virtual source pretest density */ -int directvis = 1; /* sources visible? */ -double srcsizerat = .2; /* maximum ratio source size/dist. */ +static RAY thisray; /* for our convenience */ -COLOR cextinction = BLKCOLOR; /* global extinction coefficient */ -COLOR salbedo = BLKCOLOR; /* global scattering albedo */ -double seccg = 0.; /* global scattering eccentricity */ -double ssampdist = 0.; /* scatter sampling distance */ +static FILE *inpfp = NULL; /* input stream pointer */ -double specthresh = .15; /* specular sampling threshold */ -double specjitter = 1.; /* specular sampling jitter */ +static FVECT *inp_queue = NULL; /* ray input queue if flushing */ +static int inp_qpos = 0; /* next ray to return */ +static int inp_qend = 0; /* number of rays in this work group */ -int backvis = 1; /* back face visibility */ - -int maxdepth = -10; /* maximum recursion depth */ -double minweight = 2e-3; /* minimum ray weight */ - -char *ambfile = NULL; /* ambient file name */ -COLOR ambval = BLKCOLOR; /* ambient value */ -int ambvwt = 0; /* initial weight for ambient value */ -double ambacc = 0.15; /* ambient accuracy */ -int ambres = 256; /* ambient resolution */ -int ambdiv = 1024; /* ambient divisions */ -int ambssamp = 512; /* ambient super-samples */ -int ambounce = 0; /* ambient bounces */ -char *amblist[AMBLLEN]; /* ambient include/exclude list */ -int ambincl = -1; /* include == 1, exclude == 0 */ - -static int castonly = 0; - -static RAY thisray; /* for our convenience */ - -typedef void putf_t(double v); +typedef void putf_t(RREAL *v, int n); static putf_t puta, putd, putf; 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; + oputr, oputR, oputx, oputX, oputn, oputN, oputs, + oputw, oputW, oputm, oputM, oputtilde; -static void setoutput(char *vs); -static void tranotify(OBJECT obj); +extern void tranotify(OBJECT obj); +static int is_fifo(FILE *fp); static void bogusray(void); -static void rad(FVECT org, FVECT dir, double dmax); -static void irrad(FVECT org, FVECT dir); -static void printvals(RAY *r); -static int getvec(FVECT vec, int fmt, FILE *fp); -static void tabin(RAY *r); -static void ourtrace(RAY *r); +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 int iszerovec(const FVECT vec); +static double nextray(FVECT org, FVECT dir); +static void tabin(RAY *r); +static void ourtrace(RAY *r); -static oputf_t *ray_out[16], *every_out[16]; +static void putscolor(const COLORV *scol); + +static oputf_t *ray_out[32], *every_out[32]; static putf_t *putreal; -void (*addobjnotify[])() = {ambnotify, tranotify, NULL}; - void quit( /* quit program */ int code ) { -#ifndef NON_POSIX /* XXX we don't clean up elsewhere? */ - headclean(); /* delete header file */ - pfclean(); /* clean up persist files */ + if (ray_pnprocs > 0) /* close children if any */ + ray_pclose(0); + else if (ray_pnprocs < 0) + _exit(code); /* avoid flush() in child */ +#ifndef NON_POSIX + else { + headclean(); /* delete header file */ + pfclean(); /* clean up persist files */ + } #endif exit(code); } -extern char * +const char * formstr( /* return format identifier */ int f ) @@ -142,262 +121,389 @@ formstr( /* return format identifier */ case 'a': return("ascii"); case 'f': return("float"); case 'd': return("double"); - case 'c': return(COLRFMT); + case 'c': + if (out_prims == NULL) + return(SPECFMT); + if (out_prims == xyzprims) + return(CIEFMT); + return(COLRFMT); } return("unknown"); } -extern void +static void +trace_sources(void) /* trace rays to light sources, also */ +{ + int sn; + + for (sn = 0; sn < nsources; sn++) + source[sn].sflags |= SFOLLOW; +} + + +void rtrace( /* trace rays from file */ - char *fname + char *fname, + int nproc ) { unsigned long vcount = (hresolu > 1) ? (unsigned long)hresolu*vresolu - : vresolu; - long nextflush = hresolu; + : (unsigned long)vresolu; + long nextflush = (!vresolu | (hresolu <= 1)) * hresolu; + int something2flush = 0; FILE *fp; double d; FVECT orig, direc; /* set up input */ if (fname == NULL) - fp = stdin; - else if ((fp = fopen(fname, "r")) == NULL) { + inpfp = stdin; + else if ((inpfp = fopen(fname, "r")) == NULL) { sprintf(errmsg, "cannot open input file \"%s\"", fname); error(SYSTEM, errmsg); } +#ifdef getc_unlocked + flockfile(inpfp); /* avoid lock/unlock overhead */ + flockfile(stdout); +#endif if (inform != 'a') - SET_FILE_BINARY(fp); + SET_FILE_BINARY(inpfp); /* set up output */ - setoutput(outvals); - 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 (castonly || every_out[0] != NULL) + nproc = 1; /* don't bother multiprocessing */ + if (every_out[0] != NULL) { + trace = ourtrace; /* enable full tree tracing */ + if (Tflag) /* light sources, too? */ + trace_sources(); } + if ((nextflush > 0) & (nproc > nextflush)) { + error(WARNING, "reducing number of processes to match flush interval"); + nproc = nextflush; + } + if (nproc > 1) { /* start multiprocessing */ + ray_popen(nproc); + ray_fifo_out = printvals; + } if (hresolu > 0) { if (vresolu > 0) fprtresolu(hresolu, vresolu, stdout); - fflush(stdout); + else + fflush(stdout); } - /* process file */ - while (getvec(orig, inform, fp) == 0 && - getvec(direc, inform, fp) == 0) { - - d = normalize(direc); - if (d == 0.0) { /* zero ==> flush */ - bogusray(); - if (--nextflush <= 0 || !vcount) { + /* process input rays */ + while ((d = nextray(orig, direc)) >= 0.0) { + if (d == 0.0) { /* flush request? */ + if (something2flush) { + if (ray_pnprocs > 1 && ray_fifo_flush() < 0) + error(USER, "child(ren) died"); + bogusray(); fflush(stdout); - nextflush = hresolu; - } - } else { - samplendx = rand_samp ? random() : samplendx+1; - /* compute and print */ - if (imm_irrad) - irrad(orig, direc); - else - rad(orig, direc, lim_dist ? d : 0.0); - /* flush if time */ - if (!--nextflush) { + nextflush = (!vresolu | (hresolu <= 1)) * hresolu; + something2flush = 0; + } else + bogusray(); + } else { /* compute and print */ + rtcompute(orig, direc, lim_dist ? d : 0.0); + if (!--nextflush) { /* flush if time */ + if (ray_pnprocs > 1 && ray_fifo_flush() < 0) + error(USER, "child(ren) died"); fflush(stdout); nextflush = hresolu; - } + } else + something2flush = 1; } if (ferror(stdout)) error(SYSTEM, "write error"); if (vcount && !--vcount) /* check for end */ break; } + if (ray_pnprocs > 1) { /* clean up children */ + if (ray_fifo_flush() < 0) + error(USER, "unable to complete processing"); + ray_pclose(0); + } + if (vcount) + error(WARNING, "unexpected EOF on input"); if (fflush(stdout) < 0) error(SYSTEM, "write error"); - if (vcount) - error(USER, "unexpected EOF on input"); - if (fname != NULL) - fclose(fp); + if (fname != NULL) { + fclose(inpfp); + inpfp = NULL; + } + nextray(NULL, NULL); } -static void -trace_sources(void) /* trace rays to light sources, also */ +int +setrtoutput(void) /* set up output tables, return #comp */ { - int sn; - - for (sn = 0; sn < nsources; sn++) - source[sn].sflags |= SFOLLOW; -} + char *vs = outvals; + oputf_t **table = ray_out; + const int nco = (sens_curve != NULL) ? 1 : + (out_prims != NULL) ? 3 : NCSAMP; + int ncomp = 0; + if (!*vs) + error(USER, "empty output specification"); -static void -setoutput( /* set up output tables */ - register char *vs -) -{ - register oputf_t **table = ray_out; - - castonly = 1; - while (*vs) - switch (*vs++) { + switch (outform) { /* make sure (*putreal)() calls someone! */ + case 'a': putreal = puta; break; + case 'f': putreal = putf; break; + case 'd': putreal = putd; break; + case 'c': + if (outvals[1] || !strchr("vrx", outvals[0])) + error(USER, "color format only with -ov, -or, -ox"); + if (nco < 3) + error(USER, "color format incompatible with -pY, -pS, -pM"); + break; + default: + error(CONSISTENCY, "botched output format"); + } + castonly = 1; /* sets castonly as side-effect */ + do + switch (*vs) { case 'T': /* trace sources */ - if (!*vs) break; - trace_sources(); + Tflag++; /* fall through */ case 't': /* trace */ - if (!*vs) break; + if (!vs[1]) break; *table = NULL; table = every_out; - trace = ourtrace; castonly = 0; break; case 'o': /* origin */ *table++ = oputo; + ncomp += 3; break; case 'd': /* direction */ *table++ = oputd; + ncomp += 3; break; + case 'r': /* reflected contrib. */ + *table++ = oputr; + ncomp += nco; + castonly = 0; + break; + case 'R': /* reflected distance */ + *table++ = oputR; + ncomp++; + castonly = 0; + break; + case 'x': /* xmit contrib. */ + *table++ = oputx; + ncomp += nco; + castonly = 0; + break; + case 'X': /* xmit distance */ + *table++ = oputX; + ncomp++; + castonly = 0; + break; case 'v': /* value */ *table++ = oputv; + ncomp += nco; castonly = 0; break; case 'V': /* contribution */ *table++ = oputV; + ncomp += nco; + castonly = 0; if (ambounce > 0 && (ambacc > FTINY || ambssamp > 0)) error(WARNING, "-otV accuracy depends on -aa 0 -as 0"); break; case 'l': /* effective distance */ *table++ = oputl; + ncomp++; castonly = 0; break; case 'c': /* local coordinates */ *table++ = oputc; + ncomp += 2; break; case 'L': /* single ray length */ *table++ = oputL; + ncomp++; break; case 'p': /* point */ *table++ = oputp; + ncomp += 3; break; case 'n': /* perturbed normal */ *table++ = oputn; + ncomp += 3; castonly = 0; break; case 'N': /* unperturbed normal */ *table++ = oputN; + ncomp += 3; break; case 's': /* surface */ *table++ = oputs; + ncomp++; break; case 'w': /* weight */ *table++ = oputw; + ncomp++; break; case 'W': /* coefficient */ *table++ = oputW; - if (ambounce > 0 && (ambacc > FTINY || ambssamp > 0)) + ncomp += nco; + castonly = 0; + if (ambounce > 0 && (ambacc > FTINY) | (ambssamp > 0)) error(WARNING, "-otW accuracy depends on -aa 0 -as 0"); break; case 'm': /* modifier */ *table++ = oputm; + ncomp++; break; case 'M': /* material */ *table++ = oputM; + ncomp++; break; case '~': /* tilde */ *table++ = oputtilde; break; + default: + sprintf(errmsg, "unrecognized output option '%c'", *vs); + error(USER, errmsg); } + while (*++vs); + *table = NULL; + if (*every_out != NULL) + ncomp = 0; + /* compatibility */ + if ((do_irrad | imm_irrad) && castonly) + error(USER, "-I+ and -i+ options require some value output"); + for (table = ray_out; *table != NULL; table++) { + if ((*table == oputV) | (*table == oputW)) + error(WARNING, "-oVW options require trace mode"); + if ((do_irrad | imm_irrad) && + (*table == oputr) | (*table == oputR) | + (*table == oputx) | (*table == oputX)) + error(WARNING, "-orRxX options incompatible with -I+ and -i+"); + } + return(ncomp); } static void bogusray(void) /* print out empty record */ { - 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); } static void -rad( /* compute and print ray value(s) */ - FVECT org, - FVECT dir, - double dmax +raycast( /* compute first ray intersection only */ + RAY *r ) { - VCOPY(thisray.rorg, org); - VCOPY(thisray.rdir, dir); - thisray.rmax = dmax; - rayorigin(&thisray, PRIMARY, NULL, NULL); - if (castonly) { - if (!localhit(&thisray, &thescene)) { - if (thisray.ro == &Aftplane) { /* clipped */ - thisray.ro = NULL; - thisray.rot = FHUGE; - } else - sourcehit(&thisray); - } - } else - rayvalue(&thisray); - printvals(&thisray); + if (!localhit(r, &thescene)) { + if (r->ro == &Aftplane) { /* clipped */ + r->ro = NULL; + r->rot = FHUGE; + } else + sourcehit(r); + } } static void -irrad( /* compute immediate irradiance value */ - FVECT org, - FVECT dir +rayirrad( /* compute irradiance rather than radiance */ + RAY *r ) { - register int i; + void (*old_revf)(RAY *) = r->revf; + /* pretend we hit surface */ + r->rxt = r->rot = 1e-5; + 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; +} - for (i = 0; i < 3; i++) { - thisray.rorg[i] = org[i] + dir[i]; - thisray.rdir[i] = -dir[i]; + +static void +rtcompute( /* compute and print ray value(s) */ + FVECT org, + FVECT dir, + double dmax +) +{ + /* set up ray */ + 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; + } else { + VCOPY(thisray.rorg, org); + VCOPY(thisray.rdir, dir); + thisray.rmax = dmax; } - thisray.rmax = 0.0; rayorigin(&thisray, PRIMARY, NULL, NULL); - /* pretend we hit surface */ - thisray.rot = 1.0-1e-4; - 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); + if (imm_irrad) + thisray.revf = rayirrad; + else if (castonly) + thisray.revf = raycast; + 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 void +static int printvals( /* print requested ray values */ RAY *r ) { - register oputf_t **tp; + oputf_t **tp; if (ray_out[0] == NULL) - return; + return(0); for (tp = ray_out; *tp != NULL; tp++) (**tp)(r); if (outform == 'a') putchar('\n'); + return(1); } static int -getvec( /* get a vector from fp */ - register FVECT vec, +is_fifo( /* check if file pointer connected to pipe */ + FILE *fp +) +{ +#ifdef S_ISFIFO + struct stat sbuf; + + if (fstat(fileno(fp), &sbuf) < 0) + error(SYSTEM, "fstat() failed on input stream"); + return(S_ISFIFO(sbuf.st_mode)); +#else + return (fp == stdin); /* just a guess, really */ +#endif +} + + +static int +getvec( /* get a vector from fp */ + FVECT vec, int fmt, FILE *fp ) @@ -405,7 +511,7 @@ getvec( /* get a vector from fp */ static float vf[3]; static double vd[3]; char buf[32]; - register int i; + int i; switch (fmt) { case 'a': /* ascii */ @@ -417,14 +523,14 @@ getvec( /* get a vector from fp */ } break; case 'f': /* binary float */ - if (fread((char *)vf, sizeof(float), 3, fp) != 3) + if (getbinary(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 *)vd, sizeof(double), 3, fp) != 3) + if (getbinary(vd, sizeof(double), 3, fp) != 3) return(-1); - vec[0] = vd[0]; vec[1] = vd[1]; vec[2] = vd[2]; + VCOPY(vec, vd); break; default: error(CONSISTENCY, "botched input format"); @@ -433,14 +539,73 @@ getvec( /* get a vector from fp */ } -static void +static int +iszerovec(const FVECT vec) +{ + return (vec[0] == 0.0) & (vec[1] == 0.0) & (vec[2] == 0.0); +} + + +static double +nextray( /* return next ray in work group (-1.0 if EOF) */ + FVECT org, + FVECT dir +) +{ + const size_t qlength = !vresolu * hresolu; + + if ((org == NULL) | (dir == NULL)) { + if (inp_queue != NULL) /* asking to free queue */ + free(inp_queue); + inp_queue = NULL; + inp_qpos = inp_qend = 0; + return(-1.); + } + if (!inp_qend) { /* initialize FIFO queue */ + int rsiz = 6*20; /* conservative ascii ray size */ + if (inform == 'f') rsiz = 6*sizeof(float); + else if (inform == 'd') rsiz = 6*sizeof(double); + /* check against pipe limit */ + if (qlength*rsiz > 512 && is_fifo(inpfp)) + inp_queue = (FVECT *)malloc(sizeof(FVECT)*2*qlength); + inp_qend = -(inp_queue == NULL); /* flag for no queue */ + } + if (inp_qend < 0) { /* not queuing? */ + if (getvec(org, inform, inpfp) < 0 || + getvec(dir, inform, inpfp) < 0) + return(-1.); + return normalize(dir); + } + if (inp_qpos >= inp_qend) { /* need to refill input queue? */ + for (inp_qend = 0; inp_qend < qlength; inp_qend++) { + if (getvec(inp_queue[2*inp_qend], inform, inpfp) < 0 + || getvec(inp_queue[2*inp_qend+1], + inform, inpfp) < 0) + break; /* hit EOF */ + if (iszerovec(inp_queue[2*inp_qend+1])) { + ++inp_qend; /* flush request */ + break; + } + } + inp_qpos = 0; + } + if (inp_qpos >= inp_qend) /* unexpected EOF? */ + return(-1.); + VCOPY(org, inp_queue[2*inp_qpos]); + VCOPY(dir, inp_queue[2*inp_qpos+1]); + ++inp_qpos; + return normalize(dir); +} + + +void tranotify( /* record new modifier */ OBJECT obj ) { static int hitlimit = 0; - register OBJREC *o = objptr(obj); - register char **tralp; + OBJREC *o = objptr(obj); + char **tralp; if (obj == OVOID) { /* starting over */ traset[0] = 0; @@ -467,7 +632,7 @@ ourtrace( /* print ray values */ RAY *r ) { - register oputf_t **tp; + oputf_t **tp; if (every_out[0] == NULL) return; @@ -501,9 +666,7 @@ oputo( /* print origin */ RAY *r ) { - (*putreal)(r->rorg[0]); - (*putreal)(r->rorg[1]); - (*putreal)(r->rorg[2]); + (*putreal)(r->rorg, 3); } @@ -512,28 +675,63 @@ oputd( /* print direction */ RAY *r ) { - (*putreal)(r->rdir[0]); - (*putreal)(r->rdir[1]); - (*putreal)(r->rdir[2]); + (*putreal)(r->rdir, 3); } static void +oputr( /* print mirrored contribution */ + RAY *r +) +{ + RREAL cval[3]; + + cval[0] = colval(r->mcol,RED); + cval[1] = colval(r->mcol,GRN); + cval[2] = colval(r->mcol,BLU); + (*putreal)(cval, 3); +} + + + +static void +oputR( /* print mirrored distance */ + RAY *r +) +{ + (*putreal)(&r->rmt, 1); +} + + +static void +oputx( /* print unmirrored contribution */ + RAY *r +) +{ + SCOLOR cdiff; + + copyscolor(cdiff, r->rcol); + sopscolor(cdiff, -=, r->mcol); + + putscolor(cdiff); +} + + +static void +oputX( /* print unmirrored distance */ + RAY *r +) +{ + (*putreal)(&r->rxt, 1); +} + + +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)); + putscolor(r->rcol); } @@ -542,13 +740,11 @@ oputV( /* print value contribution */ RAY *r ) { - double contr[3]; + SCOLOR contr; raycontrib(contr, r, PRIMARY); - multcolor(contr, r->rcol); - (*putreal)(contr[RED]); - (*putreal)(contr[GRN]); - (*putreal)(contr[BLU]); + smultscolor(contr, r->rcol); + putscolor(contr); } @@ -557,7 +753,9 @@ oputl( /* print effective distance */ RAY *r ) { - (*putreal)(r->rt); + RREAL d = raydistance(r); + + (*putreal)(&d, 1); } @@ -566,7 +764,7 @@ oputL( /* print single ray length */ RAY *r ) { - (*putreal)(r->rot); + (*putreal)(&r->rot, 1); } @@ -575,25 +773,19 @@ oputc( /* print local coordinates */ RAY *r ) { - (*putreal)(r->uv[0]); - (*putreal)(r->uv[1]); + (*putreal)(r->uv, 2); } +static RREAL vdummy[3] = {0.0, 0.0, 0.0}; + + static void -oputp( /* print point */ +oputp( /* print intersection point */ RAY *r ) { - if (r->rot < FHUGE) { - (*putreal)(r->rop[0]); - (*putreal)(r->rop[1]); - (*putreal)(r->rop[2]); - } else { - (*putreal)(0.0); - (*putreal)(0.0); - (*putreal)(0.0); - } + (*putreal)(r->rop, 3); /* set to ray origin if distant or no hit */ } @@ -602,15 +794,18 @@ oputN( /* print unperturbed normal */ RAY *r ) { - if (r->rot < FHUGE) { - (*putreal)(r->ron[0]); - (*putreal)(r->ron[1]); - (*putreal)(r->ron[2]); - } else { - (*putreal)(0.0); - (*putreal)(0.0); - (*putreal)(0.0); + if (r->ro == NULL) { /* zero vector if clipped or no hit */ + (*putreal)(vdummy, 3); + return; } + if (r->rflips & 1) { /* undo any flippin' flips */ + FVECT unrm; + unrm[0] = -r->ron[0]; + unrm[1] = -r->ron[1]; + unrm[2] = -r->ron[2]; + (*putreal)(unrm, 3); + } else + (*putreal)(r->ron, 3); } @@ -621,16 +816,12 @@ oputn( /* print perturbed normal */ { FVECT pnorm; - if (r->rot >= FHUGE) { - (*putreal)(0.0); - (*putreal)(0.0); - (*putreal)(0.0); + if (r->ro == NULL) { /* clipped or no hit */ + (*putreal)(vdummy, 3); return; } raynormal(pnorm, r); - (*putreal)(pnorm[0]); - (*putreal)(pnorm[1]); - (*putreal)(pnorm[2]); + (*putreal)(pnorm, 3); } @@ -652,7 +843,9 @@ oputw( /* print weight */ RAY *r ) { - (*putreal)(r->rweight); + RREAL rwt = r->rweight; + + (*putreal)(&rwt, 1); } @@ -661,12 +854,14 @@ oputW( /* print coefficient */ RAY *r ) { - double contr[3]; + SCOLOR contr; + /* shadow ray not on source? */ + if (r->rsrc >= 0 && source[r->rsrc].so != r->ro) + scolorblack(contr); + else + raycontrib(contr, r, PRIMARY); - raycontrib(contr, r, PRIMARY); - (*putreal)(contr[RED]); - (*putreal)(contr[GRN]); - (*putreal)(contr[BLU]); + putscolor(contr); } @@ -714,27 +909,106 @@ oputtilde( /* output tilde (spacer) */ static void -puta( /* print ascii value */ - double v +puta( /* print ascii value(s) */ + RREAL *v, int n ) { - printf("%e\t", v); + if (n == 3) { + printf("%e\t%e\t%e\t", v[0], v[1], v[2]); + return; + } + while (n--) + printf("%e\t", *v++); } static void -putd(v) /* print binary double */ -double v; +putd(RREAL *v, int n) /* output binary double(s) */ { - fwrite((char *)&v, sizeof(v), 1, stdout); +#ifdef SMLFLT + double da[3]; + int i; + + if (n > 3) + error(INTERNAL, "code error in putd()"); + for (i = n; i--; ) + da[i] = v[i]; + putbinary(da, sizeof(double), n, stdout); +#else + putbinary(v, sizeof(RREAL), n, stdout); +#endif } static void -putf(v) /* print binary float */ -double v; +putf(RREAL *v, int n) /* output binary float(s) */ { - float f = v; +#ifndef SMLFLT + float fa[3]; + int i; - fwrite((char *)&f, sizeof(f), 1, stdout); + if (n > 3) + error(INTERNAL, "code error in putf()"); + for (i = n; i--; ) + fa[i] = v[i]; + putbinary(fa, sizeof(float), n, stdout); +#else + putbinary(v, sizeof(RREAL), n, stdout); +#endif +} + + +static void +putscolor(const COLORV *scol) /* output (spectral) color */ +{ + static COLORMAT xyz2myrgbmat; + SCOLOR my_scol; + COLOR col; + /* apply scalefactor if any */ + if (out_scalefactor != 1.) { + copyscolor(my_scol, scol); + scalescolor(my_scol, out_scalefactor); + scol = my_scol; + } + if (sens_curve != NULL) { /* single channel output */ + RREAL v = (*sens_curve)(scol); + (*putreal)(&v, 1); + return; + } + if (out_prims == NULL) { /* full spectral reporting */ + if (outform == 'c') { + SCOLR sclr; + scolor_scolr(sclr, scol); + putbinary(sclr, LSCOLR, 1, stdout); + } else if (sizeof(RREAL) != sizeof(COLORV)) { + RREAL sreal[MAXCSAMP]; + int i = NCSAMP; + while (i--) sreal[i] = scol[i]; + (*putreal)(sreal, NCSAMP); + } else + (*putreal)((RREAL *)scol, NCSAMP); + return; + } + if (out_prims == xyzprims) { + scolor_cie(col, scol); + } else if (out_prims == stdprims) { + scolor_rgb(col, scol); + } else { + COLOR xyz; + if (xyz2myrgbmat[0][0] == 0) + compxyz2rgbWBmat(xyz2myrgbmat, out_prims); + scolor_cie(xyz, scol); + colortrans(col, xyz2myrgbmat, xyz); + clipgamut(col, xyz[CIEY], CGAMUT_LOWER, cblack, cwhite); + } + if (outform == 'c') { + COLR clr; + setcolr(clr, colval(col,RED), colval(col,GRN), colval(col,BLU)); + putbinary(clr, sizeof(COLR), 1, stdout); + } else if (sizeof(RREAL) != sizeof(COLORV)) { + RREAL creal[3]; + copycolor(creal, col); + (*putreal)(creal, 3); + } else + (*putreal)((RREAL *)col, 3); }