ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/rcontrib.c
Revision: 2.33
Committed: Wed Jun 13 21:32:15 2018 UTC (5 years, 11 months ago) by greg
Content type: text/plain
Branch: MAIN
CVS Tags: rad5R2
Changes since 2.32: +2 -2 lines
Log Message:
Cosmetic fix

File Contents

# User Rev Content
1 greg 2.1 #ifndef lint
2 greg 2.33 static const char RCSid[] = "$Id: rcontrib.c,v 2.32 2018/06/13 21:23:45 greg Exp $";
3 greg 2.1 #endif
4     /*
5     * Accumulate ray contributions for a set of materials
6     * Initialization and calculation routines
7     */
8    
9 greg 2.20 #include "copyright.h"
10    
11 greg 2.1 #include "rcontrib.h"
12     #include "otypes.h"
13 greg 2.14 #include "source.h"
14 greg 2.1
15 greg 2.2 char *shm_boundary = NULL; /* boundary of shared memory */
16    
17 greg 2.1 CUBE thescene; /* our scene */
18     OBJECT nsceneobjs; /* number of objects in our scene */
19    
20     int dimlist[MAXDIM]; /* sampling dimensions */
21     int ndims = 0; /* number of sampling dimensions */
22     int samplendx = 0; /* index for this sample */
23    
24 greg 2.33 void (*trace)() = NULL; /* trace call (NULL before rcinit) */
25 greg 2.1
26     int do_irrad = 0; /* compute irradiance? */
27    
28 greg 2.3 int rand_samp = 1; /* pure Monte Carlo sampling? */
29 greg 2.1
30 greg 2.8 double dstrsrc = 0.9; /* square source distribution */
31 greg 2.31 double shadthresh = 0.; /* shadow threshold */
32 greg 2.1 double shadcert = .75; /* shadow certainty */
33     int directrelay = 3; /* number of source relays */
34     int vspretest = 512; /* virtual source pretest density */
35     int directvis = 1; /* sources visible? */
36     double srcsizerat = .2; /* maximum ratio source size/dist. */
37    
38     COLOR cextinction = BLKCOLOR; /* global extinction coefficient */
39     COLOR salbedo = BLKCOLOR; /* global scattering albedo */
40     double seccg = 0.; /* global scattering eccentricity */
41     double ssampdist = 0.; /* scatter sampling distance */
42    
43 greg 2.30 double specthresh = .02; /* specular sampling threshold */
44 greg 2.1 double specjitter = 1.; /* specular sampling jitter */
45    
46     int backvis = 1; /* back face visibility */
47    
48 greg 2.3 int maxdepth = -10; /* maximum recursion depth */
49     double minweight = 2e-3; /* minimum ray weight */
50 greg 2.1
51     char *ambfile = NULL; /* ambient file name */
52     COLOR ambval = BLKCOLOR; /* ambient value */
53     int ambvwt = 0; /* initial weight for ambient value */
54 greg 2.31 double ambacc = 0.; /* ambient accuracy */
55 greg 2.1 int ambres = 256; /* ambient resolution */
56     int ambdiv = 350; /* ambient divisions */
57     int ambssamp = 0; /* ambient super-samples */
58     int ambounce = 1; /* ambient bounces */
59     char *amblist[AMBLLEN+1]; /* ambient include/exclude list */
60     int ambincl = -1; /* include == 1, exclude == 0 */
61    
62     int account; /* current accumulation count */
63     RNUMBER raysleft; /* number of rays left to trace */
64     long waitflush; /* how long until next flush */
65    
66 greg 2.4 RNUMBER lastray = 0; /* last ray number sent */
67     RNUMBER lastdone = 0; /* last ray output */
68 greg 2.1
69 greg 2.32 static void trace_contrib(RAY *r); /* our trace callback */
70    
71 greg 2.1 static void mcfree(void *p) { epfree((*(MODCONT *)p).binv); free(p); }
72    
73     LUTAB modconttab = LU_SINIT(NULL,mcfree); /* modifier lookup table */
74    
75     /************************** INITIALIZATION ROUTINES ***********************/
76    
77     char *
78     formstr( /* return format identifier */
79     int f
80     )
81     {
82     switch (f) {
83     case 'a': return("ascii");
84     case 'f': return("float");
85     case 'd': return("double");
86     case 'c': return(COLRFMT);
87     }
88     return("unknown");
89     }
90    
91    
92     /* Add modifier to our list to track */
93     MODCONT *
94 greg 2.20 addmodifier(char *modn, char *outf, char *prms, char *binv, int bincnt)
95 greg 2.1 {
96     LUENT *lep = lu_find(&modconttab,modn);
97     MODCONT *mp;
98     EPNODE *ebinv;
99     int i;
100    
101     if (lep->data != NULL) {
102     sprintf(errmsg, "duplicate modifier '%s'", modn);
103     error(USER, errmsg);
104     }
105 greg 2.27 if (nmods >= MAXMODLIST) {
106     sprintf(errmsg, "too many modifiers (%d limit)", MAXMODLIST);
107     error(INTERNAL, errmsg);
108     }
109 greg 2.26 if (!strcmp(modn, VOIDID)) {
110     sprintf(errmsg, "cannot track '%s' modifier", VOIDID);
111     error(USER, errmsg);
112     }
113 greg 2.1 modname[nmods++] = modn; /* XXX assumes static string */
114     lep->key = modn; /* XXX assumes static string */
115     if (binv == NULL)
116     binv = "0"; /* use single bin if unspecified */
117     ebinv = eparse(binv);
118     if (ebinv->type == NUM) { /* check value if constant */
119     bincnt = (int)(evalue(ebinv) + 1.5);
120     if (bincnt != 1) {
121     sprintf(errmsg, "illegal non-zero constant for bin (%s)",
122     binv);
123     error(USER, errmsg);
124     }
125     } else if (bincnt <= 0) {
126     sprintf(errmsg,
127     "unspecified or illegal bin count for modifier '%s'",
128     modn);
129     error(USER, errmsg);
130     }
131     /* initialize results holder */
132     mp = (MODCONT *)malloc(sizeof(MODCONT)+sizeof(DCOLOR)*(bincnt-1));
133     if (mp == NULL)
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 greg 2.28 mp->params = prms; /* XXX assumes static string */
138 greg 2.1 mp->binv = ebinv;
139 greg 2.29 mp->bin0 = 0;
140 greg 2.1 mp->nbins = bincnt;
141     memset(mp->cbin, 0, sizeof(DCOLOR)*bincnt);
142 greg 2.29 /* 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 greg 2.1 lep->data = (char *)mp;
149     return(mp);
150     }
151    
152    
153 greg 2.10 /* Add modifiers from a file list */
154 greg 2.1 void
155 greg 2.20 addmodfile(char *fname, char *outf, char *prms, char *binv, int bincnt)
156 greg 2.1 {
157     char *mname[MAXMODLIST];
158     int i;
159     /* find the file & store strings */
160 greg 2.27 i = wordfile(mname, MAXMODLIST, getpath(fname, getrlibpath(), R_OK));
161     if (i < 0) {
162 greg 2.1 sprintf(errmsg, "cannot find modifier file '%s'", fname);
163     error(SYSTEM, errmsg);
164     }
165 greg 2.27 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 greg 2.1 for (i = 0; mname[i]; i++) /* add each one */
171 greg 2.20 addmodifier(mname[i], outf, prms, binv, bincnt);
172 greg 2.1 }
173    
174    
175     void
176     quit( /* quit program */
177     int code
178     )
179     {
180     if (nchild > 0) /* close children if any */
181 greg 2.10 end_children(code != 0);
182 greg 2.1 exit(code);
183     }
184    
185    
186     /* Initialize our process(es) */
187     static void
188 greg 2.28 rcinit(void)
189 greg 2.1 {
190     int i;
191    
192     if (nproc > MAXPROCESS)
193     sprintf(errmsg, "too many processes requested -- reducing to %d",
194     nproc = MAXPROCESS);
195 greg 2.2 if (nproc > 1) {
196     preload_objs(); /* preload auxiliary data */
197     /* set shared memory boundary */
198     shm_boundary = strcpy((char *)malloc(16), "SHM_BOUNDARY");
199     }
200 greg 2.32 trace = trace_contrib; /* set up trace call-back */
201 greg 2.14 for (i = 0; i < nsources; i++) /* tracing to sources as well */
202     source[i].sflags |= SFOLLOW;
203 greg 2.1 if (yres > 0) { /* set up flushing & ray counts */
204     if (xres > 0)
205     raysleft = (RNUMBER)xres*yres;
206     else
207     raysleft = yres;
208     } else
209     raysleft = 0;
210     if ((account = accumulate) > 1)
211     raysleft *= accumulate;
212     waitflush = (yres > 0) & (xres > 1) ? 0 : xres;
213    
214 greg 2.5 if (nproc > 1 && in_rchild()) /* forked child? */
215 greg 2.1 return; /* return to main processing loop */
216    
217 greg 2.5 if (recover) { /* recover previous output? */
218 greg 2.8 if (accumulate <= 0)
219 greg 2.5 reload_output();
220 greg 2.8 else
221 greg 2.5 recover_output();
222     }
223     if (nproc == 1) /* single process? */
224     return;
225 greg 2.8 /* else run appropriate controller */
226     if (accumulate <= 0)
227     feeder_loop();
228     else
229     parental_loop();
230 greg 2.1 quit(0); /* parent musn't return! */
231     }
232    
233     /************************** MAIN CALCULATION PROCESS ***********************/
234    
235     /* Our trace call to sum contributions */
236     static void
237     trace_contrib(RAY *r)
238     {
239     MODCONT *mp;
240 greg 2.19 double bval;
241 greg 2.1 int bn;
242     RREAL contr[3];
243    
244 greg 2.6 if (r->ro == NULL || r->ro->omod == OVOID)
245 greg 2.1 return;
246 greg 2.20 /* shadow ray not on source? */
247     if (r->rsrc >= 0 && source[r->rsrc].so != r->ro)
248     return;
249 greg 2.1
250     mp = (MODCONT *)lu_find(&modconttab,objptr(r->ro->omod)->oname)->data;
251    
252 greg 2.6 if (mp == NULL) /* not in our list? */
253     return;
254 greg 2.1
255 greg 2.21 worldfunc(RCCONTEXT, r); /* else set context */
256 greg 2.22 set_eparams((char *)mp->params);
257 greg 2.21 if ((bval = evalue(mp->binv)) <= -.5) /* and get bin number */
258     return; /* silently ignore negatives */
259 greg 2.19 if ((bn = (int)(bval + .5)) >= mp->nbins) {
260 greg 2.23 sprintf(errmsg, "bad bin number (%d ignored)", bn);
261     error(WARNING, errmsg);
262 greg 2.1 return;
263     }
264 greg 2.14 raycontrib(contr, r, PRIMARY); /* compute coefficient */
265 greg 2.1 if (contrib)
266 greg 2.14 multcolor(contr, r->rcol); /* -> contribution */
267 greg 2.1 addcolor(mp->cbin[bn], contr);
268     }
269    
270    
271 greg 2.7 /* Evaluate irradiance contributions */
272 greg 2.1 static void
273 greg 2.7 eval_irrad(FVECT org, FVECT dir)
274 greg 2.1 {
275 greg 2.7 RAY thisray;
276    
277     VSUM(thisray.rorg, org, dir, 1.1e-4);
278     thisray.rdir[0] = -dir[0];
279     thisray.rdir[1] = -dir[1];
280     thisray.rdir[2] = -dir[2];
281     thisray.rmax = 0.0;
282     rayorigin(&thisray, PRIMARY, NULL, NULL);
283 greg 2.16 /* pretend we hit surface */
284     thisray.rt = thisray.rot = 1e-5;
285 greg 2.7 thisray.rod = 1.0;
286 greg 2.15 VCOPY(thisray.ron, dir);
287 greg 2.7 VSUM(thisray.rop, org, dir, 1e-4);
288     samplendx++; /* compute result */
289     (*ofun[Lamb.otype].funp)(&Lamb, &thisray);
290 greg 2.1 }
291    
292    
293 greg 2.7 /* Evaluate radiance contributions */
294 greg 2.1 static void
295 greg 2.7 eval_rad(FVECT org, FVECT dir, double dmax)
296 greg 2.1 {
297     RAY thisray;
298     /* set up ray */
299 greg 2.7 VCOPY(thisray.rorg, org);
300     VCOPY(thisray.rdir, dir);
301     thisray.rmax = dmax;
302 greg 2.1 rayorigin(&thisray, PRIMARY, NULL, NULL);
303     samplendx++; /* call ray evaluation */
304     rayvalue(&thisray);
305     }
306    
307    
308     /* Accumulate and/or output ray contributions (child or only process) */
309     static void
310 greg 2.28 done_contrib(void)
311 greg 2.1 {
312     MODCONT *mp;
313     int i;
314    
315     if (account <= 0 || --account)
316     return; /* not time yet */
317    
318     for (i = 0; i < nmods; i++) { /* output records & clear */
319     mp = (MODCONT *)lu_find(&modconttab,modname[i])->data;
320     mod_output(mp);
321     memset(mp->cbin, 0, sizeof(DCOLOR)*mp->nbins);
322     }
323     end_record(); /* end lines & flush if time */
324    
325     account = accumulate; /* reset accumulation counter */
326     }
327    
328    
329     /* Principal calculation loop (called by main) */
330     void
331 greg 2.28 rcontrib(void)
332 greg 2.1 {
333     static int ignore_warning_given = 0;
334     FVECT orig, direc;
335     double d;
336 greg 2.2 /* initialize (& fork more of us) */
337 greg 2.1 rcinit();
338     /* load rays from stdin & process */
339     #ifdef getc_unlocked
340 greg 2.2 flockfile(stdin); /* avoid mutex overhead */
341 greg 2.1 #endif
342     while (getvec(orig) == 0 && getvec(direc) == 0) {
343     d = normalize(direc);
344 greg 2.17 if (nchild != -1 && (d == 0.0) & (accumulate == 0)) {
345 greg 2.1 if (!ignore_warning_given++)
346     error(WARNING,
347     "dummy ray(s) ignored during accumulation\n");
348     continue;
349     }
350     if (lastray+1 < lastray)
351     lastray = lastdone = 0;
352     ++lastray;
353     if (d == 0.0) { /* zero ==> flush */
354 greg 2.18 if ((yres <= 0) | (xres <= 1))
355 greg 2.17 waitflush = 1; /* flush after */
356     if (nchild == -1)
357     account = 1;
358 greg 2.7 } else if (imm_irrad) { /* else compute */
359     eval_irrad(orig, direc);
360     } else {
361     eval_rad(orig, direc, lim_dist ? d : 0.0);
362 greg 2.1 }
363     done_contrib(); /* accumulate/output */
364     ++lastdone;
365     if (raysleft && !--raysleft)
366     break; /* preemptive EOI */
367     }
368 greg 2.11 if (nchild != -1 && (accumulate <= 0) | (account < accumulate)) {
369 greg 2.1 if (account < accumulate) {
370     error(WARNING, "partial accumulation in final record");
371     accumulate -= account;
372     }
373     account = 1; /* output accumulated totals */
374     done_contrib();
375     }
376 greg 2.9 lu_done(&ofiletab); /* close output files */
377 greg 2.1 if (raysleft)
378     error(USER, "unexpected EOF on input");
379     }