--- ray/src/rt/rtrace.c 1992/01/16 12:05:20 2.4 +++ ray/src/rt/rtrace.c 2003/02/22 02:07:29 2.27 @@ -1,13 +1,65 @@ -/* 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.27 2003/02/22 02:07:29 greg Exp $"; #endif - /* * rtrace.c - program and variables for individual ray tracing. + */ + +/* ==================================================================== + * The Radiance Software License, Version 1.0 * - * 6/11/86 + * Copyright (c) 1990 - 2002 The Regents of the University of California, + * through Lawrence Berkeley National Laboratory. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * 3. The end-user documentation included with the redistribution, + * if any, must include the following acknowledgment: + * "This product includes Radiance software + * (http://radsite.lbl.gov/) + * developed by the Lawrence Berkeley National Laboratory + * (http://www.lbl.gov/)." + * Alternately, this acknowledgment may appear in the software itself, + * if and wherever such third-party acknowledgments normally appear. + * + * 4. The names "Radiance," "Lawrence Berkeley National Laboratory" + * and "The Regents of the University of California" must + * not be used to endorse or promote products derived from this + * software without prior written permission. For written + * permission, please contact radiance@radsite.lbl.gov. + * + * 5. Products derived from this software may not be called "Radiance", + * nor may "Radiance" appear in their name, without prior written + * permission of Lawrence Berkeley National Laboratory. + * + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR + * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * ==================================================================== + * + * This software consists of voluntary contributions made by many + * individuals on behalf of Lawrence Berkeley National Laboratory. For more + * information on Lawrence Berkeley National Laboratory, please see + * . */ /* @@ -26,74 +78,121 @@ static char SCCSid[] = "$SunId$ LBL"; #include "ray.h" -#include "octree.h" - #include "otypes.h" +#include "resolu.h" + +CUBE thescene; /* our scene */ +OBJECT nsceneobjs; /* number of objects in our scene */ + int dimlist[MAXDIM]; /* sampling dimensions */ int ndims = 0; /* number of sampling dimensions */ int samplendx = 0; /* index for this sample */ int imm_irrad = 0; /* compute immediate irradiance? */ +int lim_dist = 0; /* limit distance? */ int inform = 'a'; /* input format */ int outform = 'a'; /* output format */ char *outvals = "v"; /* output specification */ +int do_irrad = 0; /* compute irradiance? */ + +void (*trace)() = NULL; /* trace call */ + +extern void ambnotify(), tranotify(); +void (*addobjnotify[])() = {ambnotify, tranotify, NULL}; +char *tralist[128]; /* list of modifers to trace (or no) */ +int traincl = -1; /* include == 1, exclude == 0 */ +#define MAXTSET 511 /* maximum number in trace set */ +OBJECT traset[MAXTSET+1]={0}; /* trace include/exclude set */ + int hresolu = 0; /* horizontal (scan) size */ int vresolu = 0; /* vertical resolution */ double dstrsrc = 0.0; /* square source distribution */ double shadthresh = .05; /* shadow threshold */ double shadcert = .5; /* shadow certainty */ -int directrelay = 1; /* number of source relays */ +int directrelay = 2; /* number of source relays */ int vspretest = 512; /* virtual source pretest density */ -int directinvis = 0; /* sources invisible? */ -double srcsizerat = .25; /* maximum ratio source size/dist. */ +int directvis = 1; /* sources visible? */ +double srcsizerat = .2; /* maximum ratio source size/dist. */ +COLOR cextinction = BLKCOLOR; /* global extinction coefficient */ +COLOR salbedo = BLKCOLOR; /* global scattering albedo */ +double seccg = 0.; /* global scattering eccentricity */ +double ssampdist = 0.; /* scatter sampling distance */ + double specthresh = .15; /* specular sampling threshold */ double specjitter = 1.; /* specular sampling jitter */ +int backvis = 1; /* back face visibility */ + int maxdepth = 6; /* maximum recursion depth */ double minweight = 4e-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.2; /* ambient accuracy */ -int ambres = 32; /* ambient resolution */ -int ambdiv = 128; /* ambient divisions */ +int ambres = 128; /* ambient resolution */ +int ambdiv = 512; /* 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 */ -extern OBJREC Lamb; /* a Lambertian surface */ static RAY thisray; /* for our convenience */ -static int oputo(), oputd(), oputv(), oputl(), - oputp(), oputn(), oputs(), oputw(), oputm(); +static void oputo(), oputd(), oputv(), oputl(), oputL(), + oputp(), oputn(), oputN(), oputs(), oputw(), oputm(); -static int (*ray_out[10])(), (*every_out[10])(); -static int castonly; +static void ourtrace(), tabin(); +static void (*ray_out[16])(), (*every_out[16])(); +static int castonly = 0; -static int puta(), putf(), putd(); +static void puta(), putf(), putd(); -static int (*putreal)(); +static void (*putreal)(); +void bogusray(), rad(), irrad(), printvals(); + +void quit(code) /* quit program */ int code; { +#ifndef NIX + headclean(); /* delete header file */ + pfclean(); /* clean up persist files */ +#endif exit(code); } +char * +formstr(f) /* return format identifier */ +int f; +{ + switch (f) { + case 'a': return("ascii"); + case 'f': return("float"); + case 'd': return("double"); + case 'c': return(COLRFMT); + } + return("unknown"); +} + + +void rtrace(fname) /* trace rays from file */ char *fname; { long vcount = hresolu>1 ? hresolu*vresolu : vresolu; long nextflush = hresolu; FILE *fp; + double d; FVECT orig, direc; /* set up input */ if (fname == NULL) @@ -102,48 +201,70 @@ char *fname; sprintf(errmsg, "cannot open input file \"%s\"", fname); error(SYSTEM, errmsg); } +#ifdef MSDOS + if (inform != 'a') + setmode(fileno(fp), O_BINARY); +#endif /* 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 (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; - } - samplendx++; + d = normalize(direc); + if (d == 0.0) { /* zero ==> flush */ + bogusray(); + if (--nextflush <= 0 || vcount <= 0) { + fflush(stdout); + nextflush = hresolu; + } + } else { + samplendx++; /* compute and print */ - if (imm_irrad) - irrad(orig, direc); - else - traceray(orig, direc); + if (imm_irrad) + irrad(orig, direc); + else + rad(orig, direc, lim_dist ? d : 0.0); /* flush if time */ - if (--nextflush == 0) { - fflush(stdout); - nextflush = hresolu; + if (--nextflush == 0) { + fflush(stdout); + nextflush = hresolu; + } } if (ferror(stdout)) error(SYSTEM, "write error"); if (--vcount == 0) /* check for end */ break; } + fflush(stdout); if (vcount > 0) error(USER, "read error"); - fclose(fp); + if (fname != NULL) + fclose(fp); } setoutput(vs) /* set up output tables */ register char *vs; { - extern int ourtrace(), (*trace)(); - register int (**table)() = ray_out; + extern void (*trace)(); + register void (**table)() = ray_out; castonly = 1; while (*vs) @@ -164,16 +285,23 @@ register char *vs; *table++ = oputv; castonly = 0; break; - case 'l': /* length */ + case 'l': /* effective distance */ *table++ = oputl; castonly = 0; 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; @@ -188,28 +316,39 @@ register char *vs; } -traceray(org, dir) /* compute and print ray value(s) */ -FVECT org, dir; +void +bogusray() /* 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; + rayorigin(&thisray, NULL, PRIMARY, 1.0); + printvals(&thisray); +} + +void +rad(org, dir, dmax) /* compute and print ray value(s) */ +FVECT org, dir; +double dmax; +{ VCOPY(thisray.rorg, org); VCOPY(thisray.rdir, dir); + thisray.rmax = dmax; rayorigin(&thisray, NULL, PRIMARY, 1.0); - if (castonly) - localhit(&thisray, &thescene) || sourcehit(&thisray); - else + if (castonly) { + if (!localhit(&thisray, &thescene)) + if (thisray.ro == &Aftplane) { /* clipped */ + thisray.ro = NULL; + thisray.rot = FHUGE; + } else + 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'); + printvals(&thisray); } +void irrad(org, dir) /* compute immediate irradiance value */ FVECT org, dir; { @@ -221,26 +360,40 @@ FVECT org, dir; } rayorigin(&thisray, NULL, PRIMARY, 1.0); /* pretend we hit surface */ - thisray.rot = 1.0; + 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); - oputv(&thisray); + printvals(&thisray); +} + + +void +printvals(r) /* print requested ray values */ +RAY *r; +{ + register void (**tp)(); + + if (ray_out[0] == NULL) + return; + for (tp = ray_out; *tp != NULL; tp++) + (**tp)(r); if (outform == 'a') putchar('\n'); } +int getvec(vec, fmt, fp) /* get a vector from fp */ register FVECT vec; int fmt; FILE *fp; { - extern char *fgetword(); static float vf[3]; + static double vd[3]; char buf[32]; register int i; @@ -259,22 +412,58 @@ FILE *fp; vec[0] = vf[0]; vec[1] = vf[1]; vec[2] = vf[2]; 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); + vec[0] = vd[0]; vec[1] = vd[1]; vec[2] = vd[2]; break; + default: + error(CONSISTENCY, "botched input format"); } return(0); } -static +void +tranotify(obj) /* record new modifier */ +OBJECT obj; +{ + static int hitlimit = 0; + register OBJREC *o = objptr(obj); + register 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(r) /* print ray values */ RAY *r; { - register int (**tp)(); + register void (**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); @@ -282,7 +471,7 @@ RAY *r; } -static +static void tabin(r) /* tab in appropriate amount */ RAY *r; { @@ -293,7 +482,7 @@ RAY *r; } -static +static void oputo(r) /* print origin */ register RAY *r; { @@ -303,7 +492,7 @@ register RAY *r; } -static +static void oputd(r) /* print direction */ register RAY *r; { @@ -313,25 +502,42 @@ register RAY *r; } -static +static void oputv(r) /* print value */ register RAY *r; { + COLR cout; + + if (outform == 'c') { + 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 */ +static void +oputl(r) /* print effective distance */ register RAY *r; { (*putreal)(r->rt); } -static +static void +oputL(r) /* print single ray length */ +register RAY *r; +{ + (*putreal)(r->rot); +} + + +static void oputp(r) /* print point */ register RAY *r; { @@ -347,8 +553,8 @@ register RAY *r; } -static -oputn(r) /* print normal */ +static void +oputN(r) /* print unperturbed normal */ register RAY *r; { if (r->rot < FHUGE) { @@ -363,7 +569,26 @@ register RAY *r; } -static +static void +oputn(r) /* 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(r) /* print name */ register RAY *r; { @@ -375,7 +600,7 @@ register RAY *r; } -static +static void oputw(r) /* print weight */ register RAY *r; { @@ -383,19 +608,22 @@ register RAY *r; } -static +static void oputm(r) /* print modifier */ register 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 +static void puta(v) /* print ascii value */ double v; { @@ -403,7 +631,7 @@ double v; } -static +static void putd(v) /* print binary double */ double v; { @@ -411,7 +639,7 @@ double v; } -static +static void putf(v) /* print binary float */ double v; {