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

Comparing ray/src/rt/rcontrib.c (file contents):
Revision 2.4 by greg, Tue Jun 12 17:20:44 2012 UTC vs.
Revision 2.10 by greg, Tue Jun 19 00:12:08 2012 UTC

# Line 27 | Line 27 | int    do_irrad = 0;                   /* compute irradiance? */
27  
28   int     rand_samp = 1;                  /* pure Monte Carlo sampling? */
29  
30 < double  dstrsrc = 0.0;                  /* square source distribution */
30 > double  dstrsrc = 0.9;                  /* square source distribution */
31   double  shadthresh = .03;               /* shadow threshold */
32   double  shadcert = .75;                 /* shadow certainty */
33   int     directrelay = 3;                /* number of source relays */
# Line 70 | Line 70 | static void mcfree(void *p) { epfree((*(MODCONT *)p).b
70  
71   LUTAB   modconttab = LU_SINIT(NULL,mcfree);     /* modifier lookup table */
72  
73 – static OBJECT           traset[MAXTSET+1]={0};  /* trace include set */
74 –
73   /************************** INITIALIZATION ROUTINES ***********************/
74  
77 – void
78 – tranotify(                      /* record new modifier */
79 –        OBJECT  obj
80 – )
81 – {
82 –        static int      hitlimit = 0;
83 –        OBJREC          *o = objptr(obj);
84 –        int             i;
85 –
86 –        if (obj == OVOID) {             /* starting over */
87 –                traset[0] = 0;
88 –                hitlimit = 0;
89 –                return;
90 –        }
91 –        if (hitlimit || !ismodifier(o->otype))
92 –                return;
93 –        for (i = nmods; i-- > 0; )
94 –                if (!strcmp(o->oname, modname[i])) {
95 –                        if (traset[0] >= MAXTSET) {
96 –                                error(WARNING, "too many same-named modifiers");
97 –                                hitlimit++;
98 –                                return;         /* should this be fatal? */
99 –                        }
100 –                        insertelem(traset, obj);
101 –                        break;
102 –                }
103 – }
104 –
105 –
75   char *
76   formstr(                                /* return format identifier */
77          int  f
# Line 168 | Line 137 | addmodifier(char *modn, char *outf, char *binv, int bi
137   }
138  
139  
140 < /* add modifiers from a file list */
140 > /* Add modifiers from a file list */
141   void
142   addmodfile(char *fname, char *outf, char *binv, int bincnt)
143   {
# Line 190 | Line 159 | quit(                  /* quit program */
159   )
160   {
161          if (nchild > 0)         /* close children if any */
162 <                end_children();
162 >                end_children(code != 0);
163          exit(code);
164   }
165  
# Line 209 | Line 178 | rcinit()
178                                          /* set shared memory boundary */
179                  shm_boundary = strcpy((char *)malloc(16), "SHM_BOUNDARY");
180          }
212 –        if ((nproc > 1) & (accumulate <= 0))
213 –                put_zero_record(0);     /* prime our queue to accumulate */
214 –
215 –        if (recover) {                  /* recover previous output? */
216 –                if (accumulate <= 0) {
217 –                        reload_output();
218 –                        if (nproc > 1)
219 –                                queue_modifiers();
220 –                } else
221 –                        recover_output();
222 –        }
181          if (yres > 0) {                 /* set up flushing & ray counts */
182                  if (xres > 0)
183                          raysleft = (RNUMBER)xres*yres;
# Line 234 | Line 192 | rcinit()
192          for (i = 0; i < nsources; i++)
193                  source[i].sflags |= SFOLLOW;
194  
195 <        if (nproc == 1 || in_rchild())  /* single process or child */
195 >        if (nproc > 1 && in_rchild())   /* forked child? */
196                  return;                 /* return to main processing loop */
197  
198 <        parental_loop();                /* else run controller */
198 >        if (recover) {                  /* recover previous output? */
199 >                if (accumulate <= 0)
200 >                        reload_output();
201 >                else
202 >                        recover_output();
203 >        }
204 >        if (nproc == 1)                 /* single process? */
205 >                return;
206 >                                        /* else run appropriate controller */
207 >        if (accumulate <= 0)
208 >                feeder_loop();
209 >        else
210 >                parental_loop();
211          quit(0);                        /* parent musn't return! */
212   }
213  
# Line 251 | Line 221 | trace_contrib(RAY *r)
221          int     bn;
222          RREAL   contr[3];
223  
224 <        if (r->ro == NULL || !inset(traset, r->ro->omod))
224 >        if (r->ro == NULL || r->ro->omod == OVOID)
225                  return;
226  
227          mp = (MODCONT *)lu_find(&modconttab,objptr(r->ro->omod)->oname)->data;
228  
229 <        if (mp == NULL)
230 <                error(CONSISTENCY, "unexpected modifier in trace_contrib()");
229 >        if (mp == NULL)                         /* not in our list? */
230 >                return;
231  
232          worldfunc(RCCONTEXT, r);                /* get bin number */
233          bn = (int)(evalue(mp->binv) + .5);
# Line 272 | Line 242 | trace_contrib(RAY *r)
242   }
243  
244  
245 + /* Evaluate irradiance contributions */
246   static void
247 < rayirrad(                       /* compute irradiance rather than radiance */
277 <        RAY *r
278 < )
247 > eval_irrad(FVECT org, FVECT dir)
248   {
249 <        r->rot = 1e-5;                  /* pretend we hit surface */
250 <        VSUM(r->rop, r->rorg, r->rdir, r->rot);
251 <        r->ron[0] = -r->rdir[0];
252 <        r->ron[1] = -r->rdir[1];
253 <        r->ron[2] = -r->rdir[2];
254 <        r->rod = 1.0;
255 <                                        /* compute result */
256 <        r->revf = raytrace;
257 <        (*ofun[Lamb.otype].funp)(&Lamb, r);
258 <        r->revf = rayirrad;
249 >        RAY     thisray;
250 >
251 >        VSUM(thisray.rorg, org, dir, 1.1e-4);
252 >        thisray.rdir[0] = -dir[0];
253 >        thisray.rdir[1] = -dir[1];
254 >        thisray.rdir[2] = -dir[2];
255 >        thisray.rmax = 0.0;
256 >        rayorigin(&thisray, PRIMARY, NULL, NULL);
257 >        thisray.rot = 1e-5;             /* pretend we hit surface */
258 >        thisray.rod = 1.0;
259 >        VSUM(thisray.rop, org, dir, 1e-4);
260 >        samplendx++;                    /* compute result */
261 >        (*ofun[Lamb.otype].funp)(&Lamb, &thisray);
262   }
263  
264  
265 < /* Evaluate ray contributions */
265 > /* Evaluate radiance contributions */
266   static void
267 < eval_ray(FVECT  org, FVECT  dir, double dmax)
267 > eval_rad(FVECT org, FVECT dir, double dmax)
268   {
269          RAY     thisray;
270                                          /* set up ray */
271 +        VCOPY(thisray.rorg, org);
272 +        VCOPY(thisray.rdir, dir);
273 +        thisray.rmax = dmax;
274          rayorigin(&thisray, PRIMARY, NULL, NULL);
300 –        if (imm_irrad) {
301 –                VSUM(thisray.rorg, org, dir, 1.1e-4);
302 –                thisray.rdir[0] = -dir[0];
303 –                thisray.rdir[1] = -dir[1];
304 –                thisray.rdir[2] = -dir[2];
305 –                thisray.rmax = 0.0;
306 –                thisray.revf = rayirrad;
307 –        } else {
308 –                VCOPY(thisray.rorg, org);
309 –                VCOPY(thisray.rdir, dir);
310 –                thisray.rmax = dmax;
311 –        }
275          samplendx++;                    /* call ray evaluation */
276          rayvalue(&thisray);
277   }
# Line 363 | Line 326 | rcontrib()
326                          if ((yres <= 0) | (xres <= 0))
327                                  waitflush = 1;          /* flush right after */
328                          account = 1;
329 <                } else {                                /* else compute */
330 <                        eval_ray(orig, direc, lim_dist ? d : 0.0);
329 >                } else if (imm_irrad) {                 /* else compute */
330 >                        eval_irrad(orig, direc);
331 >                } else {
332 >                        eval_rad(orig, direc, lim_dist ? d : 0.0);
333                  }
334                  done_contrib();         /* accumulate/output */
335                  ++lastdone;
336                  if (raysleft && !--raysleft)
337                          break;          /* preemptive EOI */
338          }
339 <        if (nchild != -1 && (accumulate <= 0) | (account < accumulate)) {
339 >        if ((accumulate <= 0) | (account < accumulate)) {
340                  if (account < accumulate) {
341                          error(WARNING, "partial accumulation in final record");
342                          accumulate -= account;
# Line 379 | Line 344 | rcontrib()
344                  account = 1;            /* output accumulated totals */
345                  done_contrib();
346          }
347 +        lu_done(&ofiletab);             /* close output files */
348          if (raysleft)
349                  error(USER, "unexpected EOF on input");
384 –        lu_done(&ofiletab);             /* close output files */
350   }

Diff Legend

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