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.63 by greg, Wed Dec 16 03:30:50 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 */
152 –                        if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
153 –                                error(USER, "lost children");
154 –                        bogusray();
163                          if (--nextflush <= 0 || !vcount) {
164 +                                if (nproc > 1 && ray_fifo_flush() < 0)
165 +                                        error(USER, "lost children");
166 +                                bogusray();
167                                  fflush(stdout);
168                                  nextflush = hresolu;
169 <                        }
169 >                        } else
170 >                                bogusray();
171                  } else {                                /* compute and print */
172 <                        if (imm_irrad)
161 <                                irrad(orig, direc);
162 <                        else
163 <                                rad(orig, direc, lim_dist ? d : 0.0);
172 >                        rtcompute(orig, direc, lim_dist ? d : 0.0);
173                                                          /* flush if time */
174                          if (!--nextflush) {
175 <                                if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
175 >                                if (nproc > 1 && ray_fifo_flush() < 0)
176                                          error(USER, "lost children");
177                                  fflush(stdout);
178                                  nextflush = hresolu;
# Line 174 | Line 183 | rtrace(                                /* trace rays from file */
183                  if (vcount && !--vcount)                /* check for end */
184                          break;
185          }
186 <        if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
187 <                error(USER, "unable to complete processing");
186 >        if (nproc > 1) {                                /* clean up children */
187 >                if (ray_fifo_flush() < 0)
188 >                        error(USER, "unable to complete processing");
189 >                ray_pclose(0);
190 >        }
191          if (fflush(stdout) < 0)
192                  error(SYSTEM, "write error");
193          if (vcount)
# Line 290 | Line 302 | bogusray(void)                 /* print out empty record */
302  
303  
304   static void
305 < rad(            /* compute and print ray value(s) */
306 <        FVECT  org,
295 <        FVECT  dir,
296 <        double  dmax
305 > raycast(                        /* compute first ray intersection only */
306 >        RAY *r
307   )
308   {
309 <        VCOPY(thisray.rorg, org);
310 <        VCOPY(thisray.rdir, dir);
311 <        thisray.rmax = dmax;
312 <        if (ray_pnprocs > 1) {
313 <                if (ray_fifo_in(&thisray) < 0)
314 <                        error(USER, "lost children");
305 <                return;
309 >        if (!localhit(r, &thescene)) {
310 >                if (r->ro == &Aftplane) {       /* clipped */
311 >                        r->ro = NULL;
312 >                        r->rot = FHUGE;
313 >                } else
314 >                        sourcehit(r);
315          }
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);
316   }
317  
318  
319   static void
320 < irrad(                  /* compute immediate irradiance value */
320 > rayirrad(                       /* compute irradiance rather than radiance */
321 >        RAY *r
322 > )
323 > {
324 >        void    (*old_revf)(RAY *) = r->revf;
325 >
326 >        r->rot = 1e-5;                  /* pretend we hit surface */
327 >        VSUM(r->rop, r->rorg, r->rdir, r->rot);
328 >        r->ron[0] = -r->rdir[0];
329 >        r->ron[1] = -r->rdir[1];
330 >        r->ron[2] = -r->rdir[2];
331 >        r->rod = 1.0;
332 >                                        /* compute result */
333 >        r->revf = raytrace;
334 >        (*ofun[Lamb.otype].funp)(&Lamb, r);
335 >        r->revf = old_revf;
336 > }
337 >
338 >
339 > static void
340 > rtcompute(                      /* compute and print ray value(s) */
341          FVECT  org,
342 <        FVECT  dir
342 >        FVECT  dir,
343 >        double  dmax
344   )
345   {
346 <        VSUM(thisray.rorg, org, dir, 1.1e-4);
329 <        thisray.rdir[0] = -dir[0];
330 <        thisray.rdir[1] = -dir[1];
331 <        thisray.rdir[2] = -dir[2];
332 <        thisray.rmax = 0.0;
346 >                                        /* set up ray */
347          rayorigin(&thisray, PRIMARY, NULL, NULL);
348 <                                        /* pretend we hit surface */
349 <        thisray.rot = 1e-5;
350 <        thisray.rod = 1.0;
351 <        VCOPY(thisray.ron, dir);
352 <        VSUM(thisray.rop, org, dir, 1e-4);
353 <                                        /* compute and print */
354 <        (*ofun[Lamb.otype].funp)(&Lamb, &thisray);
348 >        if (imm_irrad) {
349 >                VSUM(thisray.rorg, org, dir, 1.1e-4);
350 >                thisray.rdir[0] = -dir[0];
351 >                thisray.rdir[1] = -dir[1];
352 >                thisray.rdir[2] = -dir[2];
353 >                thisray.rmax = 0.0;
354 >                thisray.revf = rayirrad;
355 >        } else {
356 >                VCOPY(thisray.rorg, org);
357 >                VCOPY(thisray.rdir, dir);
358 >                thisray.rmax = dmax;
359 >                if (castonly)
360 >                        thisray.revf = raycast;
361 >        }
362 >        if (ray_pnprocs > 1) {          /* multiprocessing FIFO? */
363 >                if (ray_fifo_in(&thisray) < 0)
364 >                        error(USER, "lost children");
365 >                return;
366 >        }
367 >        samplendx++;                    /* else do it ourselves */
368 >        rayvalue(&thisray);
369          printvals(&thisray);
370   }
371  
# Line 383 | Line 411 | getvec(                /* get a vector from fp */
411          case 'f':                                       /* binary float */
412                  if (fread((char *)vf, sizeof(float), 3, fp) != 3)
413                          return(-1);
414 <                vec[0] = vf[0]; vec[1] = vf[1]; vec[2] = vf[2];
414 >                VCOPY(vec, vf);
415                  break;
416          case 'd':                                       /* binary double */
417                  if (fread((char *)vd, sizeof(double), 3, fp) != 3)
418                          return(-1);
419 <                vec[0] = vd[0]; vec[1] = vd[1]; vec[2] = vd[2];
419 >                VCOPY(vec, vd);
420                  break;
421          default:
422                  error(CONSISTENCY, "botched input format");

Diff Legend

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