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.9 by greg, Sat Jun 16 17:30:13 2012 UTC vs.
Revision 2.32 by greg, Wed Jun 13 21:23:45 2018 UTC

# Line 6 | Line 6 | static const char RCSid[] = "$Id$";
6   * Initialization and calculation routines
7   */
8  
9 + #include "copyright.h"
10 +
11   #include "rcontrib.h"
10 – #include "source.h"
12   #include "otypes.h"
13 < #include "platform.h"
13 > #include "source.h"
14  
15   char    *shm_boundary = NULL;           /* boundary of shared memory */
16  
# Line 20 | Line 21 | int    dimlist[MAXDIM];                /* sampling dimensions */
21   int     ndims = 0;                      /* number of sampling dimensions */
22   int     samplendx = 0;                  /* index for this sample */
23  
24 < static void     trace_contrib(RAY *r);  /* our trace callback */
24 < void    (*trace)() = trace_contrib;
24 > void    (*trace)();
25  
26   int     do_irrad = 0;                   /* compute irradiance? */
27  
28   int     rand_samp = 1;                  /* pure Monte Carlo sampling? */
29  
30   double  dstrsrc = 0.9;                  /* square source distribution */
31 < double  shadthresh = .03;               /* shadow threshold */
31 > double  shadthresh = 0.;                /* shadow threshold */
32   double  shadcert = .75;                 /* shadow certainty */
33   int     directrelay = 3;                /* number of source relays */
34   int     vspretest = 512;                /* virtual source pretest density */
# Line 40 | Line 40 | COLOR  salbedo = BLKCOLOR;             /* global scattering albedo
40   double  seccg = 0.;                     /* global scattering eccentricity */
41   double  ssampdist = 0.;                 /* scatter sampling distance */
42  
43 < double  specthresh = .15;               /* specular sampling threshold */
43 > double  specthresh = .02;               /* specular sampling threshold */
44   double  specjitter = 1.;                /* specular sampling jitter */
45  
46   int     backvis = 1;                    /* back face visibility */
# Line 51 | Line 51 | double minweight = 2e-3;               /* minimum ray weight */
51   char    *ambfile = NULL;                /* ambient file name */
52   COLOR   ambval = BLKCOLOR;              /* ambient value */
53   int     ambvwt = 0;                     /* initial weight for ambient value */
54 < double  ambacc = 0;                     /* ambient accuracy */
54 > double  ambacc = 0.;                    /* ambient accuracy */
55   int     ambres = 256;                   /* ambient resolution */
56   int     ambdiv = 350;                   /* ambient divisions */
57   int     ambssamp = 0;                   /* ambient super-samples */
# Line 66 | Line 66 | long   waitflush;                      /* how long until next flush */
66   RNUMBER lastray = 0;                    /* last ray number sent */
67   RNUMBER lastdone = 0;                   /* last ray output */
68  
69 + static void     trace_contrib(RAY *r);  /* our trace callback */
70 +
71   static void mcfree(void *p) { epfree((*(MODCONT *)p).binv); free(p); }
72  
73   LUTAB   modconttab = LU_SINIT(NULL,mcfree);     /* modifier lookup table */
# Line 89 | Line 91 | formstr(                               /* return format identifier */
91  
92   /* Add modifier to our list to track */
93   MODCONT *
94 < addmodifier(char *modn, char *outf, char *binv, int bincnt)
94 > addmodifier(char *modn, char *outf, char *prms, char *binv, int bincnt)
95   {
96          LUENT   *lep = lu_find(&modconttab,modn);
97          MODCONT *mp;
# Line 100 | Line 102 | addmodifier(char *modn, char *outf, char *binv, int bi
102                  sprintf(errmsg, "duplicate modifier '%s'", modn);
103                  error(USER, errmsg);
104          }
105 <        if (nmods >= MAXMODLIST)
106 <                error(INTERNAL, "too many modifiers");
105 >        if (nmods >= MAXMODLIST) {
106 >                sprintf(errmsg, "too many modifiers (%d limit)", MAXMODLIST);
107 >                error(INTERNAL, errmsg);
108 >        }
109 >        if (!strcmp(modn, VOIDID)) {
110 >                sprintf(errmsg, "cannot track '%s' modifier", VOIDID);
111 >                error(USER, errmsg);
112 >        }
113          modname[nmods++] = modn;        /* XXX assumes static string */
114          lep->key = modn;                /* XXX assumes static string */
115          if (binv == NULL)
# Line 126 | Line 134 | addmodifier(char *modn, char *outf, char *binv, int bi
134                  error(SYSTEM, "out of memory in addmodifier");
135          mp->outspec = outf;             /* XXX assumes static string */
136          mp->modname = modn;             /* XXX assumes static string */
137 +        mp->params = prms;              /* XXX assumes static string */
138          mp->binv = ebinv;
139 +        mp->bin0 = 0;
140          mp->nbins = bincnt;
141          memset(mp->cbin, 0, sizeof(DCOLOR)*bincnt);
142 <                                        /* allocate output streams */
143 <        for (i = bincnt; i-- > 0; )
144 <                getostream(mp->outspec, mp->modname, i, 1);
142 >                                        /* figure out starting bin */
143 >        while (!getostream(mp->outspec, mp->modname, mp->bin0, 1))
144 >                mp->bin0++;
145 >                                        /* allocate other output streams */
146 >        for (i = 0; ++i < mp->nbins; )
147 >                getostream(mp->outspec, mp->modname, mp->bin0+i, 1);
148          lep->data = (char *)mp;
149          return(mp);
150   }
151  
152  
153 < /* add modifiers from a file list */
153 > /* Add modifiers from a file list */
154   void
155 < addmodfile(char *fname, char *outf, char *binv, int bincnt)
155 > addmodfile(char *fname, char *outf, char *prms, char *binv, int bincnt)
156   {
157          char    *mname[MAXMODLIST];
158          int     i;
159                                          /* find the file & store strings */
160 <        if (wordfile(mname, getpath(fname, getrlibpath(), R_OK)) < 0) {
160 >        i = wordfile(mname, MAXMODLIST, getpath(fname, getrlibpath(), R_OK));
161 >        if (i < 0) {
162                  sprintf(errmsg, "cannot find modifier file '%s'", fname);
163                  error(SYSTEM, errmsg);
164          }
165 +        if (i >= MAXMODLIST-1) {
166 +                sprintf(errmsg, "too many modifiers (%d limit) in file '%s'",
167 +                                MAXMODLIST-1, fname);
168 +                error(INTERNAL, errmsg);
169 +        }
170          for (i = 0; mname[i]; i++)      /* add each one */
171 <                addmodifier(mname[i], outf, binv, bincnt);
171 >                addmodifier(mname[i], outf, prms, binv, bincnt);
172   }
173  
174  
# Line 159 | Line 178 | quit(                  /* quit program */
178   )
179   {
180          if (nchild > 0)         /* close children if any */
181 <                end_children();
181 >                end_children(code != 0);
182          exit(code);
183   }
184  
185  
186   /* Initialize our process(es) */
187   static void
188 < rcinit()
188 > rcinit(void)
189   {
190          int     i;
191  
# Line 178 | Line 197 | rcinit()
197                                          /* set shared memory boundary */
198                  shm_boundary = strcpy((char *)malloc(16), "SHM_BOUNDARY");
199          }
200 +        trace = trace_contrib;          /* set up trace call-back */
201 +        for (i = 0; i < nsources; i++)  /* tracing to sources as well */
202 +                source[i].sflags |= SFOLLOW;
203          if (yres > 0) {                 /* set up flushing & ray counts */
204                  if (xres > 0)
205                          raysleft = (RNUMBER)xres*yres;
# Line 188 | Line 210 | rcinit()
210          if ((account = accumulate) > 1)
211                  raysleft *= accumulate;
212          waitflush = (yres > 0) & (xres > 1) ? 0 : xres;
191 –                                        /* tracing to sources as well */
192 –        for (i = 0; i < nsources; i++)
193 –                source[i].sflags |= SFOLLOW;
213  
214          if (nproc > 1 && in_rchild())   /* forked child? */
215                  return;                 /* return to main processing loop */
# Line 218 | Line 237 | static void
237   trace_contrib(RAY *r)
238   {
239          MODCONT *mp;
240 +        double  bval;
241          int     bn;
242          RREAL   contr[3];
243  
244          if (r->ro == NULL || r->ro->omod == OVOID)
245                  return;
246 +                                                /* shadow ray not on source? */
247 +        if (r->rsrc >= 0 && source[r->rsrc].so != r->ro)
248 +                return;
249  
250          mp = (MODCONT *)lu_find(&modconttab,objptr(r->ro->omod)->oname)->data;
251  
252          if (mp == NULL)                         /* not in our list? */
253                  return;
254  
255 <        worldfunc(RCCONTEXT, r);                /* get bin number */
256 <        bn = (int)(evalue(mp->binv) + .5);
257 <        if ((bn < 0) | (bn >= mp->nbins)) {
258 <                error(WARNING, "bad bin number (ignored)");
255 >        worldfunc(RCCONTEXT, r);                /* else set context */
256 >        set_eparams((char *)mp->params);
257 >        if ((bval = evalue(mp->binv)) <= -.5)   /* and get bin number */
258 >                return;                         /* silently ignore negatives */
259 >        if ((bn = (int)(bval + .5)) >= mp->nbins) {
260 >                sprintf(errmsg, "bad bin number (%d ignored)", bn);
261 >                error(WARNING, errmsg);
262                  return;
263          }
264 <        raycontrib(contr, r, PRIMARY);
264 >        raycontrib(contr, r, PRIMARY);          /* compute coefficient */
265          if (contrib)
266 <                multcolor(contr, r->rcol);
266 >                multcolor(contr, r->rcol);      /* -> contribution */
267          addcolor(mp->cbin[bn], contr);
268   }
269  
# Line 254 | Line 280 | eval_irrad(FVECT org, FVECT dir)
280          thisray.rdir[2] = -dir[2];
281          thisray.rmax = 0.0;
282          rayorigin(&thisray, PRIMARY, NULL, NULL);
283 <        thisray.rot = 1e-5;             /* pretend we hit surface */
283 >                                        /* pretend we hit surface */
284 >        thisray.rt = thisray.rot = 1e-5;
285          thisray.rod = 1.0;
286 +        VCOPY(thisray.ron, dir);
287          VSUM(thisray.rop, org, dir, 1e-4);
288          samplendx++;                    /* compute result */
289          (*ofun[Lamb.otype].funp)(&Lamb, &thisray);
# Line 279 | Line 307 | eval_rad(FVECT org, FVECT dir, double dmax)
307  
308   /* Accumulate and/or output ray contributions (child or only process) */
309   static void
310 < done_contrib()
310 > done_contrib(void)
311   {
312          MODCONT *mp;
313          int     i;
# Line 300 | Line 328 | done_contrib()
328  
329   /* Principal calculation loop (called by main) */
330   void
331 < rcontrib()
331 > rcontrib(void)
332   {
333          static int      ignore_warning_given = 0;
334          FVECT           orig, direc;
# Line 313 | Line 341 | rcontrib()
341   #endif
342          while (getvec(orig) == 0 && getvec(direc) == 0) {
343                  d = normalize(direc);
344 <                if (nchild != -1 && (d == 0.0) & (accumulate != 1)) {
344 >                if (nchild != -1 && (d == 0.0) & (accumulate == 0)) {
345                          if (!ignore_warning_given++)
346                                  error(WARNING,
347                                  "dummy ray(s) ignored during accumulation\n");
# Line 323 | Line 351 | rcontrib()
351                          lastray = lastdone = 0;
352                  ++lastray;
353                  if (d == 0.0) {                         /* zero ==> flush */
354 <                        if ((yres <= 0) | (xres <= 0))
355 <                                waitflush = 1;          /* flush right after */
356 <                        account = 1;
354 >                        if ((yres <= 0) | (xres <= 1))
355 >                                waitflush = 1;          /* flush after */
356 >                        if (nchild == -1)
357 >                                account = 1;
358                  } else if (imm_irrad) {                 /* else compute */
359                          eval_irrad(orig, direc);
360                  } else {
# Line 336 | Line 365 | rcontrib()
365                  if (raysleft && !--raysleft)
366                          break;          /* preemptive EOI */
367          }
368 <        if ((accumulate <= 0) | (account < accumulate)) {
368 >        if (nchild != -1 && (accumulate <= 0) | (account < accumulate)) {
369                  if (account < accumulate) {
370                          error(WARNING, "partial accumulation in final record");
371                          accumulate -= account;

Diff Legend

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