ViewVC Help

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

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

Comparing ray/src/rt/m_bsdf.c (file contents):
Revision 2.27 by greg, Tue Feb 24 19:39:26 2015 UTC vs.
Revision 2.37 by greg, Thu May 18 17:59:37 2017 UTC

#	Line 23 | Line 23 | static const char RCSid[] = "$Id$";
23		*  (opposite the surface normal) to bypass any intervening geometry.
24		*  Translation only affects scattered, non-source-directed samples.
25		*  A non-zero thickness has the further side-effect that an unscattered
26	<	*  (view) ray will pass right through our material if it has any
27	<	*  non-diffuse transmission, making the BSDF surface invisible.  This
28	<	*  shows the proxied geometry instead. Thickness has the further
29	<	*  effect of turning off reflection on the hidden side so that rays
30	<	*  heading in the opposite direction pass unimpeded through the BSDF
26	>	*  (view) ray will pass right through our material, making the BSDF
27	>	*  surface invisible and showing the proxied geometry instead. Thickness
28	>	*  has the further effect of turning off reflection on the reverse side so
29	>	*  rays heading in the opposite direction pass unimpeded through the BSDF
30		*  surface.  A paired surface may be placed on the opposide side of
31		*  the detail geometry, less than this thickness away, if a two-way
32		*  proxy is desired.  Note that the sign of the thickness is important.
#	Line 36 | Line 35 | static const char RCSid[] = "$Id$";
35		*  hides geometry in front of the surface when rays hit from behind,
36		*  and applies only the transmission and backside reflectance properties.
37		*  Reflection is ignored on the hidden side, as those rays pass through.
38	+	*      When thickness is set to zero, shadow rays will be blocked unless
39	+	*  a BTDF has a strong "through" component in the source direction.
40	+	*  A separate test prevents over-counting by dropping specular & ambient
41	+	*  samples that are too close to this "through" direction.  The same
42	+	*  restriction applies for the proxy case (thickness != 0).
43		*      The "up" vector for the BSDF is given by three variables, defined
44		*  (along with the thickness) by the named function file, or '.' if none.
45		*  Together with the surface normal, this defines the local coordinate
#	Line 43 | Line 47 | static const char RCSid[] = "$Id$";
47		*      We do not reorient the surface, so if the BSDF has no back-side
48		*  reflectance and none is given in the real arguments, a BSDF surface
49		*  with zero thickness will appear black when viewed from behind
50	<	*  unless backface visibility is off.
50	>	*  unless backface visibility is on, when it becomes invisible.
51		*      The diffuse arguments are added to components in the BSDF file,
52		*  not multiplied.  However, patterns affect this material as a multiplier
53		*  on everything except non-diffuse reflection.
#	Line 59 | Line 63 | static const char RCSid[] = "$Id$";
63		/*
64		* Note that our reverse ray-tracing process means that the positions
65		* of incoming and outgoing vectors may be reversed in our calls
66	<	* to the BSDF library.  This is fine, since the bidirectional nature
66	>	* to the BSDF library.  This is usually fine, since the bidirectional nature
67		* of the BSDF (that's what the 'B' stands for) means it all works out.
68		*/
69
#	Line 72 | Line 76 | typedef struct {
76		RREAL   toloc[3][3];    /* world to local BSDF coords */
77		RREAL   fromloc[3][3];  /* local BSDF coords to world */
78		double  thick;          /* surface thickness */
79	+	COLOR   cthru;          /* "through" component multiplier */
80		SDData  *sd;            /* loaded BSDF data */
81	<	COLOR   runsamp;        /* BSDF hemispherical reflection */
82	<	COLOR   rdiff;          /* added diffuse reflection */
78	<	COLOR   tunsamp;        /* BSDF hemispherical transmission */
79	<	COLOR   tdiff;          /* added diffuse transmission */
81	>	COLOR   rdiff;          /* diffuse reflection */
82	>	COLOR   tdiff;          /* diffuse transmission */
83		}  BSDFDAT;             /* BSDF material data */
84
85		#define cvt_sdcolor(cv, svp)    ccy2rgb(&(svp)->spec, (svp)->cieY, cv)
86
87	+	/* Compute "through" component color */
88	+	static void
89	+	compute_through(BSDFDAT *ndp)
90	+	{
91	+	#define NDIR2CHECK      13
92	+	static const float      dir2check[NDIR2CHECK][2] = {
93	+	{0, 0},
94	+	{-0.8, 0},
95	+	{0, 0.8},
96	+	{0, -0.8},
97	+	{0.8, 0},
98	+	{-0.8, 0.8},
99	+	{-0.8, -0.8},
100	+	{0.8, 0.8},
101	+	{0.8, -0.8},
102	+	{-1.6, 0},
103	+	{0, 1.6},
104	+	{0, -1.6},
105	+	{1.6, 0},
106	+	};
107	+	const double    peak_over = 2.0;
108	+	SDSpectralDF    *dfp;
109	+	FVECT           pdir;
110	+	double          tomega, srchrad;
111	+	COLOR           vpeak, vsum;
112	+	int             nsum, i;
113	+	SDError         ec;
114	+
115	+	setcolor(ndp->cthru, .0, .0, .0);       /* starting assumption */
116	+
117	+	if (ndp->pr->rod > 0)
118	+	dfp = (ndp->sd->tf != NULL) ? ndp->sd->tf : ndp->sd->tb;
119	+	else
120	+	dfp = (ndp->sd->tb != NULL) ? ndp->sd->tb : ndp->sd->tf;
121	+
122	+	if (dfp == NULL)
123	+	return;                         /* no specular transmission */
124	+	if (bright(ndp->pr->pcol) <= FTINY)
125	+	return;                         /* pattern is black, here */
126	+	srchrad = sqrt(dfp->minProjSA);         /* else search for peak */
127	+	setcolor(vpeak, .0, .0, .0);
128	+	setcolor(vsum, .0, .0, .0);
129	+	nsum = 0;
130	+	for (i = 0; i < NDIR2CHECK; i++) {
131	+	FVECT   tdir;
132	+	SDValue sv;
133	+	COLOR   vcol;
134	+	tdir[0] = -ndp->vray[0] + dir2check[i][0]*srchrad;
135	+	tdir[1] = -ndp->vray[1] + dir2check[i][1]*srchrad;
136	+	tdir[2] = -ndp->vray[2];
137	+	normalize(tdir);
138	+	ec = SDevalBSDF(&sv, tdir, ndp->vray, ndp->sd);
139	+	if (ec)
140	+	goto baderror;
141	+	cvt_sdcolor(vcol, &sv);
142	+	addcolor(vsum, vcol);
143	+	++nsum;
144	+	if (bright(vcol) > bright(vpeak)) {
145	+	copycolor(vpeak, vcol);
146	+	VCOPY(pdir, tdir);
147	+	}
148	+	}
149	+	ec = SDsizeBSDF(&tomega, pdir, ndp->vray, SDqueryMin, ndp->sd);
150	+	if (ec)
151	+	goto baderror;
152	+	if (tomega > 1.5*dfp->minProjSA)
153	+	return;                         /* not really a peak? */
154	+	if ((bright(vpeak) - ndp->sd->tLamb.cieY*(1./PI))*tomega <= .007)
155	+	return;                         /* < 0.7% transmission */
156	+	for (i = 3; i--; )                      /* remove peak from average */
157	+	colval(vsum,i) -= colval(vpeak,i);
158	+	--nsum;
159	+	if (peak_over*bright(vsum) >= nsum*bright(vpeak))
160	+	return;                         /* not peaky enough */
161	+	copycolor(ndp->cthru, vpeak);           /* else use it */
162	+	scalecolor(ndp->cthru, tomega);
163	+	multcolor(ndp->cthru, ndp->pr->pcol);   /* modify by pattern */
164	+	return;
165	+	baderror:
166	+	objerror(ndp->mp, USER, transSDError(ec));
167	+	#undef NDIR2CHECK
168	+	}
169	+
170		/* Jitter ray sample according to projected solid angle and specjitter */
171		static void
172		bsdf_jitter(FVECT vres, BSDFDAT *ndp, double sr_psa)
#	Line 95 | Line 181 | bsdf_jitter(FVECT vres, BSDFDAT *ndp, double sr_psa)
181		normalize(vres);
182		}
183
184	<	/* Evaluate BSDF for direct component, returning true if OK to proceed */
184	>	/* Get BSDF specular for direct component, returning true if OK to proceed */
185		static int
186	<	direct_bsdf_OK(COLOR cval, FVECT ldir, double omega, BSDFDAT *ndp)
186	>	direct_specular_OK(COLOR cval, FVECT ldir, double omega, BSDFDAT *ndp)
187		{
188		int     nsamp, ok = 0;
189		FVECT   vsrc, vsmp, vjit;
190	<	double  tomega;
190	>	double  tomega, tomega2;
191		double  sf, tsr, sd[2];
192	<	COLOR   csmp;
192	>	COLOR   csmp, cdiff;
193	>	double  diffY;
194		SDValue sv;
195		SDError ec;
196		int     i;
197	+	/* in case we fail */
198	+	setcolor(cval, .0, .0, .0);
199		/* transform source direction */
200		if (SDmapDir(vsrc, ndp->toloc, ldir) != SDEnone)
201		return(0);
202	<	/* assign number of samples */
202	>	/* will discount diffuse portion */
203	>	switch ((vsrc[2] > 0)<<1 | (ndp->vray[2] > 0)) {
204	>	case 3:
205	>	if (ndp->sd->rf == NULL)
206	>	return(0);      /* all diffuse */
207	>	sv = ndp->sd->rLambFront;
208	>	break;
209	>	case 0:
210	>	if (ndp->sd->rb == NULL)
211	>	return(0);      /* all diffuse */
212	>	sv = ndp->sd->rLambBack;
213	>	break;
214	>	default:
215	>	if ((ndp->sd->tf == NULL) & (ndp->sd->tb == NULL))
216	>	return(0);      /* all diffuse */
217	>	sv = ndp->sd->tLamb;
218	>	break;
219	>	}
220	>	if (sv.cieY > FTINY) {
221	>	diffY = sv.cieY *= 1./PI;
222	>	cvt_sdcolor(cdiff, &sv);
223	>	} else {
224	>	diffY = .0;
225	>	setcolor(cdiff, .0, .0, .0);
226	>	}
227	>	/* need projected solid angles */
228	>	omega *= fabs(vsrc[2]);
229		ec = SDsizeBSDF(&tomega, ndp->vray, vsrc, SDqueryMin, ndp->sd);
230		if (ec)
231		goto baderror;
232		/* check indirect over-counting */
233	<	if (ndp->thick != 0 && ndp->pr->crtype & (SPECULAR|AMBIENT)
234	<	&& vsrc[2] > 0 ^ ndp->vray[2] > 0) {
233	>	if ((ndp->thick != 0 || bright(ndp->cthru) > FTINY)
234	>	&& ndp->pr->crtype & (SPECULAR|AMBIENT)
235	>	&& (vsrc[2] > 0) ^ (ndp->vray[2] > 0)) {
236		double  dx = vsrc[0] + ndp->vray[0];
237		double  dy = vsrc[1] + ndp->vray[1];
238	<	if (dx*dx + dy*dy <= omega+tomega)
238	>	if (dx*dx + dy*dy <= (4./PI)*(omega + tomega +
239	>	2.*sqrt(omega*tomega)))
240		return(0);
241		}
242	+	/* assign number of samples */
243		sf = specjitter * ndp->pr->rweight;
244		if (tomega <= .0)
245		nsamp = 1;
#	Line 130 | Line 248 | direct_bsdf_OK(COLOR cval, FVECT ldir, double omega, B
248		else
249		nsamp = 4.*sf*omega/tomega + .5;
250		nsamp += !nsamp;
251	<	setcolor(cval, .0, .0, .0);     /* sample our source area */
134	<	sf = sqrt(omega);
251	>	sf = sqrt(omega);               /* sample our source area */
252		tsr = sqrt(tomega);
253		for (i = nsamp; i--; ) {
254		VCOPY(vsmp, vsrc);      /* jitter query directions */
#	Line 139 | Line 256 | direct_bsdf_OK(COLOR cval, FVECT ldir, double omega, B
256		multisamp(sd, 2, (i + frandom())/(double)nsamp);
257		vsmp[0] += (sd[0] - .5)*sf;
258		vsmp[1] += (sd[1] - .5)*sf;
259	<	if (normalize(vsmp) == 0) {
143	<	--nsamp;
144	<	continue;
145	<	}
259	>	normalize(vsmp);
260		}
261		bsdf_jitter(vjit, ndp, tsr);
262		/* compute BSDF */
263		ec = SDevalBSDF(&sv, vjit, vsmp, ndp->sd);
264		if (ec)
265		goto baderror;
266	<	if (sv.cieY <= FTINY)   /* worth using? */
267	<	continue;
266	>	if (sv.cieY - diffY <= FTINY)
267	>	continue;       /* no specular part */
268	>	/* check for variable resolution */
269	>	ec = SDsizeBSDF(&tomega2, vjit, vsmp, SDqueryMin, ndp->sd);
270	>	if (ec)
271	>	goto baderror;
272	>	if (tomega2 < .12*tomega)
273	>	continue;       /* not safe to include */
274		cvt_sdcolor(csmp, &sv);
275	<	addcolor(cval, csmp);   /* average it in */
275	>	addcolor(cval, csmp);   /* else average it in */
276		++ok;
277		}
278	<	sf = 1./(double)nsamp;
278	>	if (!ok)                        /* no valid specular samples? */
279	>	return(0);
280	>
281	>	sf = 1./(double)ok;             /* compute average BSDF */
282		scalecolor(cval, sf);
283	<	return(ok);
283	>	/* subtract diffuse contribution */
284	>	for (i = 3*(diffY > FTINY); i--; )
285	>	if ((colval(cval,i) -= colval(cdiff,i)) < .0)
286	>	colval(cval,i) = .0;
287	>	return(1);
288		baderror:
289		objerror(ndp->mp, USER, transSDError(ec));
290		return(0);                      /* gratis return */
#	Line 201 | Line 328 | dir_bsdf(
328		scalecolor(ctmp, dtmp);
329		addcolor(cval, ctmp);
330		}
331	+	if (ambRayInPmap(np->pr))
332	+	return;         /* specular already in photon map */
333		/*
334	<	*  Compute scattering coefficient using BSDF.
334	>	*  Compute specular scattering coefficient using BSDF.
335		*/
336	<	if (!direct_bsdf_OK(ctmp, ldir, omega, np))
336	>	if (!direct_specular_OK(ctmp, ldir, omega, np))
337		return;
338	<	if (ldot > 0) {         /* pattern only diffuse reflection */
210	<	COLOR   ctmp1, ctmp2;
211	<	dtmp = (np->pr->rod > 0) ? np->sd->rLambFront.cieY
212	<	: np->sd->rLambBack.cieY;
213	<	/* diffuse fraction */
214	<	dtmp /= PI * bright(ctmp);
215	<	copycolor(ctmp2, np->pr->pcol);
216	<	scalecolor(ctmp2, dtmp);
217	<	setcolor(ctmp1, 1.-dtmp, 1.-dtmp, 1.-dtmp);
218	<	addcolor(ctmp1, ctmp2);
219	<	multcolor(ctmp, ctmp1); /* apply derated pattern */
220	<	dtmp = ldot * omega;
221	<	} else {                        /* full pattern on transmission */
338	>	if (ldot < 0) {         /* pattern for specular transmission */
339		multcolor(ctmp, np->pr->pcol);
340		dtmp = -ldot * omega;
341	<	}
341	>	} else
342	>	dtmp = ldot * omega;
343		scalecolor(ctmp, dtmp);
344		addcolor(cval, ctmp);
345		}
#	Line 256 | Line 374 | dir_brdf(
374		scalecolor(ctmp, dtmp);
375		addcolor(cval, ctmp);
376		}
377	+	if (ambRayInPmap(np->pr))
378	+	return;         /* specular already in photon map */
379		/*
380	<	*  Compute reflection coefficient using BSDF.
380	>	*  Compute specular reflection coefficient using BSDF.
381		*/
382	<	if (!direct_bsdf_OK(ctmp, ldir, omega, np))
382	>	if (!direct_specular_OK(ctmp, ldir, omega, np))
383		return;
264	–	/* pattern only diffuse reflection */
265	–	dtmp = (np->pr->rod > 0) ? np->sd->rLambFront.cieY
266	–	: np->sd->rLambBack.cieY;
267	–	dtmp /= PI * bright(ctmp);      /* diffuse fraction */
268	–	copycolor(ctmp2, np->pr->pcol);
269	–	scalecolor(ctmp2, dtmp);
270	–	setcolor(ctmp1, 1.-dtmp, 1.-dtmp, 1.-dtmp);
271	–	addcolor(ctmp1, ctmp2);
272	–	multcolor(ctmp, ctmp1);         /* apply derated pattern */
384		dtmp = ldot * omega;
385		scalecolor(ctmp, dtmp);
386		addcolor(cval, ctmp);
#	Line 305 | Line 416 | dir_btdf(
416		scalecolor(ctmp, dtmp);
417		addcolor(cval, ctmp);
418		}
419	+	if (ambRayInPmap(np->pr))
420	+	return;         /* specular already in photon map */
421		/*
422	<	*  Compute scattering coefficient using BSDF.
422	>	*  Compute specular scattering coefficient using BSDF.
423		*/
424	<	if (!direct_bsdf_OK(ctmp, ldir, omega, np))
424	>	if (!direct_specular_OK(ctmp, ldir, omega, np))
425		return;
426		/* full pattern on transmission */
427		multcolor(ctmp, np->pr->pcol);
#	Line 364 | Line 477 | sample_sdcomp(BSDFDAT *ndp, SDComponent *dcp, int usep
477		continue;               /* Russian roulette victim */
478		}
479		/* need to offset origin? */
480	<	if (ndp->thick != 0 && ndp->pr->rod > 0 ^ vsmp[2] > 0)
480	>	if (ndp->thick != 0 && (ndp->pr->rod > 0) ^ (vsmp[2] > 0))
481		VSUM(sr.rorg, sr.rorg, ndp->pr->ron, -ndp->thick);
482		rayvalue(&sr);                  /* send & evaluate sample */
483		multcolor(sr.rcol, sr.rcoef);
#	Line 382 | Line 495 | sample_sdf(BSDFDAT *ndp, int sflags)
495		COLORV          *unsc;
496
497		if (sflags == SDsampSpT) {
498	<	unsc = ndp->tunsamp;
498	>	unsc = ndp->tdiff;
499		if (ndp->pr->rod > 0)
500		dfp = (ndp->sd->tf != NULL) ? ndp->sd->tf : ndp->sd->tb;
501		else
502		dfp = (ndp->sd->tb != NULL) ? ndp->sd->tb : ndp->sd->tf;
390	–	cvt_sdcolor(unsc, &ndp->sd->tLamb);
503		} else /* sflags == SDsampSpR */ {
504	<	unsc = ndp->runsamp;
505	<	if (ndp->pr->rod > 0) {
504	>	unsc = ndp->rdiff;
505	>	if (ndp->pr->rod > 0)
506		dfp = ndp->sd->rf;
507	<	cvt_sdcolor(unsc, &ndp->sd->rLambFront);
396	<	} else {
507	>	else
508		dfp = ndp->sd->rb;
398	–	cvt_sdcolor(unsc, &ndp->sd->rLambBack);
399	–	}
509		}
401	–	multcolor(unsc, ndp->pr->pcol);
510		if (dfp == NULL)                        /* no specular component? */
511		return(0);
512		/* below sampling threshold? */
#	Line 452 | Line 560 | m_bsdf(OBJREC *m, RAY *r)
560		nd.thick = evalue(mf->ep[0]);
561		if ((-FTINY <= nd.thick) & (nd.thick <= FTINY))
562		nd.thick = .0;
455	–	/* check shadow */
456	–	if (r->crtype & SHADOW) {
457	–	if (nd.thick != 0)
458	–	raytrans(r);            /* pass-through */
459	–	return(1);                      /* or shadow */
460	–	}
563		/* check backface visibility */
564		if (!hitfront & !backvis) {
565		raytrans(r);
566		return(1);
567		}
568		/* check other rays to pass */
569	<	if (nd.thick != 0 && (!(r->crtype & (SPECULAR|AMBIENT)) ||
570	<	nd.thick > 0 ^ hitfront)) {
569	>	if (nd.thick != 0 && (r->crtype & SHADOW ||
570	>	!(r->crtype & (SPECULAR|AMBIENT)) ||
571	>	(nd.thick > 0) ^ hitfront)) {
572		raytrans(r);                    /* hide our proxy */
573		return(1);
574		}
575	<
576	<	/* PMAP: skip ambient ray if accounted for by photon map */
474	<	if (ambRayInPmap(r))
475	<	return(1);
476	<
575	>	nd.mp = m;
576	>	nd.pr = r;
577		/* get BSDF data */
578		nd.sd = loadBSDF(m->oargs.sarg[1]);
579	+	/* early shadow check */
580	+	if (r->crtype & SHADOW && (nd.sd->tf == NULL) & (nd.sd->tb == NULL))
581	+	return(1);
582		/* diffuse reflectance */
583		if (hitfront) {
584	<	if (m->oargs.nfargs < 3)
585	<	setcolor(nd.rdiff, .0, .0, .0);
586	<	else
484	<	setcolor(nd.rdiff, m->oargs.farg[0],
584	>	cvt_sdcolor(nd.rdiff, &nd.sd->rLambFront);
585	>	if (m->oargs.nfargs >= 3) {
586	>	setcolor(ctmp, m->oargs.farg[0],
587		m->oargs.farg[1],
588		m->oargs.farg[2]);
589	+	addcolor(nd.rdiff, ctmp);
590	+	}
591		} else {
592	<	if (m->oargs.nfargs < 6)
593	<	setcolor(nd.rdiff, .0, .0, .0);
594	<	else
491	<	setcolor(nd.rdiff, m->oargs.farg[3],
592	>	cvt_sdcolor(nd.rdiff, &nd.sd->rLambBack);
593	>	if (m->oargs.nfargs >= 6) {
594	>	setcolor(ctmp, m->oargs.farg[3],
595		m->oargs.farg[4],
596		m->oargs.farg[5]);
597	+	addcolor(nd.rdiff, ctmp);
598	+	}
599		}
600		/* diffuse transmittance */
601	<	if (m->oargs.nfargs < 9)
602	<	setcolor(nd.tdiff, .0, .0, .0);
603	<	else
499	<	setcolor(nd.tdiff, m->oargs.farg[6],
601	>	cvt_sdcolor(nd.tdiff, &nd.sd->tLamb);
602	>	if (m->oargs.nfargs >= 9) {
603	>	setcolor(ctmp, m->oargs.farg[6],
604		m->oargs.farg[7],
605		m->oargs.farg[8]);
606	<	nd.mp = m;
607	<	nd.pr = r;
606	>	addcolor(nd.tdiff, ctmp);
607	>	}
608		/* get modifiers */
609		raytexture(r, m->omod);
610		/* modify diffuse values */
#	Line 528 | Line 632 | m_bsdf(OBJREC *m, RAY *r)
632		nd.vray[2] = -r->rdir[2];
633		ec = SDmapDir(nd.vray, nd.toloc, nd.vray);
634		}
531	–	if (!ec)
532	–	ec = SDinvXform(nd.fromloc, nd.toloc);
635		if (ec) {
636		objerror(m, WARNING, "Illegal orientation vector");
637		return(1);
638		}
639	<	/* determine BSDF resolution */
640	<	ec = SDsizeBSDF(nd.sr_vpsa, nd.vray, NULL, SDqueryMin+SDqueryMax, nd.sd);
639	>	compute_through(&nd);                   /* compute through component */
640	>	if (r->crtype & SHADOW) {
641	>	RAY     tr;                     /* attempt to pass shadow ray */
642	>	if (rayorigin(&tr, TRANS, r, nd.cthru) < 0)
643	>	return(1);              /* blocked */
644	>	VCOPY(tr.rdir, r->rdir);
645	>	rayvalue(&tr);                  /* transmit with scaling */
646	>	multcolor(tr.rcol, tr.rcoef);
647	>	copycolor(r->rcol, tr.rcol);
648	>	return(1);                      /* we're done */
649	>	}
650	>	ec = SDinvXform(nd.fromloc, nd.toloc);
651	>	if (!ec)                                /* determine BSDF resolution */
652	>	ec = SDsizeBSDF(nd.sr_vpsa, nd.vray, NULL,
653	>	SDqueryMin+SDqueryMax, nd.sd);
654		if (ec)
655		objerror(m, USER, transSDError(ec));
656
#	Line 551 | Line 666 | m_bsdf(OBJREC *m, RAY *r)
666		/* sample transmission */
667		sample_sdf(&nd, SDsampSpT);
668		/* compute indirect diffuse */
669	<	copycolor(ctmp, nd.rdiff);
555	<	addcolor(ctmp, nd.runsamp);
556	<	if (bright(ctmp) > FTINY) {             /* ambient from reflection */
669	>	if (bright(nd.rdiff) > FTINY) {         /* ambient from reflection */
670		if (!hitfront)
671		flipsurface(r);
672	+	copycolor(ctmp, nd.rdiff);
673		multambient(ctmp, r, nd.pnorm);
674		addcolor(r->rcol, ctmp);
675		if (!hitfront)
676		flipsurface(r);
677		}
678	<	copycolor(ctmp, nd.tdiff);
565	<	addcolor(ctmp, nd.tunsamp);
566	<	if (bright(ctmp) > FTINY) {             /* ambient from other side */
678	>	if (bright(nd.tdiff) > FTINY) {         /* ambient from other side */
679		FVECT  bnorm;
680		if (hitfront)
681		flipsurface(r);
682		bnorm[0] = -nd.pnorm[0];
683		bnorm[1] = -nd.pnorm[1];
684		bnorm[2] = -nd.pnorm[2];
685	+	copycolor(ctmp, nd.tdiff);
686		if (nd.thick != 0) {            /* proxy with offset? */
687		VCOPY(vtmp, r->rop);
688		VSUM(r->rop, vtmp, r->ron, nd.thick);

Diff Legend

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