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 2.57 by greg, Sat Dec 12 19:01:00 2009 UTC vs.
Revision 2.59 by greg, Sun Dec 13 19:13:04 2009 UTC

# Line 63 | Line 63 | static oputf_t  oputo, oputd, oputv, oputV, oputl, opu
63   static void setoutput(char *vs);
64   extern void tranotify(OBJECT obj);
65   static void bogusray(void);
66 < static void rad(FVECT org, FVECT dir, double dmax);
67 < static void irrad(FVECT org, FVECT dir);
66 > static void raycast(RAY *r);
67 > static void rayirrad(RAY *r);
68 > static void rtcompute(FVECT org, FVECT dir, double dmax);
69   static int printvals(RAY *r);
70   static int getvec(FVECT vec, int fmt, FILE *fp);
71   static void tabin(RAY *r);
# Line 82 | Line 83 | quit(                  /* quit program */
83          if (ray_pnprocs > 0)    /* close children if any */
84                  ray_pclose(0);          
85   #ifndef  NON_POSIX
86 <        headclean();            /* delete header file */
87 <        pfclean();              /* clean up persist files */
86 >        else if (!ray_pnprocs) {
87 >                headclean();    /* delete header file */
88 >                pfclean();      /* clean up persist files */
89 >        }
90   #endif
91          exit(code);
92   }
# Line 106 | Line 109 | formstr(                               /* return format identifier */
109  
110   extern void
111   rtrace(                         /* trace rays from file */
112 <        char  *fname
112 >        char  *fname,
113 >        int  nproc
114   )
115   {
116          unsigned long  vcount = (hresolu > 1) ? (unsigned long)hresolu*vresolu
# Line 126 | Line 130 | rtrace(                                /* trace rays from file */
130                  SET_FILE_BINARY(fp);
131                                          /* set up output */
132          setoutput(outvals);
133 +        if (imm_irrad)
134 +                castonly = 0;
135 +        else if (castonly)
136 +                nproc = 1;              /* don't bother multiprocessing */
137          switch (outform) {
138          case 'a': putreal = puta; break;
139          case 'f': putreal = putf; break;
# Line 137 | Line 145 | rtrace(                                /* trace rays from file */
145          default:
146                  error(CONSISTENCY, "botched output format");
147          }
148 <        ray_fifo_out = printvals;
148 >        if (nproc > 1) {                /* start multiprocessing */
149 >                ray_popen(nproc);
150 >                ray_fifo_out = printvals;
151 >        }
152          if (hresolu > 0) {
153                  if (vresolu > 0)
154                          fprtresolu(hresolu, vresolu, stdout);
# Line 149 | Line 160 | rtrace(                                /* trace rays from file */
160  
161                  d = normalize(direc);
162                  if (d == 0.0) {                         /* zero ==> flush */
163 <                        if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
163 >                        if (nproc > 1 && ray_fifo_flush() < 0)
164                                  error(USER, "lost children");
165                          bogusray();
166                          if (--nextflush <= 0 || !vcount) {
# Line 157 | Line 168 | rtrace(                                /* trace rays from file */
168                                  nextflush = hresolu;
169                          }
170                  } else {                                /* compute and print */
171 <                        if (imm_irrad)
161 <                                irrad(orig, direc);
162 <                        else
163 <                                rad(orig, direc, lim_dist ? d : 0.0);
171 >                        rtcompute(orig, direc, lim_dist ? d : 0.0);
172                                                          /* flush if time */
173                          if (!--nextflush) {
174 <                                if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
174 >                                if (nproc > 1 && ray_fifo_flush() < 0)
175                                          error(USER, "lost children");
176                                  fflush(stdout);
177                                  nextflush = hresolu;
# Line 174 | Line 182 | rtrace(                                /* trace rays from file */
182                  if (vcount && !--vcount)                /* check for end */
183                          break;
184          }
185 <        if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
186 <                error(USER, "unable to complete processing");
185 >        if (nproc > 1) {                                /* clean up children */
186 >                if (ray_fifo_flush() < 0)
187 >                        error(USER, "unable to complete processing");
188 >                ray_pclose(0);
189 >        }
190          if (fflush(stdout) < 0)
191                  error(SYSTEM, "write error");
192          if (vcount)
# Line 290 | Line 301 | bogusray(void)                 /* print out empty record */
301  
302  
303   static void
304 < rad(            /* compute and print ray value(s) */
305 <        FVECT  org,
295 <        FVECT  dir,
296 <        double  dmax
304 > raycast(                        /* compute first ray intersection only */
305 >        RAY *r
306   )
307   {
308 <        VCOPY(thisray.rorg, org);
309 <        VCOPY(thisray.rdir, dir);
310 <        thisray.rmax = dmax;
311 <        if (ray_pnprocs > 1) {
312 <                if (ray_fifo_in(&thisray) < 0)
313 <                        error(USER, "lost children");
305 <                return;
308 >        if (!localhit(r, &thescene)) {
309 >                if (r->ro == &Aftplane) {       /* clipped */
310 >                        r->ro = NULL;
311 >                        r->rot = FHUGE;
312 >                } else
313 >                        sourcehit(r);
314          }
307 –        rayorigin(&thisray, PRIMARY, NULL, NULL);
308 –        if (castonly) {
309 –                if (!localhit(&thisray, &thescene)) {
310 –                        if (thisray.ro == &Aftplane) {  /* clipped */
311 –                                thisray.ro = NULL;
312 –                                thisray.rot = FHUGE;
313 –                        } else
314 –                                sourcehit(&thisray);
315 –                }
316 –        } else
317 –                ray_trace(&thisray);
318 –        printvals(&thisray);
315   }
316  
317  
318   static void
319 < irrad(                  /* compute immediate irradiance value */
319 > rayirrad(                       /* compute irradiance rather than radiance */
320 >        RAY *r
321 > )
322 > {
323 >        r->rot = 1e-5;                  /* pretend we hit surface */
324 >        VSUM(r->rop, r->rorg, r->rdir, r->rot);
325 >        r->ron[0] = -r->rdir[0];
326 >        r->ron[1] = -r->rdir[1];
327 >        r->ron[2] = -r->rdir[2];
328 >        r->rod = 1.0;
329 >                                        /* compute result */
330 >        (*ofun[Lamb.otype].funp)(&Lamb, r);
331 > }
332 >
333 >
334 > static void
335 > rtcompute(                      /* compute and print ray value(s) */
336          FVECT  org,
337 <        FVECT  dir
337 >        FVECT  dir,
338 >        double  dmax
339   )
340   {
341 <        VSUM(thisray.rorg, org, dir, 1.1e-4);
342 <        thisray.rdir[0] = -dir[0];
343 <        thisray.rdir[1] = -dir[1];
344 <        thisray.rdir[2] = -dir[2];
345 <        thisray.rmax = 0.0;
341 >        if (imm_irrad) {                /* set up ray */
342 >                VSUM(thisray.rorg, org, dir, 1.1e-4);
343 >                thisray.rdir[0] = -dir[0];
344 >                thisray.rdir[1] = -dir[1];
345 >                thisray.rdir[2] = -dir[2];
346 >                thisray.rmax = 0.0;
347 >        } else {
348 >                VCOPY(thisray.rorg, org);
349 >                VCOPY(thisray.rdir, dir);
350 >                thisray.rmax = dmax;
351 >        }
352          rayorigin(&thisray, PRIMARY, NULL, NULL);
353 <                                        /* pretend we hit surface */
354 <        thisray.rot = 1e-5;
355 <        thisray.rod = 1.0;
356 <        VCOPY(thisray.ron, dir);
357 <        VSUM(thisray.rop, org, dir, 1e-4);
358 <                                        /* compute and print */
359 <        (*ofun[Lamb.otype].funp)(&Lamb, &thisray);
353 >                                        /* special case evaluators */
354 >        if (castonly)
355 >                thisray.revf = raycast;
356 >        else if (imm_irrad)
357 >                thisray.revf = rayirrad;
358 >
359 >        if (ray_pnprocs > 1) {          /* multiprocessing FIFO? */
360 >                if (ray_fifo_in(&thisray) < 0)
361 >                        error(USER, "lost children");
362 >                return;
363 >        }
364 >        samplendx++;                    /* else do it ourselves */
365 >        rayvalue(&thisray);
366          printvals(&thisray);
367   }
368  
# Line 383 | Line 408 | getvec(                /* get a vector from fp */
408          case 'f':                                       /* binary float */
409                  if (fread((char *)vf, sizeof(float), 3, fp) != 3)
410                          return(-1);
411 <                vec[0] = vf[0]; vec[1] = vf[1]; vec[2] = vf[2];
411 >                VCOPY(vec, vf);
412                  break;
413          case 'd':                                       /* binary double */
414                  if (fread((char *)vd, sizeof(double), 3, fp) != 3)
415                          return(-1);
416 <                vec[0] = vd[0]; vec[1] = vd[1]; vec[2] = vd[2];
416 >                VCOPY(vec, vd);
417                  break;
418          default:
419                  error(CONSISTENCY, "botched input format");

Diff Legend

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