ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/rt/ambient.c

Comparing ray/src/rt/ambient.c (file contents):
Revision 2.62 by greg, Mon Aug 22 16:07:26 2005 UTC vs.
Revision 2.116 by greg, Fri Jan 27 19:57:08 2023 UTC

#	Line 1 | Line 1
1	–	#ifndef lint
1		static const char       RCSid[] = "$Id$";
3	–	#endif
2		/*
3		*  ambient.c - routines dealing with ambient (inter-reflected) component.
4		*
#	Line 14 | Line 12 | static const char      RCSid[] = "$Id$";
12		#include  "platform.h"
13		#include  "ray.h"
14		#include  "otypes.h"
15	+	#include  "otspecial.h"
16		#include  "resolu.h"
17		#include  "ambient.h"
18		#include  "random.h"
19	+	#include  "pmapamb.h"
20
21		#ifndef  OCTSCALE
22		#define  OCTSCALE       1.0     /* ceil((valid rad.)/(cube size)) */
23		#endif
24
25	–	extern char  *shm_boundary;     /* memory sharing boundary */
26	–
25		#ifndef  MAXASET
26	<	#define  MAXASET        2047    /* maximum number of elements in ambient set */
26	>	#define  MAXASET        4095    /* maximum number of elements in ambient set */
27		#endif
28		OBJECT  ambset[MAXASET+1]={0};  /* ambient include/exclude set */
29
#	Line 37 | Line 35 | static AMBTREE atrunk;         /* our ambient trunk node */
35		static FILE  *ambfp = NULL;     /* ambient file pointer */
36		static int  nunflshed = 0;      /* number of unflushed ambient values */
37
40	–	#ifndef SORT_THRESH
41	–	#ifdef SMLMEM
42	–	#define SORT_THRESH     ((3L<<20)/sizeof(AMBVAL))
43	–	#else
44	–	#define SORT_THRESH     ((9L<<20)/sizeof(AMBVAL))
45	–	#endif
46	–	#endif
47	–	#ifndef SORT_INTVL
48	–	#define SORT_INTVL      (SORT_THRESH<<1)
49	–	#endif
50	–	#ifndef MAX_SORT_INTVL
51	–	#define MAX_SORT_INTVL  (SORT_INTVL<<6)
52	–	#endif
53	–
38		static double  avsum = 0.;              /* computed ambient value sum (log) */
39		static unsigned int  navsum = 0;        /* number of values in avsum */
40		static unsigned int  nambvals = 0;      /* total number of indirect values */
41		static unsigned int  nambshare = 0;     /* number of values from file */
58	–	static unsigned long  ambclock = 0;     /* ambient access clock */
59	–	static unsigned long  lastsort = 0;     /* time of last value sort */
60	–	static long  sortintvl = SORT_INTVL;    /* time until next sort */
42		static FILE  *ambinp = NULL;            /* auxiliary file for input */
43		static long  lastpos = -1;              /* last flush position */
44
64	–	#define MAXACLOCK       (1L<<30)        /* clock turnover value */
65	–	/*
66	–	* Track access times unless we are sharing ambient values
67	–	* through memory on a multiprocessor, when we want to avoid
68	–	* claiming our own memory (copy on write).  Go ahead anyway
69	–	* if more than two thirds of our values are unshared.
70	–	* Compile with -Dtracktime=0 to turn this code off.
71	–	*/
72	–	#ifndef tracktime
73	–	#define tracktime       (shm_boundary == NULL || nambvals > 3*nambshare)
74	–	#endif
75	–
45		#define  AMBFLUSH       (BUFSIZ/AMBVALSIZ)
46
47		#define  newambval()    (AMBVAL *)malloc(sizeof(AMBVAL))
79	–	#define  freeav(av)     free((void *)av);
48
49	+	#define  tfunc(lwr, x, upr)     (((x)-(lwr))/((upr)-(lwr)))
50	+
51		static void initambfile(int creat);
52		static void avsave(AMBVAL *av);
53		static AMBVAL *avstore(AMBVAL  *aval);
54		static AMBTREE *newambtree(void);
55		static void freeambtree(AMBTREE  *atp);
56
57	<	typedef void unloadtf_t(void *);
57	>	typedef void unloadtf_t(AMBVAL *);
58		static unloadtf_t avinsert;
59	<	static unloadtf_t av2list;
59	>	static unloadtf_t avfree;
60		static void unloadatree(AMBTREE  *at, unloadtf_t *f);
61
62	<	static int aposcmp(const void *avp1, const void *avp2);
93	<	static int avlmemi(AMBVAL *avaddr);
94	<	static void sortambvals(int always);
62	>	static void sortambvals(void);
63
64	+	static int      plugaleak(RAY *r, AMBVAL *ap, FVECT anorm, double ang);
65	+	static double   sumambient(COLOR acol, RAY *r, FVECT rn, int al,
66	+	AMBTREE *at, FVECT c0, double s);
67	+	static int      makeambient(COLOR acol, RAY *r, FVECT rn, int al);
68	+	static int      extambient(COLOR cr, AMBVAL *ap, FVECT pv, FVECT nv,
69	+	FVECT uvw[3]);
70	+
71		#ifdef  F_SETLKW
72		static void aflock(int  typ);
73		#endif
74
75
76	<	extern void
76	>	void
77		setambres(                              /* set ambient resolution */
78		int  ar
79		)
#	Line 107 | Line 82 | setambres(                             /* set ambient resolution */
82		/* set min & max radii */
83		if (ar <= 0) {
84		minarad = 0;
85	<	maxarad = thescene.cusize / 2.0;
85	>	maxarad = thescene.cusize*0.2;
86		} else {
87		minarad = thescene.cusize / ar;
88	<	maxarad = 64 * minarad;                 /* heuristic */
89	<	if (maxarad > thescene.cusize / 2.0)
90	<	maxarad = thescene.cusize / 2.0;
88	>	maxarad = 64.0 * minarad;               /* heuristic */
89	>	if (maxarad > thescene.cusize*0.2)
90	>	maxarad = thescene.cusize*0.2;
91		}
92		if (minarad <= FTINY)
93	<	minarad = 10*FTINY;
93	>	minarad = 10.0*FTINY;
94		if (maxarad <= minarad)
95	<	maxarad = 64 * minarad;
95	>	maxarad = 64.0 * minarad;
96		}
97
98
99	<	extern void
99	>	void
100		setambacc(                              /* set ambient accuracy */
101		double  newa
102		)
103		{
104	<	double  ambdiff;
105	<
106	<	if (newa < 0.0)
107	<	newa = 0.0;
108	<	ambdiff = fabs(newa - ambacc);
109	<	if (ambdiff >= .01 && (ambacc = newa) > FTINY && nambvals > 0)
110	<	sortambvals(1);                 /* rebuild tree */
104	>	static double   olda;           /* remember previous setting here */
105	>
106	>	newa *= (newa > 0);
107	>	if (fabs(newa - olda) >= .05*(newa + olda)) {
108	>	ambacc = newa;
109	>	if (ambacc > FTINY && nambvals > 0)
110	>	sortambvals();          /* rebuild tree */
111	>	}
112		}
113
114
115	<	extern void
115	>	void
116		setambient(void)                                /* initialize calculation */
117		{
118		int     readonly = 0;
119	<	long  pos, flen;
119	>	long    flen;
120		AMBVAL  amb;
121		/* make sure we're fresh */
122		ambdone();
#	Line 160 | Line 136 | setambient(void)                               /* initialize calculation */
136		readonly = (ambfp = fopen(ambfile, "r")) != NULL;
137		if (ambfp != NULL) {
138		initambfile(0);                 /* file exists */
139	<	pos = ftell(ambfp);
139	>	lastpos = ftell(ambfp);
140		while (readambval(&amb, ambfp))
141	<	avinsert(avstore(&amb));
141	>	avstore(&amb);
142		nambshare = nambvals;           /* share loaded values */
143		if (readonly) {
144		sprintf(errmsg,
#	Line 174 | Line 150 | setambient(void)                               /* initialize calculation */
150		return;                 /* avoid ambsync() */
151		}
152		/* align file pointer */
153	<	pos += (long)nambvals*AMBVALSIZ;
153	>	lastpos += (long)nambvals*AMBVALSIZ;
154		flen = lseek(fileno(ambfp), (off_t)0, SEEK_END);
155	<	if (flen != pos) {
155	>	if (flen != lastpos) {
156		sprintf(errmsg,
157		"ignoring last %ld values in ambient file (corrupted)",
158	<	(flen - pos)/AMBVALSIZ);
158	>	(flen - lastpos)/AMBVALSIZ);
159		error(WARNING, errmsg);
160	<	fseek(ambfp, pos, 0);
161	<	#ifndef _WIN32 /* XXX we need a replacement for that one */
186	<	ftruncate(fileno(ambfp), (off_t)pos);
187	<	#endif
160	>	fseek(ambfp, lastpos, SEEK_SET);
161	>	ftruncate(fileno(ambfp), (off_t)lastpos);
162		}
163		} else if ((ambfp = fopen(ambfile, "w+")) != NULL) {
164		initambfile(1);                 /* else create new file */
165	+	fflush(ambfp);
166	+	lastpos = ftell(ambfp);
167		} else {
168		sprintf(errmsg, "cannot open ambient file \"%s\"", ambfile);
169		error(SYSTEM, errmsg);
170		}
171	<	nunflshed++;    /* lie */
172	<	ambsync();
171	>	#ifdef  F_SETLKW
172	>	aflock(F_UNLCK);                        /* release file */
173	>	#endif
174		}
175
176
177	<	extern void
177	>	void
178		ambdone(void)                   /* close ambient file and free memory */
179		{
180		if (ambfp != NULL) {            /* close ambient file */
#	Line 211 | Line 188 | ambdone(void)                  /* close ambient file and free memory
188		lastpos = -1;
189		}
190		/* free ambient tree */
191	<	unloadatree(&atrunk, free);
191	>	unloadatree(&atrunk, avfree);
192		/* reset state variables */
193		avsum = 0.;
194		navsum = 0;
195		nambvals = 0;
196		nambshare = 0;
220	–	ambclock = 0;
221	–	lastsort = 0;
222	–	sortintvl = SORT_INTVL;
197		}
198
199
200	<	extern void
200	>	void
201		ambnotify(                      /* record new modifier */
202		OBJECT  obj
203		)
204		{
205		static int  hitlimit = 0;
206	<	register OBJREC  *o;
207	<	register char  **amblp;
206	>	OBJREC   *o;
207	>	char  **amblp;
208
209		if (obj == OVOID) {             /* starting over */
210		ambset[0] = 0;
#	Line 253 | Line 227 | ambnotify(                     /* record new modifier */
227		}
228
229
230	<	extern void
230	>	void
231		multambient(            /* compute ambient component & multiply by coef. */
232		COLOR  aval,
233	<	register RAY  *r,
233	>	RAY  *r,
234		FVECT  nrm
235		)
236		{
237	+	static double  logAvgAbsorp = 1;
238		static int  rdepth = 0;                 /* ambient recursion */
239	<	COLOR   acol;
239	>	COLOR   acol, caustic;
240	>	int     i, ok;
241		double  d, l;
242
243	+	/* PMAP: Factor in ambient from photon map, if enabled and ray is
244	+	* ambient. Return as all ambient components accounted for, else
245	+	* continue. */
246	+	if (ambPmap(aval, r, rdepth))
247	+	return;
248	+
249	+	if (logAvgAbsorp > 0)                   /* exclude in -aw to avoid growth */
250	+	logAvgAbsorp = log(1.-AVGREFL);
251	+
252	+	/* PMAP: Factor in specular-diffuse ambient (caustics) from photon
253	+	* map, if enabled and ray is primary, else caustic is zero.  Continue
254	+	* with RADIANCE ambient calculation */
255	+	copycolor(caustic, aval);
256	+	ambPmapCaustic(caustic, r, rdepth);
257	+
258		if (ambdiv <= 0)                        /* no ambient calculation */
259		goto dumbamb;
260		/* check number of bounces */
#	Line 275 | Line 266 | multambient(           /* compute ambient component & multiply
266		goto dumbamb;
267
268		if (ambacc <= FTINY) {                  /* no ambient storage */
269	+	FVECT   uvd[2];
270	+	float   dgrad[2], *dgp = NULL;
271	+
272	+	if (nrm != r->ron && DOT(nrm,r->ron) < 0.9999)
273	+	dgp = dgrad;            /* compute rotational grad. */
274		copycolor(acol, aval);
275		rdepth++;
276	<	d = doambient(acol, r, r->rweight, NULL, NULL);
276	>	ok = doambient(acol, r, r->rweight,
277	>	uvd, NULL, NULL, dgp, NULL);
278		rdepth--;
279	<	if (d <= FTINY)
279	>	if (!ok)
280		goto dumbamb;
281	+	if ((ok > 0) & (dgp != NULL)) { /* apply texture */
282	+	FVECT   v1;
283	+	VCROSS(v1, r->ron, nrm);
284	+	d = 1.0;
285	+	for (i = 3; i--; )
286	+	d += v1[i] * (dgp[0]*uvd[0][i] + dgp[1]*uvd[1][i]);
287	+	if (d >= 0.05)
288	+	scalecolor(acol, d);
289	+	}
290		copycolor(aval, acol);
291	+
292	+	/* PMAP: add in caustic */
293	+	addcolor(aval, caustic);
294		return;
295		}
287	–
288	–	if (tracktime)                          /* sort to minimize thrashing */
289	–	sortambvals(0);
296		/* interpolate ambient value */
297		setcolor(acol, 0.0, 0.0, 0.0);
298		d = sumambient(acol, r, nrm, rdepth,
299		&atrunk, thescene.cuorg, thescene.cusize);
300	+
301		if (d > FTINY) {
302		d = 1.0/d;
303		scalecolor(acol, d);
304		multcolor(aval, acol);
305	+
306	+	/* PMAP: add in caustic */
307	+	addcolor(aval, caustic);
308		return;
309		}
310	+
311		rdepth++;                               /* need to cache new value */
312	<	d = makeambient(acol, r, nrm, rdepth-1);
312	>	ok = makeambient(acol, r, nrm, rdepth-1);
313		rdepth--;
314	<	if (d > FTINY) {
315	<	multcolor(aval, acol);          /* got new value */
314	>
315	>	if (ok) {
316	>	multcolor(aval, acol);          /* computed new value */
317	>
318	>	/* PMAP: add in caustic */
319	>	addcolor(aval, caustic);
320		return;
321		}
322	+
323		dumbamb:                                        /* return global value */
324		if ((ambvwt <= 0) | (navsum == 0)) {
325		multcolor(aval, ambval);
326	+
327	+	/* PMAP: add in caustic */
328	+	addcolor(aval, caustic);
329		return;
330		}
331	<	l = bright(ambval);                     /* average in computations */
331	>
332	>	l = bright(ambval);                     /* average in computations */
333		if (l > FTINY) {
334	<	d = (log(l)*(double)ambvwt + avsum) /
334	>	d = (log(l)*(double)ambvwt + avsum + logAvgAbsorp*navsum) /
335		(double)(ambvwt + navsum);
336		d = exp(d) / l;
337		scalecolor(aval, d);
338		multcolor(aval, ambval);        /* apply color of ambval */
339		} else {
340	<	d = exp( avsum / (double)navsum );
340	>	d = exp( avsum/(double)navsum + logAvgAbsorp );
341		scalecolor(aval, d);            /* neutral color */
342		}
343		}
344
345
346	<	extern double
347	<	sumambient(     /* get interpolated ambient value */
346	>	/* Plug a potential leak where ambient cache value is occluded */
347	>	static int
348	>	plugaleak(RAY *r, AMBVAL *ap, FVECT anorm, double ang)
349	>	{
350	>	const double    cost70sq = 0.1169778;   /* cos(70deg)^2 */
351	>	RAY             rtst;
352	>	FVECT           vdif;
353	>	double          normdot, ndotd, nadotd;
354	>	double          a, b, c, t[2];
355	>
356	>	ang += 2.*PI*(ang < 0);                 /* check direction flags */
357	>	if ( !(ap->corral>>(int)(ang*(16./PI)) & 1) )
358	>	return(0);
359	>	/*
360	>	* Generate test ray, targeting 20 degrees above sample point plane
361	>	* along surface normal from cache position.  This should be high
362	>	* enough to miss local geometry we don't really care about.
363	>	*/
364	>	VSUB(vdif, ap->pos, r->rop);
365	>	normdot = DOT(anorm, r->ron);
366	>	ndotd = DOT(vdif, r->ron);
367	>	nadotd = DOT(vdif, anorm);
368	>	a = normdot*normdot - cost70sq;
369	>	b = 2.0*(normdot*ndotd - nadotd*cost70sq);
370	>	c = ndotd*ndotd - DOT(vdif,vdif)*cost70sq;
371	>	if (quadratic(t, a, b, c) != 2)
372	>	return(1);                      /* should rarely happen */
373	>	if (t[1] <= FTINY)
374	>	return(0);                      /* should fail behind test */
375	>	rayorigin(&rtst, SHADOW, r, NULL);
376	>	VSUM(rtst.rdir, vdif, anorm, t[1]);     /* further dist. > plane */
377	>	rtst.rmax = normalize(rtst.rdir);       /* short ray test */
378	>	while (localhit(&rtst, &thescene)) {    /* check for occluder */
379	>	OBJREC  *m = findmaterial(rtst.ro);
380	>	if (m != NULL && !istransp(m->otype) && !isBSDFproxy(m) &&
381	>	(rtst.clipset == NULL ||
382	>	!inset(rtst.clipset, rtst.ro->omod)))
383	>	return(1);              /* plug light leak */
384	>	VCOPY(rtst.rorg, rtst.rop);     /* skip invisible surface */
385	>	rtst.rmax -= rtst.rot;
386	>	rayclear(&rtst);
387	>	}
388	>	return(0);                              /* seems we're OK */
389	>	}
390	>
391	>
392	>	static double
393	>	sumambient(             /* get interpolated ambient value */
394		COLOR  acol,
395	<	register RAY  *r,
395	>	RAY  *r,
396		FVECT  rn,
397		int  al,
398		AMBTREE  *at,
399		FVECT  c0,
400		double  s
401		)
402	<	{
403	<	double  d, e1, e2, wt, wsum;
404	<	COLOR  ct;
405	<	FVECT  ck0;
406	<	int  i;
407	<	register int  j;
408	<	register AMBVAL  *av;
402	>	{                       /* initial limit is 10 degrees plus ambacc radians */
403	>	const double    minangle = 10.0 * PI/180.;
404	>	double          maxangle = minangle + ambacc;
405	>	double          wsum = 0.0;
406	>	FVECT           ck0;
407	>	int             i, j;
408	>	AMBVAL          *av;
409
410	<	wsum = 0.0;
411	<	/* do this node */
410	>	if (at->kid != NULL) {          /* sum children first */
411	>	s *= 0.5;
412	>	for (i = 0; i < 8; i++) {
413	>	for (j = 0; j < 3; j++) {
414	>	ck0[j] = c0[j];
415	>	if (1<<j & i)
416	>	ck0[j] += s;
417	>	if (r->rop[j] < ck0[j] - OCTSCALE*s)
418	>	break;
419	>	if (r->rop[j] > ck0[j] + (1.0+OCTSCALE)*s)
420	>	break;
421	>	}
422	>	if (j == 3)
423	>	wsum += sumambient(acol, r, rn, al,
424	>	at->kid+i, ck0, s);
425	>	}
426	>	/* good enough? */
427	>	if (wsum >= 0.05 && s > minarad*10.0)
428	>	return(wsum);
429	>	}
430	>	/* adjust maximum angle */
431	>	if (at->alist != NULL && (at->alist->lvl <= al) & (r->rweight < 0.6))
432	>	maxangle = (maxangle - PI/2.)*pow(r->rweight,0.13) + PI/2.;
433	>	/* sum this node */
434		for (av = at->alist; av != NULL; av = av->next) {
435	<	double  rn_dot = -2.0;
436	<	if (tracktime)
437	<	av->latick = ambclock;
435	>	double  u, v, d, delta_r2, delta_t2;
436	>	COLOR   ct;
437	>	FVECT   uvw[3];
438		/*
439	<	*  Ambient level test.
439	>	*  Ambient level test
440		*/
441	<	if (av->lvl > al)       /* list sorted, so this works */
441	>	if (av->lvl > al ||     /* list sorted, so this works */
442	>	(av->lvl == al) & (av->weight < 0.9*r->rweight))
443		break;
355	–	if (av->weight < 0.9*r->rweight)
356	–	continue;
444		/*
445	<	*  Ambient radius test.
445	>	*  Direction test using unperturbed normal
446		*/
447	<	d = av->pos[0] - r->rop[0];
448	<	e1 = d * d;
449	<	d = av->pos[1] - r->rop[1];
363	<	e1 += d * d;
364	<	d = av->pos[2] - r->rop[2];
365	<	e1 += d * d;
366	<	e1 /= av->rad * av->rad;
367	<	if (e1 > ambacc*ambacc*1.21)
447	>	decodedir(uvw[2], av->ndir);
448	>	d = DOT(uvw[2], r->ron);
449	>	if (d <= 0.0)           /* >= 90 degrees */
450		continue;
451	+	delta_r2 = 2.0 - 2.0*d; /* approx. radians^2 */
452	+	if (delta_r2 >= maxangle*maxangle)
453	+	continue;
454		/*
455	<	*  Direction test using closest normal.
455	>	*  Modified ray behind test
456		*/
457	<	d = DOT(av->dir, r->ron);
458	<	if (rn != r->ron) {
459	<	rn_dot = DOT(av->dir, rn);
375	<	if (rn_dot > 1.0-FTINY)
376	<	rn_dot = 1.0-FTINY;
377	<	if (rn_dot >= d-FTINY) {
378	<	d = rn_dot;
379	<	rn_dot = -2.0;
380	<	}
381	<	}
382	<	e2 = (1.0 - d) * r->rweight;
383	<	if (e2 < 0.0) e2 = 0.0;
384	<	if (e1 + e2 > ambacc*ambacc*1.21)
457	>	VSUB(ck0, r->rop, av->pos);
458	>	d = DOT(ck0, uvw[2]);
459	>	if (d < -minarad*ambacc)
460		continue;
461	+	d /= av->rad[0];
462	+	delta_t2 = d*d;
463	+	if (delta_t2 >= ambacc*ambacc)
464	+	continue;
465		/*
466	<	*  Ray behind test.
466	>	*  Elliptical radii test based on Hessian
467		*/
468	<	d = 0.0;
469	<	for (j = 0; j < 3; j++)
470	<	d += (r->rop[j] - av->pos[j]) *
471	<	(av->dir[j] + r->ron[j]);
472	<	if (d*0.5 < -minarad*ambacc-.001)
468	>	decodedir(uvw[0], av->udir);
469	>	VCROSS(uvw[1], uvw[2], uvw[0]);
470	>	d = (u = DOT(ck0, uvw[0])) / av->rad[0];
471	>	delta_t2 += d*d;
472	>	d = (v = DOT(ck0, uvw[1])) / av->rad[1];
473	>	delta_t2 += d*d;
474	>	if (delta_t2 >= ambacc*ambacc)
475		continue;
476		/*
477	<	*  Jittering final test reduces image artifacts.
477	>	*  Test for potential light leak
478		*/
479	<	e1 = sqrt(e1);
399	<	e2 = sqrt(e2);
400	<	wt = e1 + e2;
401	<	if (wt > ambacc*(.9+.2*urand(9015+samplendx)))
479	>	if (av->corral && plugaleak(r, av, uvw[2], atan2a(v,u)))
480		continue;
481		/*
482	<	*  Recompute directional error using perturbed normal
482	>	*  Extrapolate value and compute final weight (hat function)
483		*/
484	<	if (rn_dot > 0.0) {
485	<	e2 = sqrt((1.0 - rn_dot)*r->rweight);
486	<	wt = e1 + e2;
487	<	}
488	<	if (wt <= 1e-3)
411	<	wt = 1e3;
412	<	else
413	<	wt = 1.0 / wt;
414	<	wsum += wt;
415	<	extambient(ct, av, r->rop, rn);
416	<	scalecolor(ct, wt);
484	>	if (!extambient(ct, av, r->rop, rn, uvw))
485	>	continue;
486	>	d = tfunc(maxangle, sqrt(delta_r2), 0.0) *
487	>	tfunc(ambacc, sqrt(delta_t2), 0.0);
488	>	scalecolor(ct, d);
489		addcolor(acol, ct);
490	+	wsum += d;
491		}
419	–	if (at->kid == NULL)
420	–	return(wsum);
421	–	/* do children */
422	–	s *= 0.5;
423	–	for (i = 0; i < 8; i++) {
424	–	for (j = 0; j < 3; j++) {
425	–	ck0[j] = c0[j];
426	–	if (1<<j & i)
427	–	ck0[j] += s;
428	–	if (r->rop[j] < ck0[j] - OCTSCALE*s)
429	–	break;
430	–	if (r->rop[j] > ck0[j] + (1.0+OCTSCALE)*s)
431	–	break;
432	–	}
433	–	if (j == 3)
434	–	wsum += sumambient(acol, r, rn, al,
435	–	at->kid+i, ck0, s);
436	–	}
492		return(wsum);
493		}
494
495
496	<	extern double
496	>	static int
497		makeambient(            /* make a new ambient value for storage */
498		COLOR  acol,
499		RAY  *r,
#	Line 447 | Line 502 | makeambient(           /* make a new ambient value for storage
502		)
503		{
504		AMBVAL  amb;
505	<	FVECT   gp, gd;
505	>	FVECT   uvw[3];
506		int     i;
507
508		amb.weight = 1.0;                       /* compute weight */
#	Line 457 | Line 512 | makeambient(           /* make a new ambient value for storage
512		amb.weight = 1.25*r->rweight;
513		setcolor(acol, AVGREFL, AVGREFL, AVGREFL);
514		/* compute ambient */
515	<	amb.rad = doambient(acol, r, amb.weight, gp, gd);
516	<	if (amb.rad <= FTINY) {
462	<	setcolor(acol, 0.0, 0.0, 0.0);
463	<	return(0.0);
464	<	}
515	>	i = doambient(acol, r, amb.weight,
516	>	uvw, amb.rad, amb.gpos, amb.gdir, &amb.corral);
517		scalecolor(acol, 1./AVGREFL);           /* undo assumed reflectance */
518	+	if (i <= 0 || amb.rad[0] <= FTINY)      /* no Hessian or zero radius */
519	+	return(i);
520		/* store value */
521		VCOPY(amb.pos, r->rop);
522	<	VCOPY(amb.dir, r->ron);
522	>	amb.ndir = encodedir(r->ron);
523	>	amb.udir = encodedir(uvw[0]);
524		amb.lvl = al;
525		copycolor(amb.val, acol);
471	–	VCOPY(amb.gpos, gp);
472	–	VCOPY(amb.gdir, gd);
526		/* insert into tree */
527		avsave(&amb);                           /* and save to file */
528	<	if (rn != r->ron)
529	<	extambient(acol, &amb, r->rop, rn);     /* texture */
530	<	return(amb.rad);
528	>	if (rn != r->ron) {                     /* texture */
529	>	VCOPY(uvw[2], r->ron);
530	>	extambient(acol, &amb, r->rop, rn, uvw);
531	>	}
532	>	return(1);
533		}
534
535
536	<	extern void
536	>	static int
537		extambient(             /* extrapolate value at pv, nv */
538		COLOR  cr,
539	<	register AMBVAL  *ap,
539	>	AMBVAL   *ap,
540		FVECT  pv,
541	<	FVECT  nv
541	>	FVECT  nv,
542	>	FVECT  uvw[3]
543		)
544		{
545	<	FVECT  v1;
546	<	register int  i;
547	<	double  d;
545	>	const double    min_d = 0.05;
546	>	const double    max_d = 20.;
547	>	static FVECT    my_uvw[3];
548	>	FVECT           v1;
549	>	int             i;
550	>	double          d = 1.0;        /* zeroeth order */
551
552	<	d = 1.0;                        /* zeroeth order */
553	<	/* gradient due to translation */
554	<	for (i = 0; i < 3; i++)
555	<	d += ap->gpos[i]*(pv[i]-ap->pos[i]);
556	<	/* gradient due to rotation */
498	<	VCROSS(v1, ap->dir, nv);
499	<	d += DOT(ap->gdir, v1);
500	<	if (d <= 0.0) {
501	<	setcolor(cr, 0.0, 0.0, 0.0);
502	<	return;
552	>	if (uvw == NULL) {              /* need local coordinates? */
553	>	decodedir(my_uvw[2], ap->ndir);
554	>	decodedir(my_uvw[0], ap->udir);
555	>	VCROSS(my_uvw[1], my_uvw[2], my_uvw[0]);
556	>	uvw = my_uvw;
557		}
558	+	for (i = 3; i--; )              /* gradient due to translation */
559	+	d += (pv[i] - ap->pos[i]) *
560	+	(ap->gpos[0]*uvw[0][i] + ap->gpos[1]*uvw[1][i]);
561	+
562	+	VCROSS(v1, uvw[2], nv);         /* gradient due to rotation */
563	+	for (i = 3; i--; )
564	+	d += v1[i] * (ap->gdir[0]*uvw[0][i] + ap->gdir[1]*uvw[1][i]);
565	+
566	+	if (d < min_d)                  /* clamp min/max scaling */
567	+	d = min_d;
568	+	else if (d > max_d)
569	+	d = max_d;
570		copycolor(cr, ap->val);
571		scalecolor(cr, d);
572	+	return(d > min_d);
573		}
574
575
576		static void
577	+	avinsert(                               /* insert ambient value in our tree */
578	+	AMBVAL *av
579	+	)
580	+	{
581	+	AMBTREE  *at;
582	+	AMBVAL  *ap;
583	+	AMBVAL  avh;
584	+	FVECT  ck0;
585	+	double  s;
586	+	int  branch;
587	+	int  i;
588	+
589	+	if (av->rad[0] <= FTINY)
590	+	error(CONSISTENCY, "zero ambient radius in avinsert");
591	+	at = &atrunk;
592	+	VCOPY(ck0, thescene.cuorg);
593	+	s = thescene.cusize;
594	+	while (s*(OCTSCALE/2) > av->rad[1]*ambacc) {
595	+	if (at->kid == NULL)
596	+	if ((at->kid = newambtree()) == NULL)
597	+	error(SYSTEM, "out of memory in avinsert");
598	+	s *= 0.5;
599	+	branch = 0;
600	+	for (i = 0; i < 3; i++)
601	+	if (av->pos[i] > ck0[i] + s) {
602	+	ck0[i] += s;
603	+	branch |= 1 << i;
604	+	}
605	+	at = at->kid + branch;
606	+	}
607	+	avh.next = at->alist;           /* order by increasing level */
608	+	for (ap = &avh; ap->next != NULL; ap = ap->next)
609	+	if ( ap->next->lvl > av->lvl ||
610	+	(ap->next->lvl == av->lvl) &
611	+	(ap->next->weight <= av->weight) )
612	+	break;
613	+	av->next = ap->next;
614	+	ap->next = (AMBVAL*)av;
615	+	at->alist = avh.next;
616	+	}
617	+
618	+
619	+	static void
620		initambfile(            /* initialize ambient file */
621	<	int  creat
621	>	int  cre8
622		)
623		{
624		extern char  *progname, *octname;
625		static char  *mybuf = NULL;
626
627		#ifdef  F_SETLKW
628	<	aflock(creat ? F_WRLCK : F_RDLCK);
628	>	aflock(cre8 ? F_WRLCK : F_RDLCK);
629		#endif
630		SET_FILE_BINARY(ambfp);
631		if (mybuf == NULL)
632		mybuf = (char *)bmalloc(BUFSIZ+8);
633		setbuf(ambfp, mybuf);
634	<	if (creat) {                    /* new file */
634	>	if (cre8) {                     /* new file */
635		newheader("RADIANCE", ambfp);
636		fprintf(ambfp, "%s -av %g %g %g -aw %d -ab %d -aa %g ",
637		progname, colval(ambval,RED),
#	Line 529 | Line 639 | initambfile(           /* initialize ambient file */
639		ambvwt, ambounce, ambacc);
640		fprintf(ambfp, "-ad %d -as %d -ar %d ",
641		ambdiv, ambssamp, ambres);
642	+	fprintf(ambfp, "-dr %d -ds %g -dt %g -dc %g ", directrelay,
643	+	srcsizerat, shadthresh, shadcert);
644	+	fprintf(ambfp, "-ss %g -st %g -lr %d -lw %g ", specjitter,
645	+	specthresh, maxdepth, minweight);
646		if (octname != NULL)
647	<	printargs(1, &octname, ambfp);
648	<	else
535	<	fputc('\n', ambfp);
647	>	fputs(octname, ambfp);
648	>	fputc('\n', ambfp);
649		fprintf(ambfp, "SOFTWARE= %s\n", VersionID);
650		fputnow(ambfp);
651		fputformat(AMBFMT, ambfp);
652	<	putc('\n', ambfp);
652	>	fputc('\n', ambfp);
653		putambmagic(ambfp);
654		} else if (checkheader(ambfp, AMBFMT, NULL) < 0 || !hasambmagic(ambfp))
655		error(USER, "bad ambient file");
#	Line 548 | Line 661 | avsave(                                /* insert and save an ambient value */
661		AMBVAL  *av
662		)
663		{
664	<	avinsert(avstore(av));
664	>	avstore(av);
665		if (ambfp == NULL)
666		return;
667		if (writambval(av, ambfp) < 0)
#	Line 563 | Line 676 | writerr:
676
677
678		static AMBVAL *
679	<	avstore(                                /* allocate memory and store aval */
680	<	register AMBVAL  *aval
679	>	avstore(                                /* allocate memory and save aval */
680	>	AMBVAL  *aval
681		)
682		{
683	<	register AMBVAL  *av;
683	>	AMBVAL  *av;
684		double  d;
685
686		if ((av = newambval()) == NULL)
687		error(SYSTEM, "out of memory in avstore");
688		*av = *aval;
576	–	av->latick = ambclock;
689		av->next = NULL;
690		nambvals++;
691		d = bright(av->val);
#	Line 581 | Line 693 | avstore(                               /* allocate memory and store aval */
693		avsum += log(d);
694		navsum++;
695		}
696	+	avinsert(av);                   /* insert in our cache tree */
697		return(av);
698		}
699
#	Line 593 | Line 706 | static AMBTREE  *atfreelist = NULL;    /* free ambient tr
706		static AMBTREE *
707		newambtree(void)                                /* allocate 8 ambient tree structs */
708		{
709	<	register AMBTREE  *atp, *upperlim;
709	>	AMBTREE  *atp, *upperlim;
710
711		if (atfreelist == NULL) {       /* get more nodes */
712		atfreelist = (AMBTREE *)malloc(ATALLOCSZ*8*sizeof(AMBTREE));
#	Line 607 | Line 720 | newambtree(void)                               /* allocate 8 ambient tree structs
720		}
721		atp = atfreelist;
722		atfreelist = atp->kid;
723	<	memset((char *)atp, '\0', 8*sizeof(AMBTREE));
723	>	memset(atp, 0, 8*sizeof(AMBTREE));
724		return(atp);
725		}
726
#	Line 623 | Line 736 | freeambtree(                   /* free 8 ambient tree structs */
736
737
738		static void
626	–	avinsert(                               /* insert ambient value in our tree */
627	–	void *av
628	–	)
629	–	{
630	–	register AMBTREE  *at;
631	–	register AMBVAL  *ap;
632	–	AMBVAL  avh;
633	–	FVECT  ck0;
634	–	double  s;
635	–	int  branch;
636	–	register int  i;
637	–
638	–	if (((AMBVAL*)av)->rad <= FTINY)
639	–	error(CONSISTENCY, "zero ambient radius in avinsert");
640	–	at = &atrunk;
641	–	VCOPY(ck0, thescene.cuorg);
642	–	s = thescene.cusize;
643	–	while (s*(OCTSCALE/2) > ((AMBVAL*)av)->rad*ambacc) {
644	–	if (at->kid == NULL)
645	–	if ((at->kid = newambtree()) == NULL)
646	–	error(SYSTEM, "out of memory in avinsert");
647	–	s *= 0.5;
648	–	branch = 0;
649	–	for (i = 0; i < 3; i++)
650	–	if (((AMBVAL*)av)->pos[i] > ck0[i] + s) {
651	–	ck0[i] += s;
652	–	branch |= 1 << i;
653	–	}
654	–	at = at->kid + branch;
655	–	}
656	–	avh.next = at->alist;           /* order by increasing level */
657	–	for (ap = &avh; ap->next != NULL; ap = ap->next)
658	–	if (ap->next->lvl >= ((AMBVAL*)av)->lvl)
659	–	break;
660	–	((AMBVAL*)av)->next = ap->next;
661	–	ap->next = (AMBVAL*)av;
662	–	at->alist = avh.next;
663	–	}
664	–
665	–
666	–	static void
739		unloadatree(                    /* unload an ambient value tree */
740	<	register AMBTREE  *at,
740	>	AMBTREE  *at,
741		unloadtf_t *f
742		)
743		{
744	<	register AMBVAL  *av;
745	<	register int  i;
744	>	AMBVAL  *av;
745	>	int  i;
746		/* transfer values at this node */
747		for (av = at->alist; av != NULL; av = at->alist) {
748		at->alist = av->next;
749	+	av->next = NULL;
750		(*f)(av);
751		}
752		if (at->kid == NULL)
#	Line 685 | Line 758 | unloadatree(                   /* unload an ambient value tree */
758		}
759
760
688	–	static struct avl {
689	–	AMBVAL  *p;
690	–	unsigned long   t;
691	–	}       *avlist1;                       /* ambient value list with ticks */
692	–	static AMBVAL   **avlist2;              /* memory positions for sorting */
693	–	static int      i_avlist;               /* index for lists */
694	–
695	–	static int alatcmp(const void *av1, const void *av2);
696	–
761		static void
762	<	av2list(
699	<	void *av
700	<	)
762	>	avfree(AMBVAL *av)
763		{
764	<	#ifdef DEBUG
703	<	if (i_avlist >= nambvals)
704	<	error(CONSISTENCY, "too many ambient values in av2list1");
705	<	#endif
706	<	avlist1[i_avlist].p = avlist2[i_avlist] = (AMBVAL*)av;
707	<	avlist1[i_avlist++].t = ((AMBVAL*)av)->latick;
764	>	free(av);
765		}
766
767
768	<	static int
769	<	alatcmp(                        /* compare ambient values for MRA */
713	<	const void *av1,
714	<	const void *av2
715	<	)
768	>	static void
769	>	sortambvals(void)                       /* resort ambient values */
770		{
771	<	register long  lc = ((struct avl *)av2)->t - ((struct avl *)av1)->t;
718	<	return(lc<0 ? -1 : lc>0 ? 1 : 0);
719	<	}
771	>	AMBTREE  oldatrunk = atrunk;
772
773	<
774	<	/* GW NOTE 2002/10/3:
775	<	* I used to compare AMBVAL pointers, but found that this was the
724	<	* cause of a serious consistency error with gcc, since the optimizer
725	<	* uses some dangerous trick in pointer subtraction that
726	<	* assumes pointers differ by exact struct size increments.
727	<	*/
728	<	static int
729	<	aposcmp(                        /* compare ambient value positions */
730	<	const void      *avp1,
731	<	const void      *avp2
732	<	)
733	<	{
734	<	register long   diff = *(char * const *)avp1 - *(char * const *)avp2;
735	<	if (diff < 0)
736	<	return(-1);
737	<	return(diff > 0);
773	>	atrunk.alist = NULL;
774	>	atrunk.kid = NULL;
775	>	unloadatree(&oldatrunk, avinsert);
776		}
777
740	–	#if 1
741	–	static int
742	–	avlmemi(                                /* find list position from address */
743	–	AMBVAL  *avaddr
744	–	)
745	–	{
746	–	register AMBVAL  **avlpp;
778
748	–	avlpp = (AMBVAL **)bsearch((char *)&avaddr, (char *)avlist2,
749	–	nambvals, sizeof(AMBVAL *), aposcmp);
750	–	if (avlpp == NULL)
751	–	error(CONSISTENCY, "address not found in avlmemi");
752	–	return(avlpp - avlist2);
753	–	}
754	–	#else
755	–	#define avlmemi(avaddr) ((AMBVAL **)bsearch((char *)&avaddr,(char *)avlist2, \
756	–	nambvals,sizeof(AMBVAL *),aposcmp) - avlist2)
757	–	#endif
758	–
759	–
760	–	static void
761	–	sortambvals(                    /* resort ambient values */
762	–	int     always
763	–	)
764	–	{
765	–	AMBTREE  oldatrunk;
766	–	AMBVAL  tav, *tap, *pnext;
767	–	register int    i, j;
768	–	/* see if it's time yet */
769	–	if (!always && (ambclock++ < lastsort+sortintvl ||
770	–	nambvals < SORT_THRESH))
771	–	return;
772	–	/*
773	–	* The idea here is to minimize memory thrashing
774	–	* in VM systems by improving reference locality.
775	–	* We do this by periodically sorting our stored ambient
776	–	* values in memory in order of most recently to least
777	–	* recently accessed.  This ordering was chosen so that new
778	–	* ambient values (which tend to be less important) go into
779	–	* higher memory with the infrequently accessed values.
780	–	*      Since we expect our values to need sorting less
781	–	* frequently as the process continues, we double our
782	–	* waiting interval after each call.
783	–	*      This routine is also called by setambacc() with
784	–	* the "always" parameter set to 1 so that the ambient
785	–	* tree will be rebuilt with the new accuracy parameter.
786	–	*/
787	–	if (tracktime) {                /* allocate pointer arrays to sort */
788	–	avlist2 = (AMBVAL **)malloc(nambvals*sizeof(AMBVAL *));
789	–	avlist1 = (struct avl *)malloc(nambvals*sizeof(struct avl));
790	–	} else {
791	–	avlist2 = NULL;
792	–	avlist1 = NULL;
793	–	}
794	–	if (avlist1 == NULL) {          /* no time tracking -- rebuild tree? */
795	–	if (avlist2 != NULL)
796	–	free((void *)avlist2);
797	–	if (always) {           /* rebuild without sorting */
798	–	oldatrunk = atrunk;
799	–	atrunk.alist = NULL;
800	–	atrunk.kid = NULL;
801	–	unloadatree(&oldatrunk, avinsert);
802	–	}
803	–	} else {                        /* sort memory by last access time */
804	–	/*
805	–	* Sorting memory is tricky because it isn't contiguous.
806	–	* We have to sort an array of pointers by MRA and also
807	–	* by memory position.  We then copy values in "loops"
808	–	* to minimize memory hits.  Nevertheless, we will visit
809	–	* everyone at least twice, and this is an expensive process
810	–	* when we're thrashing, which is when we need to do it.
811	–	*/
812	–	#ifdef DEBUG
813	–	sprintf(errmsg, "sorting %u ambient values at ambclock=%lu...",
814	–	nambvals, ambclock);
815	–	eputs(errmsg);
816	–	#endif
817	–	i_avlist = 0;
818	–	unloadatree(&atrunk, av2list);  /* empty current tree */
819	–	#ifdef DEBUG
820	–	if (i_avlist < nambvals)
821	–	error(CONSISTENCY, "missing ambient values in sortambvals");
822	–	#endif
823	–	qsort((char *)avlist1, nambvals, sizeof(struct avl), alatcmp);
824	–	qsort((char *)avlist2, nambvals, sizeof(AMBVAL *), aposcmp);
825	–	for (i = 0; i < nambvals; i++) {
826	–	if (avlist1[i].p == NULL)
827	–	continue;
828	–	tap = avlist2[i];
829	–	tav = *tap;
830	–	for (j = i; (pnext = avlist1[j].p) != tap;
831	–	j = avlmemi(pnext)) {
832	–	*(avlist2[j]) = *pnext;
833	–	avinsert(avlist2[j]);
834	–	avlist1[j].p = NULL;
835	–	}
836	–	*(avlist2[j]) = tav;
837	–	avinsert(avlist2[j]);
838	–	avlist1[j].p = NULL;
839	–	}
840	–	free((void *)avlist1);
841	–	free((void *)avlist2);
842	–	/* compute new sort interval */
843	–	sortintvl = ambclock - lastsort;
844	–	if (sortintvl >= MAX_SORT_INTVL/2)
845	–	sortintvl = MAX_SORT_INTVL;
846	–	else
847	–	sortintvl <<= 1;        /* wait twice as long next */
848	–	#ifdef DEBUG
849	–	eputs("done\n");
850	–	#endif
851	–	}
852	–	if (ambclock >= MAXACLOCK)
853	–	ambclock = MAXACLOCK/2;
854	–	lastsort = ambclock;
855	–	}
856	–
857	–
779		#ifdef  F_SETLKW
780
781		static void
#	Line 864 | Line 785 | aflock(                        /* lock/unlock ambient file */
785		{
786		static struct flock  fls;       /* static so initialized to zeroes */
787
788	+	if (typ == fls.l_type)          /* already called? */
789	+	return;
790	+
791		fls.l_type = typ;
792	<	if (fcntl(fileno(ambfp), F_SETLKW, &fls) < 0)
793	<	error(SYSTEM, "cannot (un)lock ambient file");
792	>	do
793	>	if (fcntl(fileno(ambfp), F_SETLKW, &fls) != -1)
794	>	return;
795	>	while (errno == EINTR);
796	>
797	>	error(SYSTEM, "cannot (un)lock ambient file");
798		}
799
800
801	<	extern int
801	>	int
802		ambsync(void)                   /* synchronize ambient file */
803		{
804		long  flen;
805		AMBVAL  avs;
806	<	register int  n;
806	>	int  n;
807
808	<	if (nunflshed == 0)
808	>	if (ambfp == NULL)      /* no ambient file? */
809		return(0);
810	<	if (lastpos < 0)        /* initializing (locked in initambfile) */
811	<	goto syncend;
884	<	/* gain exclusive access */
885	<	aflock(F_WRLCK);
810	>	/* gain appropriate access */
811	>	aflock(nunflshed ? F_WRLCK : F_RDLCK);
812		/* see if file has grown */
813		if ((flen = lseek(fileno(ambfp), (off_t)0, SEEK_END)) < 0)
814		goto seekerr;
815	<	if ( (n = flen - lastpos) ) {           /* file has grown */
816	<	if (ambinp == NULL) {           /* use duplicate filedes */
817	<	ambinp = fdopen(dup(fileno(ambfp)), "r");
815	>	if ((n = flen - lastpos) > 0) {         /* file has grown */
816	>	if (ambinp == NULL) {           /* get new file pointer */
817	>	ambinp = fopen(ambfile, "rb");
818		if (ambinp == NULL)
819	<	error(SYSTEM, "fdopen failed in ambsync");
819	>	error(SYSTEM, "fopen failed in ambsync");
820		}
821	<	if (fseek(ambinp, lastpos, 0) < 0)
821	>	if (fseek(ambinp, lastpos, SEEK_SET) < 0)
822		goto seekerr;
823		while (n >= AMBVALSIZ) {        /* load contributed values */
824		if (!readambval(&avs, ambinp)) {
#	Line 902 | Line 828 | ambsync(void)                  /* synchronize ambient file */
828		error(WARNING, errmsg);
829		break;
830		}
831	<	avinsert(avstore(&avs));
831	>	avstore(&avs);
832		n -= AMBVALSIZ;
833		}
834	<	/*** seek always as safety measure
835	<	if (n) ***/                     /* alignment */
836	<	if (lseek(fileno(ambfp), (off_t)(flen-n), SEEK_SET) < 0)
911	<	goto seekerr;
834	>	lastpos = flen - n;             /* check alignment */
835	>	if (n && lseek(fileno(ambfp), (off_t)lastpos, SEEK_SET) < 0)
836	>	goto seekerr;
837		}
913	–	#ifdef  DEBUG
914	–	if (ambfp->_ptr - ambfp->_base != nunflshed*AMBVALSIZ) {
915	–	sprintf(errmsg, "ambient file buffer at %d rather than %d",
916	–	ambfp->_ptr - ambfp->_base,
917	–	nunflshed*AMBVALSIZ);
918	–	error(CONSISTENCY, errmsg);
919	–	}
920	–	#endif
921	–	syncend:
838		n = fflush(ambfp);                      /* calls write() at last */
839	<	if ((lastpos = lseek(fileno(ambfp), (off_t)0, SEEK_CUR)) < 0)
924	<	goto seekerr;
839	>	lastpos += (long)nunflshed*AMBVALSIZ;
840		aflock(F_UNLCK);                        /* release file */
841		nunflshed = 0;
842		return(n);
843		seekerr:
844		error(SYSTEM, "seek failed in ambsync");
845	<	return -1; /* pro forma return */
845	>	return(EOF);    /* pro forma return */
846		}
847
848	<	#else
848	>	#else   /* ! F_SETLKW */
849
850	<	extern int
850	>	int
851		ambsync(void)                   /* flush ambient file */
852		{
853	<	if (nunflshed == 0)
853	>	if (ambfp == NULL)
854		return(0);
855		nunflshed = 0;
856		return(fflush(ambfp));
857		}
858
859	<	#endif
859	>	#endif  /* ! F_SETLKW */

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)