ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/rtrace.c
(Generate patch)

Comparing ray/src/rt/rtrace.c (file contents):
Revision 1.20 by greg, Mon Oct 21 12:58:10 1991 UTC vs.
Revision 2.20 by greg, Fri Dec 8 18:49:12 1995 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1986 Regents of the University of California */
1 > /* Copyright (c) 1995 Regents of the University of California */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ LBL";
# Line 30 | Line 30 | static char SCCSid[] = "$SunId$ LBL";
30  
31   #include  "otypes.h"
32  
33 + #include  "resolu.h"
34 +
35   int  dimlist[MAXDIM];                   /* sampling dimensions */
36   int  ndims = 0;                         /* number of sampling dimensions */
37   int  samplendx = 0;                     /* index for this sample */
# Line 40 | Line 42 | int  inform = 'a';                     /* input format */
42   int  outform = 'a';                     /* output format */
43   char  *outvals = "v";                   /* output specification */
44  
45 + char  *tralist[128];                    /* list of modifers to trace (or no) */
46 + int  traincl = -1;                      /* include == 1, exclude == 0 */
47 + #define  MAXTSET        511             /* maximum number in trace set */
48 + OBJECT  traset[MAXTSET+1]={0};          /* trace include/exclude set */
49 +
50   int  hresolu = 0;                       /* horizontal (scan) size */
51   int  vresolu = 0;                       /* vertical resolution */
52  
53   double  dstrsrc = 0.0;                  /* square source distribution */
54   double  shadthresh = .05;               /* shadow threshold */
55   double  shadcert = .5;                  /* shadow certainty */
56 < int  directrelay = 1;                   /* number of source relays */
56 > int  directrelay = 2;                   /* number of source relays */
57   int  vspretest = 512;                   /* virtual source pretest density */
58 < int  directinvis = 0;                   /* sources invisible? */
59 < double  srcsizerat = .25;               /* maximum ratio source size/dist. */
58 > int  directvis = 1;                     /* sources visible? */
59 > double  srcsizerat = .2;                /* maximum ratio source size/dist. */
60  
61 + COLOR  cextinction = BLKCOLOR;          /* global extinction coefficient */
62 + double  salbedo = 0.;                   /* global scattering albedo */
63 + double  seccg = 0.;                     /* global scattering eccentricity */
64 + double  ssampdist = 0.;                 /* scatter sampling distance */
65 +
66 + double  specthresh = .15;               /* specular sampling threshold */
67 + double  specjitter = 1.;                /* specular sampling jitter */
68 +
69 + int  backvis = 1;                       /* back face visibility */
70 +
71   int  maxdepth = 6;                      /* maximum recursion depth */
72   double  minweight = 4e-3;               /* minimum ray weight */
73  
74   COLOR  ambval = BLKCOLOR;               /* ambient value */
75   double  ambacc = 0.2;                   /* ambient accuracy */
76 < int  ambres = 32;                       /* ambient resolution */
77 < int  ambdiv = 128;                      /* ambient divisions */
76 > int  ambres = 128;                      /* ambient resolution */
77 > int  ambdiv = 512;                      /* ambient divisions */
78   int  ambssamp = 0;                      /* ambient super-samples */
79   int  ambounce = 0;                      /* ambient bounces */
80   char  *amblist[128];                    /* ambient include/exclude list */
# Line 67 | Line 84 | extern OBJREC  Lamb;                   /* a Lambertian surface */
84  
85   static RAY  thisray;                    /* for our convenience */
86  
87 < static int  oputo(), oputd(), oputv(), oputl(),
88 <                oputp(), oputn(), oputs(), oputw(), oputm();
87 > static int  oputo(), oputd(), oputv(), oputl(), oputL(),
88 >                oputp(), oputn(), oputN(), oputs(), oputw(), oputm();
89  
90 < static int  (*ray_out[10])(), (*every_out[10])();
91 < static int  castonly;
90 > static int  ourtrace(), tabin();
91 > static int  (*ray_out[16])(), (*every_out[16])();
92 > static int  castonly = 0;
93  
94   static int  puta(), putf(), putd();
95  
# Line 81 | Line 99 | static int  (*putreal)();
99   quit(code)                      /* quit program */
100   int  code;
101   {
102 + #ifndef  NIX
103 +        headclean();            /* delete header file */
104 +        pfclean();              /* clean up persist files */
105 + #endif
106          exit(code);
107   }
108  
109  
110 + char *
111 + formstr(f)                              /* return format identifier */
112 + int  f;
113 + {
114 +        switch (f) {
115 +        case 'a': return("ascii");
116 +        case 'f': return("float");
117 +        case 'd': return("double");
118 +        case 'c': return(COLRFMT);
119 +        }
120 +        return("unknown");
121 + }
122 +
123 +
124   rtrace(fname)                           /* trace rays from file */
125   char  *fname;
126   {
# Line 99 | Line 135 | char  *fname;
135                  sprintf(errmsg, "cannot open input file \"%s\"", fname);
136                  error(SYSTEM, errmsg);
137          }
138 + #ifdef MSDOS
139 +        if (inform != 'a')
140 +                setmode(fileno(fp), O_BINARY);
141 + #endif
142                                          /* set up output */
143          setoutput(outvals);
144          switch (outform) {
145          case 'a': putreal = puta; break;
146          case 'f': putreal = putf; break;
147          case 'd': putreal = putd; break;
148 +        case 'c':
149 +                if (strcmp(outvals, "v"))
150 +                        error(USER, "color format with value output only");
151 +                break;
152 +        default:
153 +                error(CONSISTENCY, "botched output format");
154          }
155 +        if (hresolu > 0) {
156 +                if (vresolu > 0)
157 +                        fprtresolu(hresolu, vresolu, stdout);
158 +                fflush(stdout);
159 +        }
160                                          /* process file */
161          while (getvec(orig, inform, fp) == 0 &&
162                          getvec(direc, inform, fp) == 0) {
# Line 119 | Line 170 | char  *fname;
170                  if (imm_irrad)
171                          irrad(orig, direc);
172                  else
173 <                        traceray(orig, direc);
173 >                        rad(orig, direc);
174                                                          /* flush if time */
175                  if (--nextflush == 0) {
176                          fflush(stdout);
# Line 130 | Line 181 | char  *fname;
181                  if (--vcount == 0)                      /* check for end */
182                          break;
183          }
184 +        fflush(stdout);
185          if (vcount > 0)
186                  error(USER, "read error");
187 <        fclose(fp);
187 >        if (fname != NULL)
188 >                fclose(fp);
189   }
190  
191  
192   setoutput(vs)                           /* set up output tables */
193   register char  *vs;
194   {
195 <        extern int  ourtrace(), (*trace)();
195 >        extern int  (*trace)();
196          register int (**table)() = ray_out;
197  
198          castonly = 1;
# Line 161 | Line 214 | register char  *vs;
214                          *table++ = oputv;
215                          castonly = 0;
216                          break;
217 <                case 'l':                               /* length */
217 >                case 'l':                               /* effective distance */
218                          *table++ = oputl;
219                          castonly = 0;
220                          break;
221 +                case 'L':                               /* single ray length */
222 +                        *table++ = oputL;
223 +                        break;
224                  case 'p':                               /* point */
225                          *table++ = oputp;
226                          break;
227 <                case 'n':                               /* normal */
227 >                case 'n':                               /* perturbed normal */
228                          *table++ = oputn;
229 +                        castonly = 0;
230                          break;
231 +                case 'N':                               /* unperturbed normal */
232 +                        *table++ = oputN;
233 +                        break;
234                  case 's':                               /* surface */
235                          *table++ = oputs;
236                          break;
# Line 185 | Line 245 | register char  *vs;
245   }
246  
247  
248 < traceray(org, dir)              /* compute and print ray value(s) */
248 > rad(org, dir)                   /* compute and print ray value(s) */
249   FVECT  org, dir;
250   {
191 –        register int  (**tp)();
192 –
251          VCOPY(thisray.rorg, org);
252          VCOPY(thisray.rdir, dir);
253 +        thisray.rmax = 0.0;
254          rayorigin(&thisray, NULL, PRIMARY, 1.0);
255          if (castonly)
256                  localhit(&thisray, &thescene) || sourcehit(&thisray);
257          else
258                  rayvalue(&thisray);
259 <
201 <        if (ray_out[0] == NULL)
202 <                return;
203 <        for (tp = ray_out; *tp != NULL; tp++)
204 <                (**tp)(&thisray);
205 <        if (outform == 'a')
206 <                putchar('\n');
259 >        printvals(&thisray);
260   }
261  
262  
# Line 218 | Line 271 | FVECT  org, dir;
271          }
272          rayorigin(&thisray, NULL, PRIMARY, 1.0);
273                                          /* pretend we hit surface */
274 <        thisray.rot = 1.0;
274 >        thisray.rot = 1.0-1e-4;
275          thisray.rod = 1.0;
276          VCOPY(thisray.ron, dir);
277          for (i = 0; i < 3; i++)         /* fudge factor */
278                  thisray.rop[i] = org[i] + 1e-4*dir[i];
279                                          /* compute and print */
280          (*ofun[Lamb.otype].funp)(&Lamb, &thisray);
281 <        oputv(&thisray);
281 >        printvals(&thisray);
282 > }
283 >
284 >
285 > printvals(r)                    /* print requested ray values */
286 > RAY  *r;
287 > {
288 >        register int  (**tp)();
289 >
290 >        if (ray_out[0] == NULL)
291 >                return;
292 >        for (tp = ray_out; *tp != NULL; tp++)
293 >                (**tp)(r);
294          if (outform == 'a')
295                  putchar('\n');
296   }
# Line 237 | Line 302 | int  fmt;
302   FILE  *fp;
303   {
304          extern char  *fgetword();
240 –        extern double  atof();
305          static float  vf[3];
306 +        static double  vd[3];
307          char  buf[32];
308          register int  i;
309  
# Line 257 | Line 322 | FILE  *fp;
322                  vec[0] = vf[0]; vec[1] = vf[1]; vec[2] = vf[2];
323                  break;
324          case 'd':                                       /* binary double */
325 <                if (fread((char *)vec, sizeof(double), 3, fp) != 3)
325 >                if (fread((char *)vd, sizeof(double), 3, fp) != 3)
326                          return(-1);
327 +                vec[0] = vd[0]; vec[1] = vd[1]; vec[2] = vd[2];
328                  break;
329 +        default:
330 +                error(CONSISTENCY, "botched input format");
331          }
332          return(0);
333   }
334  
335  
336 + tranotify(obj)                  /* record new modifier */
337 + OBJECT  obj;
338 + {
339 +        static int  hitlimit = 0;
340 +        register OBJREC  *o = objptr(obj);
341 +        register char  **tralp;
342 +
343 +        if (hitlimit || !ismodifier(o->otype))
344 +                return;
345 +        for (tralp = tralist; *tralp != NULL; tralp++)
346 +                if (!strcmp(o->oname, *tralp)) {
347 +                        if (traset[0] >= MAXTSET) {
348 +                                error(WARNING, "too many modifiers in trace list");
349 +                                hitlimit++;
350 +                                return;         /* should this be fatal? */
351 +                        }
352 +                        insertelem(traset, obj);
353 +                        return;
354 +                }
355 + }
356 +
357 +
358   static
359   ourtrace(r)                             /* print ray values */
360   RAY  *r;
# Line 273 | Line 363 | RAY  *r;
363  
364          if (every_out[0] == NULL)
365                  return;
366 +        if (r->ro == NULL) {
367 +                if (traincl == 1)
368 +                        return;
369 +        } else if (traincl != -1 && traincl != inset(traset, r->ro->omod))
370 +                return;
371          tabin(r);
372          for (tp = every_out; *tp != NULL; tp++)
373                  (**tp)(r);
# Line 315 | Line 410 | static
410   oputv(r)                                /* print value */
411   register RAY  *r;
412   {
413 +        COLR  cout;
414 +        
415 +        if (outform == 'c') {
416 +                setcolr(cout,   colval(r->rcol,RED),
417 +                                colval(r->rcol,GRN),
418 +                                colval(r->rcol,BLU));
419 +                fwrite((char *)cout, sizeof(cout), 1, stdout);
420 +                return;
421 +        }
422          (*putreal)(colval(r->rcol,RED));
423          (*putreal)(colval(r->rcol,GRN));
424          (*putreal)(colval(r->rcol,BLU));
# Line 322 | Line 426 | register RAY  *r;
426  
427  
428   static
429 < oputl(r)                                /* print length */
429 > oputl(r)                                /* print effective distance */
430   register RAY  *r;
431   {
432          (*putreal)(r->rt);
# Line 330 | Line 434 | register RAY  *r;
434  
435  
436   static
437 + oputL(r)                                /* print single ray length */
438 + register RAY  *r;
439 + {
440 +        (*putreal)(r->rot);
441 + }
442 +
443 +
444 + static
445   oputp(r)                                /* print point */
446   register RAY  *r;
447   {
# Line 346 | Line 458 | register RAY  *r;
458  
459  
460   static
461 < oputn(r)                                /* print normal */
461 > oputN(r)                                /* print unperturbed normal */
462   register RAY  *r;
463   {
464          if (r->rot < FHUGE) {
# Line 358 | Line 470 | register RAY  *r;
470                  (*putreal)(0.0);
471                  (*putreal)(0.0);
472          }
473 + }
474 +
475 +
476 + static
477 + oputn(r)                                /* print perturbed normal */
478 + RAY  *r;
479 + {
480 +        FVECT  pnorm;
481 +
482 +        if (r->rot >= FHUGE) {
483 +                (*putreal)(0.0);
484 +                (*putreal)(0.0);
485 +                (*putreal)(0.0);
486 +                return;
487 +        }
488 +        raynormal(pnorm, r);
489 +        (*putreal)(pnorm[0]);
490 +        (*putreal)(pnorm[1]);
491 +        (*putreal)(pnorm[2]);
492   }
493  
494  

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines