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.62 by greg, Mon Dec 14 07:31:37 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 >        void    (*old_revf)(RAY *) = r->revf;
324 >
325 >        r->rot = 1e-5;                  /* pretend we hit surface */
326 >        VSUM(r->rop, r->rorg, r->rdir, r->rot);
327 >        r->ron[0] = -r->rdir[0];
328 >        r->ron[1] = -r->rdir[1];
329 >        r->ron[2] = -r->rdir[2];
330 >        r->rod = 1.0;
331 >                                        /* compute result */
332 >        r->revf = raytrace;
333 >        (*ofun[Lamb.otype].funp)(&Lamb, r);
334 >        r->revf = old_revf;
335 > }
336 >
337 >
338 > static void
339 > rtcompute(                      /* compute and print ray value(s) */
340          FVECT  org,
341 <        FVECT  dir
341 >        FVECT  dir,
342 >        double  dmax
343   )
344   {
345 <        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;
345 >                                        /* set up ray */
346          rayorigin(&thisray, PRIMARY, NULL, NULL);
347 <                                        /* pretend we hit surface */
348 <        thisray.rot = 1e-5;
349 <        thisray.rod = 1.0;
350 <        VCOPY(thisray.ron, dir);
351 <        VSUM(thisray.rop, org, dir, 1e-4);
352 <                                        /* compute and print */
353 <        (*ofun[Lamb.otype].funp)(&Lamb, &thisray);
347 >        if (imm_irrad) {
348 >                VSUM(thisray.rorg, org, dir, 1.1e-4);
349 >                thisray.rdir[0] = -dir[0];
350 >                thisray.rdir[1] = -dir[1];
351 >                thisray.rdir[2] = -dir[2];
352 >                thisray.rmax = 0.0;
353 >                thisray.revf = rayirrad;
354 >        } else {
355 >                VCOPY(thisray.rorg, org);
356 >                VCOPY(thisray.rdir, dir);
357 >                thisray.rmax = dmax;
358 >                if (castonly)
359 >                        thisray.revf = raycast;
360 >        }
361 >        if (ray_pnprocs > 1) {          /* multiprocessing FIFO? */
362 >                if (ray_fifo_in(&thisray) < 0)
363 >                        error(USER, "lost children");
364 >                return;
365 >        }
366 >        samplendx++;                    /* else do it ourselves */
367 >        rayvalue(&thisray);
368          printvals(&thisray);
369   }
370  
# Line 383 | Line 410 | getvec(                /* get a vector from fp */
410          case 'f':                                       /* binary float */
411                  if (fread((char *)vf, sizeof(float), 3, fp) != 3)
412                          return(-1);
413 <                vec[0] = vf[0]; vec[1] = vf[1]; vec[2] = vf[2];
413 >                VCOPY(vec, vf);
414                  break;
415          case 'd':                                       /* binary double */
416                  if (fread((char *)vd, sizeof(double), 3, fp) != 3)
417                          return(-1);
418 <                vec[0] = vd[0]; vec[1] = vd[1]; vec[2] = vd[2];
418 >                VCOPY(vec, vd);
419                  break;
420          default:
421                  error(CONSISTENCY, "botched input format");

Diff Legend

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