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.22 by greg, Sat Jul 19 20:03:03 2014 UTC vs.
Revision 2.38 by greg, Thu Sep 10 00:45:01 2020 UTC

# Line 8 | Line 8 | static const char RCSid[] = "$Id$";
8  
9   #include "copyright.h"
10  
11 – #include <ctype.h>
11   #include "rcontrib.h"
12   #include "otypes.h"
13   #include "source.h"
# Line 22 | 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 */
26 < void    (*trace)() = trace_contrib;
24 > void    (*trace)() = NULL;              /* trace call (NULL before rcinit) */
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 42 | 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 53 | 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 68 | 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 102 | Line 102 | addmodifier(char *modn, char *outf, char *prms, char *
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 128 | Line 134 | addmodifier(char *modn, char *outf, char *prms, char *
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;
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   }
# Line 147 | Line 157 | addmodfile(char *fname, char *outf, char *prms, char *
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, prms, binv, bincnt);
172   }
173  
174  
175 + /* Check if we have any more rays left (and report progress) */
176 + int
177 + morays(void)
178 + {
179 +        static RNUMBER  total_rays;
180 +        static time_t   tstart, last_report;
181 +        time_t          tnow;
182 +
183 +        if (!raysleft)
184 +                return(1);      /* unknown total, so nothing to do or say */
185 +
186 +        if (report_intvl > 0 && (tnow = time(0)) >= last_report+report_intvl) {
187 +                if (!total_rays) {
188 +                        total_rays = raysleft;
189 +                        tstart = tnow;
190 +                }
191 +                sprintf(errmsg, "%.2f%% done after %.3f hours\n",
192 +                                100.-100.*raysleft/total_rays,
193 +                                (1./3600.)*(tnow - tstart));
194 +                eputs(errmsg);
195 +                last_report = tnow;
196 +        }
197 +        return(--raysleft);
198 + }
199 +
200 +
201 + /* Quit program */
202   void
203 < quit(                   /* quit program */
203 > quit(
204          int  code
205   )
206   {
207          if (nchild > 0)         /* close children if any */
208                  end_children(code != 0);
209 +        else if (nchild < 0)
210 +                _exit(code);    /* avoid flush() in child */
211          exit(code);
212   }
213  
214  
215   /* Initialize our process(es) */
216   static void
217 < rcinit()
217 > rcinit(void)
218   {
219          int     i;
220  
# Line 181 | Line 226 | rcinit()
226                                          /* set shared memory boundary */
227                  shm_boundary = strcpy((char *)malloc(16), "SHM_BOUNDARY");
228          }
229 +        trace = trace_contrib;          /* set up trace call-back */
230          for (i = 0; i < nsources; i++)  /* tracing to sources as well */
231                  source[i].sflags |= SFOLLOW;
232          if (yres > 0) {                 /* set up flushing & ray counts */
# Line 215 | Line 261 | rcinit()
261  
262   /************************** MAIN CALCULATION PROCESS ***********************/
263  
218 – /* Set parameters for current bin evaluation */
219 – void
220 – set_eparams(char *prms)
221 – {
222 –        static char     *last_params = NULL;
223 –        char            vname[RMAXWORD];
224 –        double          value;
225 –        char            *cpd;
226 –                                        /* check if already set */
227 –        if ((prms == NULL) | (prms == last_params))
228 –                return;
229 –        if (last_params != NULL && !strcmp(prms, last_params))
230 –                return;
231 –        last_params = prms;             /* assign each variable */
232 –        while (*prms) {
233 –                if (isspace(*prms)) {
234 –                        ++prms; continue;
235 –                }
236 –                if (!isalpha(*prms))
237 –                        goto bad_params;
238 –                cpd = vname;
239 –                while (*prms && (*prms != '=') & !isspace(*prms)) {
240 –                        if (!isid(*prms))
241 –                                goto bad_params;
242 –                        *cpd++ = *prms++;
243 –                }
244 –                if (cpd == vname)
245 –                        goto bad_params;
246 –                *cpd = '\0';
247 –                while (isspace(*prms)) prms++;
248 –                if (*prms++ != '=')
249 –                        goto bad_params;
250 –                value = atof(prms);
251 –                if ((prms = fskip(prms)) == NULL)
252 –                        goto bad_params;
253 –                while (isspace(*prms)) prms++;
254 –                prms += (*prms == ',') | (*prms == ';');
255 –                varset(vname, '=', value);
256 –        }
257 –        return;
258 – bad_params:
259 –        sprintf(errmsg, "bad parameter list '%s'", last_params);
260 –        error(USER, errmsg);
261 – }
262 –
263 –
264   /* Our trace call to sum contributions */
265   static void
266   trace_contrib(RAY *r)
# Line 286 | Line 286 | trace_contrib(RAY *r)
286          if ((bval = evalue(mp->binv)) <= -.5)   /* and get bin number */
287                  return;                         /* silently ignore negatives */
288          if ((bn = (int)(bval + .5)) >= mp->nbins) {
289 <                error(WARNING, "bad bin number (ignored)");
289 >                sprintf(errmsg, "bad bin number (%d ignored)", bn);
290 >                error(WARNING, errmsg);
291                  return;
292          }
293          raycontrib(contr, r, PRIMARY);          /* compute coefficient */
# Line 309 | Line 310 | eval_irrad(FVECT org, FVECT dir)
310          thisray.rmax = 0.0;
311          rayorigin(&thisray, PRIMARY, NULL, NULL);
312                                          /* pretend we hit surface */
313 <        thisray.rt = thisray.rot = 1e-5;
313 >        thisray.rxt = thisray.rot = 1e-5;
314          thisray.rod = 1.0;
315          VCOPY(thisray.ron, dir);
316          VSUM(thisray.rop, org, dir, 1e-4);
# Line 335 | Line 336 | eval_rad(FVECT org, FVECT dir, double dmax)
336  
337   /* Accumulate and/or output ray contributions (child or only process) */
338   static void
339 < done_contrib()
339 > done_contrib(void)
340   {
341          MODCONT *mp;
342          int     i;
# Line 356 | Line 357 | done_contrib()
357  
358   /* Principal calculation loop (called by main) */
359   void
360 < rcontrib()
360 > rcontrib(void)
361   {
362          static int      ignore_warning_given = 0;
363          FVECT           orig, direc;
# Line 390 | Line 391 | rcontrib()
391                  }
392                  done_contrib();         /* accumulate/output */
393                  ++lastdone;
394 <                if (raysleft && !--raysleft)
394 >                if (!morays())
395                          break;          /* preemptive EOI */
396          }
397          if (nchild != -1 && (accumulate <= 0) | (account < accumulate)) {

Diff Legend

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