ViewVC Help

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

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

Comparing ray/src/rt/normal.c (file contents):
Revision 2.62 by greg, Sun Jul 29 19:01:39 2012 UTC vs.
Revision 2.70 by greg, Thu May 21 05:54:54 2015 UTC

#	Line 19 | Line 19 | static const char RCSid[] = "$Id$";
19		#include  "otypes.h"
20		#include  "rtotypes.h"
21		#include  "random.h"
22	+	#include  "pmapmat.h"
23
24		#ifndef  MAXITER
25		#define  MAXITER        10              /* maximum # specular ray attempts */
#	Line 65 | Line 66 | typedef struct {
66		double  pdot;           /* perturbed dot product */
67		}  NORMDAT;             /* normal material data */
68
69	<	static void gaussamp(RAY  *r, NORMDAT  *np);
69	>	static void gaussamp(NORMDAT  *np);
70
71
72		static void
#	Line 111 | Line 112 | dirnorm(               /* compute source contribution */
112		scalecolor(ctmp, dtmp);
113		addcolor(cval, ctmp);
114		}
115	+
116	+	if (ldot < -FTINY && ltdiff > FTINY) {
117	+	/*
118	+	*  Compute diffuse transmission.
119	+	*/
120	+	copycolor(ctmp, np->mcolor);
121	+	dtmp = -ldot * omega * ltdiff * (1.0/PI);
122	+	scalecolor(ctmp, dtmp);
123	+	addcolor(cval, ctmp);
124	+	}
125	+
126	+	/* PMAP: skip direct specular via ambient bounce if already accounted for
127	+	* in photon map */
128	+	if (ambRayInPmap(np->rp))
129	+	return;
130	+
131		if (ldot > FTINY && (np->specfl&(SP_REFL|SP_PURE)) == SP_REFL) {
132		/*
133		*  Compute specular reflection coefficient using
#	Line 137 | Line 154 | dirnorm(               /* compute source contribution */
154		addcolor(cval, ctmp);
155		}
156		}
157	<	if (ldot < -FTINY && ltdiff > FTINY) {
158	<	/*
142	<	*  Compute diffuse transmission.
143	<	*/
144	<	copycolor(ctmp, np->mcolor);
145	<	dtmp = -ldot * omega * ltdiff * (1.0/PI);
146	<	scalecolor(ctmp, dtmp);
147	<	addcolor(cval, ctmp);
148	<	}
157	>
158	>
159		if (ldot < -FTINY && (np->specfl&(SP_TRAN|SP_PURE)) == SP_TRAN) {
160		/*
161		*  Compute specular transmission.  Specular transmission
#	Line 180 | Line 190 | m_normal(                      /* color a ray that hit something normal *
190		double  d;
191		COLOR  ctmp;
192		int  i;
193	+
194	+	/* PMAP: skip transmitted shadow ray if accounted for in photon map */
195	+	if (shadowRayInPmap(r))
196	+	return(1);
197		/* easy shadow test */
198		if (r->crtype & SHADOW && m->otype != MAT_TRANS)
199		return(1);
#	Line 188 | Line 202 | m_normal(                      /* color a ray that hit something normal *
202		objerror(m, USER, "bad number of arguments");
203		/* check for back side */
204		if (r->rod < 0.0) {
205	<	if (!backvis && m->otype != MAT_TRANS) {
205	>	if (!backvis) {
206		raytrans(r);
207		return(1);
208		}
#	Line 239 | Line 253 | m_normal(                      /* color a ray that hit something normal *
253		if (!(nd.specfl & SP_PURE) &&
254		specthresh >= nd.tspec-FTINY)
255		nd.specfl |= SP_TBLT;
256	<	if (!hastexture || r->crtype & SHADOW) {
256	>	if (!hastexture || r->crtype & (SHADOW|AMBIENT)) {
257		VCOPY(nd.prdir, r->rdir);
258		transtest = 2;
259		} else {
#	Line 254 | Line 268 | m_normal(                      /* color a ray that hit something normal *
268		} else
269		nd.tdiff = nd.tspec = nd.trans = 0.0;
270		/* transmitted ray */
271	<	if ((nd.specfl&(SP_TRAN|SP_PURE|SP_TBLT)) == (SP_TRAN|SP_PURE)) {
271	>
272	>	/* PMAP: skip indirect specular trans via ambient bounce if already
273	>	* accounted for in photon map */
274	>	if (!ambRayInPmap(r) &&
275	>	(nd.specfl&(SP_TRAN|SP_PURE|SP_TBLT)) == (SP_TRAN|SP_PURE)) {
276		RAY  lr;
277		copycolor(lr.rcoef, nd.mcolor); /* modified by color */
278		scalecolor(lr.rcoef, nd.tspec);
#	Line 280 | Line 298 | m_normal(                      /* color a ray that hit something normal *
298		if (m->otype != MAT_METAL) {
299		setcolor(nd.scolor, nd.rspec, nd.rspec, nd.rspec);
300		} else if (fest > FTINY) {
301	<	d = nd.rspec*(1. - fest);
301	>	d = m->oargs.farg[3]*(1. - fest);
302		for (i = 0; i < 3; i++)
303	<	nd.scolor[i] = fest + nd.mcolor[i]*d;
303	>	colval(nd.scolor,i) = fest +
304	>	colval(nd.mcolor,i)*d;
305		} else {
306		copycolor(nd.scolor, nd.mcolor);
307		scalecolor(nd.scolor, nd.rspec);
#	Line 298 | Line 317 | m_normal(                      /* color a ray that hit something normal *
317		checknorm(nd.vrefl);
318		}
319		/* reflected ray */
320	<	if ((nd.specfl&(SP_REFL|SP_PURE|SP_RBLT)) == (SP_REFL|SP_PURE)) {
320	>	/* PMAP: skip indirect specular refl via ambient ray if already accounted
321	>	* for in photon map */
322	>	if (!ambRayInPmap(r) &&
323	>	(nd.specfl&(SP_REFL|SP_PURE|SP_RBLT)) == (SP_REFL|SP_PURE)) {
324		RAY  lr;
325		if (rayorigin(&lr, REFLECTED, r, nd.scolor) == 0) {
326		VCOPY(lr.rdir, nd.vrefl);
327		rayvalue(&lr);
328		multcolor(lr.rcol, lr.rcoef);
329		addcolor(r->rcol, lr.rcol);
330	<	if (!hastexture && nd.specfl & SP_FLAT) {
330	>	if (nd.specfl & SP_FLAT &&
331	>	!hastexture | (r->crtype & AMBIENT)) {
332		mirtest = 2.*bright(lr.rcol);
333		mirdist = r->rot + lr.rt;
334		}
#	Line 317 | Line 340 | m_normal(                      /* color a ray that hit something normal *
340		if (nd.specfl & SP_PURE && nd.rdiff <= FTINY && nd.tdiff <= FTINY)
341		return(1);                      /* 100% pure specular */
342
343	<	if (!(nd.specfl & SP_PURE))
344	<	gaussamp(r, &nd);               /* checks *BLT flags */
343	>	/* PMAP: skip indirect gaussian via ambient bounce if already accounted
344	>	* for in photon map */
345	>	if (!ambRayInPmap(r))
346	>	if (!(nd.specfl & SP_PURE))
347	>	gaussamp(&nd);          /* checks *BLT flags */
348
349		if (nd.rdiff > FTINY) {         /* ambient from this side */
350		copycolor(ctmp, nd.mcolor);     /* modified by material color */
#	Line 361 | Line 387 | m_normal(                      /* color a ray that hit something normal *
387
388		static void
389		gaussamp(                       /* sample Gaussian specular */
364	–	RAY  *r,
390		NORMDAT  *np
391		)
392		{
#	Line 377 | Line 402 | gaussamp(                      /* sample Gaussian specular */
402		(np->specfl & (SP_TRAN|SP_TBLT)) != SP_TRAN)
403		return;
404		/* set up sample coordinates */
405	<	v[0] = v[1] = v[2] = 0.0;
381	<	for (i = 0; i < 3; i++)
382	<	if (np->pnorm[i] < 0.6 && np->pnorm[i] > -0.6)
383	<	break;
384	<	v[i] = 1.0;
385	<	fcross(u, v, np->pnorm);
386	<	normalize(u);
405	>	getperpendicular(u, np->pnorm, rand_samp);
406		fcross(v, np->pnorm, u);
407		/* compute reflection */
408		if ((np->specfl & (SP_REFL|SP_RBLT)) == SP_REFL &&
409	<	rayorigin(&sr, SPECULAR, r, np->scolor) == 0) {
409	>	rayorigin(&sr, SPECULAR, np->rp, np->scolor) == 0) {
410		nstarget = 1;
411		if (specjitter > 1.5) { /* multiple samples? */
412	<	nstarget = specjitter*r->rweight + .5;
412	>	nstarget = specjitter*np->rp->rweight + .5;
413		if (sr.rweight <= minweight*nstarget)
414		nstarget = sr.rweight/minweight;
415		if (nstarget > 1) {
#	Line 421 | Line 440 | gaussamp(                      /* sample Gaussian specular */
440		d = sqrt( np->alpha2 * -log(rv[1]) );
441		for (i = 0; i < 3; i++)
442		h[i] = np->pnorm[i] + d*(cosp*u[i] + sinp*v[i]);
443	<	d = -2.0 * DOT(h, r->rdir) / (1.0 + d*d);
444	<	VSUM(sr.rdir, r->rdir, h, d);
443	>	d = -2.0 * DOT(h, np->rp->rdir) / (1.0 + d*d);
444	>	VSUM(sr.rdir, np->rp->rdir, h, d);
445		/* sample rejection test */
446	<	if ((d = DOT(sr.rdir, r->ron)) <= FTINY)
446	>	if ((d = DOT(sr.rdir, np->rp->ron)) <= FTINY)
447		continue;
448		checknorm(sr.rdir);
449		if (nstarget > 1) {     /* W-G-M-D adjustment */
450		if (nstaken) rayclear(&sr);
451		rayvalue(&sr);
452	<	d = 2./(1. + r->rod/d);
452	>	d = 2./(1. + np->rp->rod/d);
453		scalecolor(sr.rcol, d);
454		addcolor(scol, sr.rcol);
455		} else {
456		rayvalue(&sr);
457		multcolor(sr.rcol, sr.rcoef);
458	<	addcolor(r->rcol, sr.rcol);
458	>	addcolor(np->rp->rcol, sr.rcol);
459		}
460		++nstaken;
461		}
#	Line 444 | Line 463 | gaussamp(                      /* sample Gaussian specular */
463		multcolor(scol, sr.rcoef);
464		d = (double)nstarget/ntrials;
465		scalecolor(scol, d);
466	<	addcolor(r->rcol, scol);
466	>	addcolor(np->rp->rcol, scol);
467		}
468		ndims--;
469		}
#	Line 452 | Line 471 | gaussamp(                      /* sample Gaussian specular */
471		copycolor(sr.rcoef, np->mcolor);        /* modified by color */
472		scalecolor(sr.rcoef, np->tspec);
473		if ((np->specfl & (SP_TRAN|SP_TBLT)) == SP_TRAN &&
474	<	rayorigin(&sr, SPECULAR, r, sr.rcoef) == 0) {
474	>	rayorigin(&sr, SPECULAR, np->rp, sr.rcoef) == 0) {
475		nstarget = 1;
476		if (specjitter > 1.5) { /* multiple samples? */
477	<	nstarget = specjitter*r->rweight + .5;
477	>	nstarget = specjitter*np->rp->rweight + .5;
478		if (sr.rweight <= minweight*nstarget)
479		nstarget = sr.rweight/minweight;
480		if (nstarget > 1) {
#	Line 486 | Line 505 | gaussamp(                      /* sample Gaussian specular */
505		for (i = 0; i < 3; i++)
506		sr.rdir[i] = np->prdir[i] + d*(cosp*u[i] + sinp*v[i]);
507		/* sample rejection test */
508	<	if (DOT(sr.rdir, r->ron) >= -FTINY)
508	>	if (DOT(sr.rdir, np->rp->ron) >= -FTINY)
509		continue;
510		normalize(sr.rdir);     /* OK, normalize */
511		if (nstaken)            /* multi-sampling */
512		rayclear(&sr);
513		rayvalue(&sr);
514		multcolor(sr.rcol, sr.rcoef);
515	<	addcolor(r->rcol, sr.rcol);
515	>	addcolor(np->rp->rcol, sr.rcol);
516		++nstaken;
517		}
518		ndims--;

Diff Legend

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