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

Diff Legend

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