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.112 by greg, Mon Mar 7 17:52:14 2022 UTC vs.
Revision 2.128 by greg, Thu Dec 19 19:34:31 2024 UTC

#	Line 22 | Line 22 | static const char      RCSid[] = "$Id$";
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        4095    /* maximum number of elements in ambient set */
27		#endif
#	Line 46 | Line 44 | static long  lastpos = -1;             /* last flush position */
44
45		#define  AMBFLUSH       (BUFSIZ/AMBVALSIZ)
46
47	<	#define  newambval()    (AMBVAL *)malloc(sizeof(AMBVAL))
47	>	#define  AVSIZE         (sizeof(AMBVAL)-sizeof(SCOLOR)+sizeof(COLORV)*NCSAMP)
48	>	#define  newambval()    (AMBVAL *)malloc(AVSIZE)
49
50	<	#define  tfunc(lwr, x, upr)     (((x)-(lwr))/((upr)-(lwr)))
50	>	#define  tfunc(x0, x, x1)       (((x)-(x0))/((x1)-(x0)))
51
52	<	static void initambfile(int creat);
52	>	static void initambfile(int cre8);
53		static void avsave(AMBVAL *av);
54		static AMBVAL *avstore(AMBVAL  *aval);
55		static AMBTREE *newambtree(void);
#	Line 64 | Line 63 | static void unloadatree(AMBTREE  *at, unloadtf_t *f);
63		static void sortambvals(void);
64
65		static int      plugaleak(RAY *r, AMBVAL *ap, FVECT anorm, double ang);
66	<	static double   sumambient(COLOR acol, RAY *r, FVECT rn, int al,
66	>	static double   sumambient(SCOLOR acol, RAY *r, FVECT rn, int al,
67		AMBTREE *at, FVECT c0, double s);
68	<	static int      makeambient(COLOR acol, RAY *r, FVECT rn, int al);
69	<	static int      extambient(COLOR cr, AMBVAL *ap, FVECT pv, FVECT nv,
68	>	static int      makeambient(SCOLOR acol, RAY *r, FVECT rn, int al);
69	>	static int      extambient(SCOLOR cr, AMBVAL *ap, FVECT pv, FVECT nv,
70		FVECT uvw[3]);
71
72		#ifdef  F_SETLKW
#	Line 231 | Line 230 | ambnotify(                     /* record new modifier */
230
231		void
232		multambient(            /* compute ambient component & multiply by coef. */
233	<	COLOR  aval,
233	>	SCOLOR  aval,
234		RAY  *r,
235		FVECT  nrm
236		)
237		{
238		static double  logAvgAbsorp = 1;
239		static int  rdepth = 0;                 /* ambient recursion */
240	<	COLOR   acol, caustic;
240	>	SCOLOR  acol, caustic;
241		int     i, ok;
242		double  d, l;
243
#	Line 254 | Line 253 | multambient(           /* compute ambient component & multiply
253		/* PMAP: Factor in specular-diffuse ambient (caustics) from photon
254		* map, if enabled and ray is primary, else caustic is zero.  Continue
255		* with RADIANCE ambient calculation */
256	<	copycolor(caustic, aval);
257	<	ambPmapCaustic(caustic, r, rdepth);
258	<
256	>	{/* XXX TEMPORARY */
257	>	COLOR   pmc;
258	>	scolor_color(pmc, aval);
259	>	ambPmapCaustic(pmc, r, rdepth);
260	>	setscolor(caustic, colval(pmc,RED), colval(pmc,GRN), colval(pmc,BLU));
261	>	}
262		if (ambdiv <= 0)                        /* no ambient calculation */
263		goto dumbamb;
264		/* check number of bounces */
#	Line 267 | Line 269 | multambient(           /* compute ambient component & multiply
269		ambincl != inset(ambset, r->ro->omod))
270		goto dumbamb;
271
272	<	if (ambacc <= FTINY) {                  /* no ambient storage */
273	<	FVECT   uvd[2];
272	>	if (ambacc <= FTINY) {                  /* no ambient storage? */
273	>	double  rdot = DOT(nrm,r->ron);
274	>	int     sgn = 1 - 2*(rdot < 0);
275		float   dgrad[2], *dgp = NULL;
276	+	FVECT   uvd[2];
277
278	<	if (nrm != r->ron && DOT(nrm,r->ron) < 0.9999)
278	>	if (sgn*rdot < 0.9999)
279		dgp = dgrad;            /* compute rotational grad. */
280	<	copycolor(acol, aval);
280	>	copyscolor(acol, aval);
281		rdepth++;
282	<	ok = doambient(acol, r, r->rweight,
282	>	ok = doambient(acol, r, r->rweight*sgn,
283		uvd, NULL, NULL, dgp, NULL);
284		rdepth--;
285		if (!ok)
#	Line 285 | Line 289 | multambient(           /* compute ambient component & multiply
289		VCROSS(v1, r->ron, nrm);
290		d = 1.0;
291		for (i = 3; i--; )
292	<	d += v1[i] * (dgp[0]*uvd[0][i] + dgp[1]*uvd[1][i]);
292	>	d += sgn*v1[i] * (dgp[0]*uvd[0][i] + dgp[1]*uvd[1][i]);
293		if (d >= 0.05)
294	<	scalecolor(acol, d);
294	>	scalescolor(acol, d);
295		}
296	<	copycolor(aval, acol);
296	>	copyscolor(aval, acol);
297
298		/* PMAP: add in caustic */
299	<	addcolor(aval, caustic);
299	>	saddscolor(aval, caustic);
300		return;
301		}
302		/* interpolate ambient value */
303	<	setcolor(acol, 0.0, 0.0, 0.0);
303	>	scolorblack(acol);
304		d = sumambient(acol, r, nrm, rdepth,
305		&atrunk, thescene.cuorg, thescene.cusize);
306
307		if (d > FTINY) {
308	<	d = 1.0/d;
309	<	scalecolor(acol, d);
306	<	multcolor(aval, acol);
308	>	scalescolor(acol, 1.0/d);
309	>	smultscolor(aval, acol);
310
311		/* PMAP: add in caustic */
312	<	addcolor(aval, caustic);
312	>	saddscolor(aval, caustic);
313		return;
314		}
315
#	Line 315 | Line 318 | multambient(           /* compute ambient component & multiply
318		rdepth--;
319
320		if (ok) {
321	<	multcolor(aval, acol);          /* computed new value */
321	>	smultscolor(aval, acol);        /* computed new value */
322
323		/* PMAP: add in caustic */
324	<	addcolor(aval, caustic);
324	>	saddscolor(aval, caustic);
325		return;
326		}
327
328		dumbamb:                                        /* return global value */
329		if ((ambvwt <= 0) | (navsum == 0)) {
330	<	multcolor(aval, ambval);
330	>	smultcolor(aval, ambval);
331
332		/* PMAP: add in caustic */
333	<	addcolor(aval, caustic);
333	>	saddscolor(aval, caustic);
334		return;
335		}
336
#	Line 336 | Line 339 | dumbamb:                                       /* return global value */
339		d = (log(l)*(double)ambvwt + avsum + logAvgAbsorp*navsum) /
340		(double)(ambvwt + navsum);
341		d = exp(d) / l;
342	<	scalecolor(aval, d);
343	<	multcolor(aval, ambval);        /* apply color of ambval */
342	>	scalescolor(aval, d);
343	>	smultcolor(aval, ambval);       /* apply color of ambval */
344		} else {
345		d = exp( avsum/(double)navsum + logAvgAbsorp );
346	<	scalecolor(aval, d);            /* neutral color */
346	>	scalescolor(aval, d);           /* neutral color */
347		}
348		}
349
#	Line 379 | Line 382 | plugaleak(RAY *r, AMBVAL *ap, FVECT anorm, double ang)
382		rtst.rmax = normalize(rtst.rdir);       /* short ray test */
383		while (localhit(&rtst, &thescene)) {    /* check for occluder */
384		OBJREC  *m = findmaterial(rtst.ro);
385	<	if (m != NULL && !istransp(m->otype) && !isBSDFproxy(m) &&
385	>	if (m != NULL && !istransp(m) && !isBSDFproxy(m) &&
386		(rtst.clipset == NULL ||
387		!inset(rtst.clipset, rtst.ro->omod)))
388		return(1);              /* plug light leak */
#	Line 393 | Line 396 | plugaleak(RAY *r, AMBVAL *ap, FVECT anorm, double ang)
396
397		static double
398		sumambient(             /* get interpolated ambient value */
399	<	COLOR  acol,
399	>	SCOLOR  acol,
400		RAY  *r,
401		FVECT  rn,
402		int  al,
#	Line 403 | Line 406 | sumambient(            /* get interpolated ambient value */
406		)
407		{                       /* initial limit is 10 degrees plus ambacc radians */
408		const double    minangle = 10.0 * PI/180.;
409	+	const int       sgn = 1 - 2*(DOT(r->ron,rn) < 0);
410		double          maxangle = minangle + ambacc;
411		double          wsum = 0.0;
412		FVECT           ck0;
#	Line 426 | Line 430 | sumambient(            /* get interpolated ambient value */
430		at->kid+i, ck0, s);
431		}
432		/* good enough? */
433	<	if (wsum >= 0.05 && s > minarad*10.0)
433	>	if ((wsum >= 0.05) & (s*ambacc > minarad))
434		return(wsum);
435		}
436		/* adjust maximum angle */
#	Line 435 | Line 439 | sumambient(            /* get interpolated ambient value */
439		/* sum this node */
440		for (av = at->alist; av != NULL; av = av->next) {
441		double  u, v, d, delta_r2, delta_t2;
442	<	COLOR   ct;
442	>	SCOLOR  sct;
443		FVECT   uvw[3];
444		/*
445		*  Ambient level test
#	Line 447 | Line 451 | sumambient(            /* get interpolated ambient value */
451		*  Direction test using unperturbed normal
452		*/
453		decodedir(uvw[2], av->ndir);
454	<	d = DOT(uvw[2], r->ron);
454	>	d = sgn * DOT(uvw[2], r->ron);
455		if (d <= 0.0)           /* >= 90 degrees */
456		continue;
457		delta_r2 = 2.0 - 2.0*d; /* approx. radians^2 */
#	Line 458 | Line 462 | sumambient(            /* get interpolated ambient value */
462		*/
463		VSUB(ck0, r->rop, av->pos);
464		d = DOT(ck0, uvw[2]);
465	<	if (d < -minarad*ambacc-.001)
465	>	if (d < -minarad*ambacc)
466		continue;
467		d /= av->rad[0];
468		delta_t2 = d*d;
#	Line 483 | Line 487 | sumambient(            /* get interpolated ambient value */
487		/*
488		*  Extrapolate value and compute final weight (hat function)
489		*/
490	<	if (!extambient(ct, av, r->rop, rn, uvw))
490	>	if (!extambient(sct, av, r->rop, rn, uvw))
491		continue;
492		d = tfunc(maxangle, sqrt(delta_r2), 0.0) *
493		tfunc(ambacc, sqrt(delta_t2), 0.0);
494	<	scalecolor(ct, d);
495	<	addcolor(acol, ct);
494	>	scalescolor(sct, d);
495	>	saddscolor(acol, sct);
496		wsum += d;
497		}
498		return(wsum);
#	Line 497 | Line 501 | sumambient(            /* get interpolated ambient value */
501
502		static int
503		makeambient(            /* make a new ambient value for storage */
504	<	COLOR  acol,
504	>	SCOLOR  acol,
505		RAY  *r,
506		FVECT  rn,
507		int  al
508		)
509		{
510	+	int     sgn = 1 - 2*(DOT(r->ron,rn) < 0);
511		AMBVAL  amb;
512		FVECT   uvw[3];
513		int     i;
#	Line 512 | Line 517 | makeambient(           /* make a new ambient value for storage
517		amb.weight *= AVGREFL;
518		if (r->rweight < 0.1*amb.weight)        /* heuristic override */
519		amb.weight = 1.25*r->rweight;
520	<	setcolor(acol, AVGREFL, AVGREFL, AVGREFL);
520	>	setscolor(acol, AVGREFL, AVGREFL, AVGREFL);
521		/* compute ambient */
522	<	i = doambient(acol, r, amb.weight,
522	>	i = doambient(acol, r, amb.weight*sgn,
523		uvw, amb.rad, amb.gpos, amb.gdir, &amb.corral);
524	<	scalecolor(acol, 1./AVGREFL);           /* undo assumed reflectance */
524	>	scalescolor(acol, 1./AVGREFL);          /* undo assumed reflectance */
525		if (i <= 0 || amb.rad[0] <= FTINY)      /* no Hessian or zero radius */
526		return(i);
527	+	uvw[2][0] = sgn*r->ron[0];              /* orient unperturbed normal */
528	+	uvw[2][1] = sgn*r->ron[1];
529	+	uvw[2][2] = sgn*r->ron[2];
530		/* store value */
531		VCOPY(amb.pos, r->rop);
532	<	amb.ndir = encodedir(r->ron);
532	>	amb.ndir = encodedir(uvw[2]);
533		amb.udir = encodedir(uvw[0]);
534		amb.lvl = al;
535	<	copycolor(amb.val, acol);
536	<	/* insert into tree */
537	<	avsave(&amb);                           /* and save to file */
530	<	if (rn != r->ron) {                     /* texture */
531	<	VCOPY(uvw[2], r->ron);
535	>	copyscolor(amb.val, acol);
536	>	avsave(&amb);                           /* insert and save to file */
537	>	if (DOT(uvw[2],rn) < 0.9999)            /* texture? */
538		extambient(acol, &amb, r->rop, rn, uvw);
533	–	}
539		return(1);
540		}
541
542
543		static int
544		extambient(             /* extrapolate value at pv, nv */
545	<	COLOR  cr,
545	>	SCOLOR  scr,
546		AMBVAL   *ap,
547		FVECT  pv,
548		FVECT  nv,
#	Line 569 | Line 574 | extambient(            /* extrapolate value at pv, nv */
574		d = min_d;
575		else if (d > max_d)
576		d = max_d;
577	<	copycolor(cr, ap->val);
578	<	scalecolor(cr, d);
577	>	copyscolor(scr, ap->val);
578	>	scalescolor(scr, d);
579		return(d > min_d);
580		}
581
#	Line 625 | Line 630 | initambfile(           /* initialize ambient file */
630		{
631		extern char  *progname, *octname;
632		static char  *mybuf = NULL;
633	+	int  ntries = 3;
634
635		#ifdef  F_SETLKW
636		aflock(cre8 ? F_WRLCK : F_RDLCK);
#	Line 633 | Line 639 | initambfile(           /* initialize ambient file */
639		if (mybuf == NULL)
640		mybuf = (char *)bmalloc(BUFSIZ+8);
641		setbuf(ambfp, mybuf);
642	+	retry:
643		if (cre8) {                     /* new file */
644		newheader("RADIANCE", ambfp);
645		fprintf(ambfp, "%s -av %g %g %g -aw %d -ab %d -aa %g ",
#	Line 641 | Line 648 | initambfile(           /* initialize ambient file */
648		ambvwt, ambounce, ambacc);
649		fprintf(ambfp, "-ad %d -as %d -ar %d ",
650		ambdiv, ambssamp, ambres);
651	+	fprintf(ambfp, "-dr %d -ds %g -dt %g -dc %g ", directrelay,
652	+	srcsizerat, shadthresh, shadcert);
653	+	fprintf(ambfp, "-ss %g -st %g -lr %d -lw %g ", specjitter,
654	+	specthresh, maxdepth, minweight);
655	+	fprintf(ambfp, "-cw %g %g -cs %d ", WLPART[3], WLPART[0], NCSAMP);
656		if (octname != NULL)
657		fputs(octname, ambfp);
658	<	fputc('\n', ambfp);
658	>	fputc('\n', ambfp);     /* end of command line, not header! */
659		fprintf(ambfp, "SOFTWARE= %s\n", VersionID);
660		fputnow(ambfp);
661	+	AMB_CNDX = CNDX;        /* use current spectral sampling */
662	+	AMB_WLPART = WLPART;
663	+	fputwlsplit(WLPART, ambfp);
664	+	fputncomp(NCSAMP, ambfp);
665		fputformat(AMBFMT, ambfp);
666		fputc('\n', ambfp);
667		putambmagic(ambfp);
668	<	} else if (checkheader(ambfp, AMBFMT, NULL) < 0 || !hasambmagic(ambfp))
669	<	error(USER, "bad ambient file");
668	>	} else if (getheader(ambfp, amb_headline, NULL) < 0 || !hasambmagic(ambfp)) {
669	>	if (--ntries > 0 && ftell(ambfp) == 0) {
670	>	#ifdef  F_SETLKW
671	>	aflock(F_UNLCK);
672	>	clearerr(ambfp);
673	>	sleep(2);
674	>	aflock(F_RDLCK);
675	>	#else
676	>	clearerr(ambfp);
677	>	sleep(2);
678	>	#endif
679	>	goto retry;
680	>	}
681	>	error(USER, "bad/incompatible ambient file");
682	>	}
683	>	if ((AMB_CNDX != CNDX) | (AMB_WLPART != WLPART)) {
684	>	if (setspectrsamp(AMB_CNDX, AMB_WLPART) < 0)
685	>	error(USER, "bad wavelength sampling in ambient file");
686	>	if (AMB_CNDX[3] == CNDX[3] && FABSEQ(AMB_WLPART[0],WLPART[0]) &&
687	>	FABSEQ(AMB_WLPART[3],WLPART[3])) {
688	>	AMB_CNDX = CNDX;
689	>	AMB_WLPART = WLPART;            /* just the same */
690	>	} else
691	>	error(WARNING, "different ambient file wavelength sampling");
692	>	}
693		}
694
695
#	Line 683 | Line 722 | avstore(                               /* allocate memory and save aval */
722
723		if ((av = newambval()) == NULL)
724		error(SYSTEM, "out of memory in avstore");
725	<	*av = *aval;
725	>	memcpy(av, aval, AVSIZE);       /* AVSIZE <= sizeof(AMBVAL) */
726		av->next = NULL;
727		nambvals++;
728	<	d = bright(av->val);
728	>	d = pbright(av->val);
729		if (d > FTINY) {                /* add to log sum for averaging */
730		avsum += log(d);
731		navsum++;

Diff Legend

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