src/rt/rcontrib.c

#ifndef lint
static const char RCSid[] = "$Id: rcontrib.c,v 2.41 2021/02/21 17:18:41 greg Exp $";
#endif
/*
 * Accumulate ray contributions for a set of materials
 * Initialization and calculation routines
 */

#include "copyright.h"

#include "rcontrib.h"
#include "otypes.h"
#include "source.h"

char    *shm_boundary = NULL;           /* boundary of shared memory */

CUBE    thescene;                       /* our scene */
OBJECT  nsceneobjs;                     /* number of objects in our scene */

int     dimlist[MAXDIM];                /* sampling dimensions */
int     ndims = 0;                      /* number of sampling dimensions */
int     samplendx = 0;                  /* index for this sample */

void    (*trace)() = NULL;              /* trace call (NULL before rcinit) */

int     do_irrad = 0;                   /* compute irradiance? */

int     rand_samp = 1;                  /* pure Monte Carlo sampling? */

double  dstrsrc = 0.9;                  /* square source distribution */
double  shadthresh = 0.;                /* shadow threshold */
double  shadcert = .75;                 /* shadow certainty */
int     directrelay = 3;                /* number of source relays */
int     vspretest = 512;                /* virtual source pretest density */
int     directvis = 1;                  /* sources visible? */
double  srcsizerat = .2;                /* maximum ratio source size/dist. */

COLOR   cextinction = BLKCOLOR;         /* global extinction coefficient */
COLOR   salbedo = BLKCOLOR;             /* global scattering albedo */
double  seccg = 0.;                     /* global scattering eccentricity */
double  ssampdist = 0.;                 /* scatter sampling distance */

double  specthresh = .02;               /* specular sampling threshold */
double  specjitter = 1.;                /* specular sampling jitter */

int     backvis = 1;                    /* back face visibility */

int     maxdepth = -10;                 /* maximum recursion depth */
double  minweight = 2e-3;               /* minimum ray weight */

char    *ambfile = NULL;                /* ambient file name */
COLOR   ambval = BLKCOLOR;              /* ambient value */
int     ambvwt = 0;                     /* initial weight for ambient value */
double  ambacc = 0.;                    /* ambient accuracy */
int     ambres = 256;                   /* ambient resolution */
int     ambdiv = 350;                   /* ambient divisions */
int     ambssamp = 0;                   /* ambient super-samples */
int     ambounce = 1;                   /* ambient bounces */
char    *amblist[AMBLLEN+1];            /* ambient include/exclude list */
int     ambincl = -1;                   /* include == 1, exclude == 0 */

int     account;                        /* current accumulation count */
RNUMBER raysleft;                       /* number of rays left to trace */
long    waitflush;                      /* how long until next flush */

RNUMBER lastray = 0;                    /* last ray number sent */
RNUMBER lastdone = 0;                   /* last ray output */

static void     trace_contrib(RAY *r);  /* our trace callback */

static void mcfree(void *p) { epfree((*(MODCONT *)p).binv); free(p); }

LUTAB   modconttab = LU_SINIT(NULL,mcfree);     /* modifier lookup table */

/************************** INITIALIZATION ROUTINES ***********************/

const char *
formstr(                                /* return format identifier */
        int  f
)
{
        switch (f) {
        case 'a': return("ascii");
        case 'f': return("float");
        case 'd': return("double");
        case 'c': return(COLRFMT);
        }
        return("unknown");
}


/* Add modifier to our list to track */
MODCONT *
addmodifier(char *modn, char *outf, char *prms, char *binv, int bincnt)
{
        LUENT   *lep = lu_find(&modconttab,modn);
        MODCONT *mp;
        EPNODE  *ebinv;
        int     i;
        
        if (lep->data != NULL) {
                sprintf(errmsg, "duplicate modifier '%s'", modn);
                error(USER, errmsg);
        }
        if (!strcmp(modn, VOIDID)) {
                sprintf(errmsg, "cannot track '%s' modifier", VOIDID);
                error(USER, errmsg);
        }
        if (nmods >= modasiz) {         /* need bigger modifier array */
                modasiz += modasiz/2 + 64;
                if (modname == NULL)
                        modname = (char **)malloc(modasiz*sizeof(char *));
                else
                        modname = (char **)realloc(modname, modasiz*sizeof(char *));
                if (modname == NULL)
                        error(SYSTEM, "Out of memory in addmodifier()");
        }
        modname[nmods++] = modn;        /* XXX assumes static string */
        lep->key = modn;                /* XXX assumes static string */
        if (binv == NULL)
                binv = "0";             /* use single bin if unspecified */
        ebinv = eparse(binv);
        if (ebinv->type == NUM) {       /* check value if constant */
                bincnt = (int)(evalue(ebinv) + 1.5);
                if (bincnt != 1) {
                        sprintf(errmsg, "illegal non-zero constant for bin (%s)",
                                        binv);
                        error(USER, errmsg);
                }
        } else if (bincnt <= 0) {
                sprintf(errmsg,
                        "unspecified or illegal bin count for modifier '%s'",
                                modn);
                error(USER, errmsg);
        }
                                        /* initialize results holder */
        mp = (MODCONT *)malloc(sizeof(MODCONT)+sizeof(DCOLOR)*(bincnt-1));
        if (mp == NULL)
                error(SYSTEM, "out of memory in addmodifier");
        mp->outspec = outf;             /* XXX assumes static string */
        mp->modname = modn;             /* XXX assumes static string */
        mp->params = prms;              /* XXX assumes static string */
        mp->binv = ebinv;
        mp->bin0 = 0;
        mp->nbins = bincnt;
        memset(mp->cbin, 0, sizeof(DCOLOR)*bincnt);
                                        /* figure out starting bin */
        while (!getostream(mp->outspec, mp->modname, mp->bin0, 1))
                mp->bin0++;
                                        /* allocate other output streams */
        for (i = 0; ++i < mp->nbins; )
                getostream(mp->outspec, mp->modname, mp->bin0+i, 1);
        lep->data = (char *)mp;
        return(mp);
}


/* Add modifiers from a file list */
void
addmodfile(char *fname, char *outf, char *prms, char *binv, int bincnt)
{
        char    *path = getpath(fname, getrlibpath(), R_OK);
        char    mod[MAXSTR];
        FILE    *fp;

        if (path == NULL || (fp = fopen(path, "r")) == NULL) {
                if (path == NULL)
                        sprintf(errmsg, "cannot find modifier file '%s'", fname);
                else
                        sprintf(errmsg, "cannot load modifier file '%s'", path);
                error(SYSTEM, errmsg);
        }
        while (fgetword(mod, sizeof(mod), fp) != NULL)
                addmodifier(savqstr(mod), outf, prms, binv, bincnt);
        fclose(fp);
}


/* Check if we have any more rays left (and report progress) */
int
morays(void)
{
        static RNUMBER  total_rays;
        static time_t   tstart, last_report;
        time_t          tnow;

        if (!raysleft)
                return(1);      /* unknown total, so nothing to do or say */

        if (report_intvl > 0 && (tnow = time(0)) >= last_report+report_intvl) {
                if (!total_rays) {
                        total_rays = raysleft;
                        tstart = tnow;
                } else {
                        sprintf(errmsg, "%.2f%% done after %.3f hours\n",
                                        100.-100.*raysleft/total_rays,
                                        (1./3600.)*(tnow - tstart));
                        eputs(errmsg);
                }
                last_report = tnow;
        }
        return(--raysleft);
}


/* Quit program */
void
quit(
        int  code
)
{
        if (nchild > 0)         /* close children if any */
                end_children(code != 0);
        else if (nchild < 0)
                _exit(code);    /* avoid flush() in child */
        exit(code);
}


/* Initialize our process(es) */
static void
rcinit(void)
{
        int     i;

        if (nproc > MAXPROCESS)
                sprintf(errmsg, "too many processes requested -- reducing to %d",
                                nproc = MAXPROCESS);
        if (nproc > 1) {
                preload_objs();         /* preload auxiliary data */
                                        /* set shared memory boundary */
                shm_boundary = strcpy((char *)malloc(16), "SHM_BOUNDARY");
        }
        trace = trace_contrib;          /* set up trace call-back */
        for (i = 0; i < nsources; i++)  /* tracing to sources as well */
                source[i].sflags |= SFOLLOW;
        if (yres > 0) {                 /* set up flushing & ray counts */
                if (xres > 0)
                        raysleft = (RNUMBER)xres*yres;
                else
                        raysleft = yres;
        } else
                raysleft = 0;
        if ((account = accumulate) > 1)
                raysleft *= accumulate;
        waitflush = (yres > 0) & (xres > 1) ? 0 : xres;

        if (nproc > 1 && in_rchild())   /* forked child? */
                return;                 /* return to main processing loop */

        if (recover) {                  /* recover previous output? */
                if (accumulate <= 0)
                        reload_output();
                else
                        recover_output();
        }
        if (nproc == 1)                 /* single process? */
                return;
                                        /* else run appropriate controller */
        if (accumulate <= 0)
                feeder_loop();
        else
                parental_loop();
        quit(0);                        /* parent musn't return! */
}

/************************** MAIN CALCULATION PROCESS ***********************/

/* Our trace call to sum contributions */
static void
trace_contrib(RAY *r)
{
        MODCONT *mp;
        double  bval;
        int     bn;
        RREAL   contr[3];

        if (r->ro == NULL || r->ro->omod == OVOID)
                return;
                                                /* shadow ray not on source? */
        if (r->rsrc >= 0 && source[r->rsrc].so != r->ro)
                return;

        mp = (MODCONT *)lu_find(&modconttab,objptr(r->ro->omod)->oname)->data;

        if (mp == NULL)                         /* not in our list? */
                return;

        worldfunc(RCCONTEXT, r);                /* else set context */
        set_eparams((char *)mp->params);
        if ((bval = evalue(mp->binv)) <= -.5)   /* and get bin number */
                return;                         /* silently ignore negatives */
        if ((bn = (int)(bval + .5)) >= mp->nbins) {
                sprintf(errmsg, "bad bin number (%d ignored)", bn);
                error(WARNING, errmsg);
                return;
        }
        raycontrib(contr, r, PRIMARY);          /* compute coefficient */
        if (contrib)
                multcolor(contr, r->rcol);      /* -> contribution */
        addcolor(mp->cbin[bn], contr);
}


/* Evaluate irradiance contributions */
static void
eval_irrad(FVECT org, FVECT dir)
{
        RAY     thisray;

        VSUM(thisray.rorg, org, dir, 1.1e-4);
        thisray.rdir[0] = -dir[0];
        thisray.rdir[1] = -dir[1];
        thisray.rdir[2] = -dir[2];
        thisray.rmax = 0.0;
        rayorigin(&thisray, PRIMARY, NULL, NULL);
                                        /* pretend we hit surface */
        thisray.rxt = thisray.rot = 1e-5;
        thisray.rod = 1.0;
        VCOPY(thisray.ron, dir);
        VSUM(thisray.rop, org, dir, 1e-4);
        samplendx++;                    /* compute result */
        (*ofun[Lamb.otype].funp)(&Lamb, &thisray);
}


/* Evaluate radiance contributions */
static void
eval_rad(FVECT org, FVECT dir, double dmax)
{
        RAY     thisray;
                                        /* set up ray */
        VCOPY(thisray.rorg, org);
        VCOPY(thisray.rdir, dir);
        thisray.rmax = dmax;
        rayorigin(&thisray, PRIMARY, NULL, NULL);
        samplendx++;                    /* call ray evaluation */
        rayvalue(&thisray);
}


/* Accumulate and/or output ray contributions (child or only process) */
static void
done_contrib(void)
{
        MODCONT *mp;
        int     i;

        if (account <= 0 || --account)
                return;                 /* not time yet */

        for (i = 0; i < nmods; i++) {   /* output records & clear */
                mp = (MODCONT *)lu_find(&modconttab,modname[i])->data;
                mod_output(mp);
                memset(mp->cbin, 0, sizeof(DCOLOR)*mp->nbins);
        }
        end_record();                   /* end lines & flush if time */

        account = accumulate;           /* reset accumulation counter */
}


/* Principal calculation loop (called by main) */
void
rcontrib(void)
{
        static int      ignore_warning_given = 0;
        FVECT           orig, direc;
        double          d;
                                        /* initialize (& fork more of us) */
        rcinit();
                                        /* load rays from stdin & process */
#ifdef getc_unlocked
        flockfile(stdin);               /* avoid mutex overhead */
#endif
        while (getvec(orig) == 0 && getvec(direc) == 0) {
                d = normalize(direc);
                if (nchild != -1 && (d == 0.0) & (accumulate == 0)) {
                        if (!ignore_warning_given++)
                                error(WARNING,
                                "dummy ray(s) ignored during accumulation\n");
                        continue;
                }
                if (lastray+1 < lastray)
                        lastray = lastdone = 0;
                ++lastray;
                if (d == 0.0) {                         /* zero ==> flush */
                        if ((yres <= 0) | (xres <= 1))
                                waitflush = 1;          /* flush after */
                        if (nchild == -1)
                                account = 1;
                } else if (imm_irrad) {                 /* else compute */
                        eval_irrad(orig, direc);
                } else {
                        eval_rad(orig, direc, lim_dist ? d : 0.0);
                }
                done_contrib();         /* accumulate/output */
                ++lastdone;
                if (!morays())
                        break;          /* preemptive EOI */
        }
        if (nchild != -1 && (accumulate <= 0) | (account < accumulate)) {
                if (account < accumulate) {
                        error(WARNING, "partial accumulation in final record");
                        accumulate -= account;
                }
                account = 1;            /* output accumulated totals */
                done_contrib();
        }
        lu_done(&ofiletab);             /* close output files */
        if (raysleft)
                error(USER, "unexpected EOF on input");
}
Revision:	2.42
Committed:	Mon Feb 6 22:40:21 2023 UTC (2 years, 8 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad5R4
Changes since 2.41:	+2 -2 lines
Log Message:	refactor: Changed some char* args to const char* to avoid warnings
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.42	static const char RCSid[] = "$Id: rcontrib.c,v 2.41 2021/02/21 17:18:41 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	greg	2.42	const char *
78	greg	2.1	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.26	if (!strcmp(modn, VOIDID)) {
106			sprintf(errmsg, "cannot track '%s' modifier", VOIDID);
107			error(USER, errmsg);
108			}
109	greg	2.40	if (nmods >= modasiz) { /* need bigger modifier array */
110	greg	2.41	modasiz += modasiz/2 + 64;
111	greg	2.40	if (modname == NULL)
112			modname = (char *)malloc(modasizsizeof(char *));
113			else
114			modname = (char *)realloc(modname, modasizsizeof(char *));
115			if (modname == NULL)
116			error(SYSTEM, "Out of memory in addmodifier()");
117			}
118	greg	2.1	modname[nmods++] = modn; /* XXX assumes static string */
119			lep->key = modn; /* XXX assumes static string */
120			if (binv == NULL)
121			binv = "0"; /* use single bin if unspecified */
122			ebinv = eparse(binv);
123			if (ebinv->type == NUM) { /* check value if constant */
124			bincnt = (int)(evalue(ebinv) + 1.5);
125			if (bincnt != 1) {
126			sprintf(errmsg, "illegal non-zero constant for bin (%s)",
127			binv);
128			error(USER, errmsg);
129			}
130			} else if (bincnt <= 0) {
131			sprintf(errmsg,
132			"unspecified or illegal bin count for modifier '%s'",
133			modn);
134			error(USER, errmsg);
135			}
136			/* initialize results holder */
137			mp = (MODCONT )malloc(sizeof(MODCONT)+sizeof(DCOLOR)(bincnt-1));
138			if (mp == NULL)
139			error(SYSTEM, "out of memory in addmodifier");
140			mp->outspec = outf; /* XXX assumes static string */
141			mp->modname = modn; /* XXX assumes static string */
142	greg	2.28	mp->params = prms; /* XXX assumes static string */
143	greg	2.1	mp->binv = ebinv;
144	greg	2.29	mp->bin0 = 0;
145	greg	2.1	mp->nbins = bincnt;
146			memset(mp->cbin, 0, sizeof(DCOLOR)*bincnt);
147	greg	2.29	/* figure out starting bin */
148			while (!getostream(mp->outspec, mp->modname, mp->bin0, 1))
149			mp->bin0++;
150			/* allocate other output streams */
151			for (i = 0; ++i < mp->nbins; )
152			getostream(mp->outspec, mp->modname, mp->bin0+i, 1);
153	greg	2.1	lep->data = (char *)mp;
154			return(mp);
155			}
156
157
158	greg	2.10	/* Add modifiers from a file list */
159	greg	2.1	void
160	greg	2.20	addmodfile(char fname, char outf, char prms, char binv, int bincnt)
161	greg	2.1	{
162	greg	2.40	char *path = getpath(fname, getrlibpath(), R_OK);
163			char mod[MAXSTR];
164			FILE *fp;
165
166			if (path == NULL \|\| (fp = fopen(path, "r")) == NULL) {
167	greg	2.41	if (path == NULL)
168			sprintf(errmsg, "cannot find modifier file '%s'", fname);
169			else
170			sprintf(errmsg, "cannot load modifier file '%s'", path);
171	greg	2.1	error(SYSTEM, errmsg);
172			}
173	greg	2.40	while (fgetword(mod, sizeof(mod), fp) != NULL)
174	greg	2.41	addmodifier(savqstr(mod), outf, prms, binv, bincnt);
175	greg	2.40	fclose(fp);
176	greg	2.1	}
177
178
179	greg	2.37	/* Check if we have any more rays left (and report progress) */
180			int
181			morays(void)
182			{
183			static RNUMBER total_rays;
184			static time_t tstart, last_report;
185			time_t tnow;
186
187			if (!raysleft)
188			return(1); /* unknown total, so nothing to do or say */
189
190			if (report_intvl > 0 && (tnow = time(0)) >= last_report+report_intvl) {
191			if (!total_rays) {
192			total_rays = raysleft;
193			tstart = tnow;
194	greg	2.39	} else {
195			sprintf(errmsg, "%.2f%% done after %.3f hours\n",
196			100.-100.*raysleft/total_rays,
197			(1./3600.)*(tnow - tstart));
198			eputs(errmsg);
199	greg	2.37	}
200			last_report = tnow;
201			}
202			return(--raysleft);
203			}
204
205
206			/* Quit program */
207	greg	2.1	void
208	greg	2.37	quit(
209	greg	2.1	int code
210			)
211			{
212			if (nchild > 0) /* close children if any */
213	greg	2.10	end_children(code != 0);
214	greg	2.36	else if (nchild < 0)
215			_exit(code); /* avoid flush() in child */
216	greg	2.1	exit(code);
217			}
218
219
220			/* Initialize our process(es) */
221			static void
222	greg	2.28	rcinit(void)
223	greg	2.1	{
224			int i;
225
226			if (nproc > MAXPROCESS)
227			sprintf(errmsg, "too many processes requested -- reducing to %d",
228			nproc = MAXPROCESS);
229	greg	2.2	if (nproc > 1) {
230			preload_objs(); /* preload auxiliary data */
231			/* set shared memory boundary */
232			shm_boundary = strcpy((char *)malloc(16), "SHM_BOUNDARY");
233			}
234	greg	2.32	trace = trace_contrib; /* set up trace call-back */
235	greg	2.14	for (i = 0; i < nsources; i++) /* tracing to sources as well */
236			source[i].sflags \|= SFOLLOW;
237	greg	2.1	if (yres > 0) { /* set up flushing & ray counts */
238			if (xres > 0)
239			raysleft = (RNUMBER)xres*yres;
240			else
241			raysleft = yres;
242			} else
243			raysleft = 0;
244			if ((account = accumulate) > 1)
245			raysleft *= accumulate;
246			waitflush = (yres > 0) & (xres > 1) ? 0 : xres;
247
248	greg	2.5	if (nproc > 1 && in_rchild()) /* forked child? */
249	greg	2.1	return; /* return to main processing loop */
250
251	greg	2.5	if (recover) { /* recover previous output? */
252	greg	2.8	if (accumulate <= 0)
253	greg	2.5	reload_output();
254	greg	2.8	else
255	greg	2.5	recover_output();
256			}
257			if (nproc == 1) /* single process? */
258			return;
259	greg	2.8	/* else run appropriate controller */
260			if (accumulate <= 0)
261			feeder_loop();
262			else
263			parental_loop();
264	greg	2.1	quit(0); /* parent musn't return! */
265			}
266
267			/************************ MAIN CALCULATION PROCESS *********************/
268
269			/* Our trace call to sum contributions */
270			static void
271			trace_contrib(RAY *r)
272			{
273			MODCONT *mp;
274	greg	2.19	double bval;
275	greg	2.1	int bn;
276			RREAL contr[3];
277
278	greg	2.6	if (r->ro == NULL \|\| r->ro->omod == OVOID)
279	greg	2.1	return;
280	greg	2.20	/* shadow ray not on source? */
281			if (r->rsrc >= 0 && source[r->rsrc].so != r->ro)
282			return;
283	greg	2.1
284			mp = (MODCONT *)lu_find(&modconttab,objptr(r->ro->omod)->oname)->data;
285
286	greg	2.6	if (mp == NULL) /* not in our list? */
287			return;
288	greg	2.1
289	greg	2.21	worldfunc(RCCONTEXT, r); /* else set context */
290	greg	2.22	set_eparams((char *)mp->params);
291	greg	2.21	if ((bval = evalue(mp->binv)) <= -.5) /* and get bin number */
292			return; /* silently ignore negatives */
293	greg	2.19	if ((bn = (int)(bval + .5)) >= mp->nbins) {
294	greg	2.23	sprintf(errmsg, "bad bin number (%d ignored)", bn);
295			error(WARNING, errmsg);
296	greg	2.1	return;
297			}
298	greg	2.14	raycontrib(contr, r, PRIMARY); /* compute coefficient */
299	greg	2.1	if (contrib)
300	greg	2.14	multcolor(contr, r->rcol); /* -> contribution */
301	greg	2.1	addcolor(mp->cbin[bn], contr);
302			}
303
304
305	greg	2.7	/* Evaluate irradiance contributions */
306	greg	2.1	static void
307	greg	2.7	eval_irrad(FVECT org, FVECT dir)
308	greg	2.1	{
309	greg	2.7	RAY thisray;
310
311			VSUM(thisray.rorg, org, dir, 1.1e-4);
312			thisray.rdir[0] = -dir[0];
313			thisray.rdir[1] = -dir[1];
314			thisray.rdir[2] = -dir[2];
315			thisray.rmax = 0.0;
316			rayorigin(&thisray, PRIMARY, NULL, NULL);
317	greg	2.16	/* pretend we hit surface */
318	greg	2.35	thisray.rxt = thisray.rot = 1e-5;
319	greg	2.7	thisray.rod = 1.0;
320	greg	2.15	VCOPY(thisray.ron, dir);
321	greg	2.7	VSUM(thisray.rop, org, dir, 1e-4);
322			samplendx++; /* compute result */
323			(*ofun[Lamb.otype].funp)(&Lamb, &thisray);
324	greg	2.1	}
325
326
327	greg	2.7	/* Evaluate radiance contributions */
328	greg	2.1	static void
329	greg	2.7	eval_rad(FVECT org, FVECT dir, double dmax)
330	greg	2.1	{
331			RAY thisray;
332			/* set up ray */
333	greg	2.7	VCOPY(thisray.rorg, org);
334			VCOPY(thisray.rdir, dir);
335			thisray.rmax = dmax;
336	greg	2.1	rayorigin(&thisray, PRIMARY, NULL, NULL);
337			samplendx++; /* call ray evaluation */
338			rayvalue(&thisray);
339			}
340
341
342			/* Accumulate and/or output ray contributions (child or only process) */
343			static void
344	greg	2.28	done_contrib(void)
345	greg	2.1	{
346			MODCONT *mp;
347			int i;
348
349			if (account <= 0 \|\| --account)
350			return; /* not time yet */
351
352			for (i = 0; i < nmods; i++) { /* output records & clear */
353			mp = (MODCONT *)lu_find(&modconttab,modname[i])->data;
354			mod_output(mp);
355			memset(mp->cbin, 0, sizeof(DCOLOR)*mp->nbins);
356			}
357			end_record(); /* end lines & flush if time */
358
359			account = accumulate; /* reset accumulation counter */
360			}
361
362
363			/* Principal calculation loop (called by main) */
364			void
365	greg	2.28	rcontrib(void)
366	greg	2.1	{
367			static int ignore_warning_given = 0;
368			FVECT orig, direc;
369			double d;
370	greg	2.2	/* initialize (& fork more of us) */
371	greg	2.1	rcinit();
372			/* load rays from stdin & process */
373			#ifdef getc_unlocked
374	greg	2.2	flockfile(stdin); /* avoid mutex overhead */
375	greg	2.1	#endif
376			while (getvec(orig) == 0 && getvec(direc) == 0) {
377			d = normalize(direc);
378	greg	2.17	if (nchild != -1 && (d == 0.0) & (accumulate == 0)) {
379	greg	2.1	if (!ignore_warning_given++)
380			error(WARNING,
381			"dummy ray(s) ignored during accumulation\n");
382			continue;
383			}
384			if (lastray+1 < lastray)
385			lastray = lastdone = 0;
386			++lastray;
387			if (d == 0.0) { /* zero ==> flush */
388	greg	2.18	if ((yres <= 0) \| (xres <= 1))
389	greg	2.17	waitflush = 1; /* flush after */
390			if (nchild == -1)
391			account = 1;
392	greg	2.7	} else if (imm_irrad) { /* else compute */
393			eval_irrad(orig, direc);
394			} else {
395			eval_rad(orig, direc, lim_dist ? d : 0.0);
396	greg	2.1	}
397			done_contrib(); /* accumulate/output */
398			++lastdone;
399	greg	2.37	if (!morays())
400	greg	2.1	break; /* preemptive EOI */
401			}
402	greg	2.11	if (nchild != -1 && (accumulate <= 0) \| (account < accumulate)) {
403	greg	2.1	if (account < accumulate) {
404			error(WARNING, "partial accumulation in final record");
405			accumulate -= account;
406			}
407			account = 1; /* output accumulated totals */
408			done_contrib();
409			}
410	greg	2.9	lu_done(&ofiletab); /* close output files */
411	greg	2.1	if (raysleft)
412			error(USER, "unexpected EOF on input");
413			}