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.41 by greg, Wed Mar 12 04:59:05 2003 UTC vs.
Revision 2.51 by greg, Thu Dec 8 17:56:38 2005 UTC

#	Line 14 | Line 14 | static const char RCSid[] = "$Id$";
14		#include "copyright.h"
15
16		#include  "ray.h"
17	<
17	>	#include  "ambient.h"
18	>	#include  "source.h"
19		#include  "otypes.h"
20	<
20	>	#include  "rtotypes.h"
21		#include  "random.h"
22
23		#ifndef  MAXITER
24		#define  MAXITER        10              /* maximum # specular ray attempts */
25		#endif
26		/* estimate of Fresnel function */
27	<	#define  FRESNE(ci)     (exp(-6.0*(ci)) - 0.00247875217)
27	>	#define  FRESNE(ci)     (exp(-5.85*(ci)) - 0.00287989916)
28	>	#define  FRESTHRESH     0.017999        /* minimum specularity for approx. */
29
28	–	static void  gaussamp();
30
31		/*
32		*      This routine implements the isotropic Gaussian
#	Line 64 | Line 65 | typedef struct {
65		double  pdot;           /* perturbed dot product */
66		}  NORMDAT;             /* normal material data */
67
68	+	static srcdirf_t dirnorm;
69	+	static void gaussamp(RAY  *r, NORMDAT  *np);
70
71	+
72		static void
73	<	dirnorm(cval, np, ldir, omega)          /* compute source contribution */
74	<	COLOR  cval;                    /* returned coefficient */
75	<	register NORMDAT  *np;          /* material data */
76	<	FVECT  ldir;                    /* light source direction */
77	<	double  omega;                  /* light source size */
73	>	dirnorm(                /* compute source contribution */
74	>	COLOR  cval,                    /* returned coefficient */
75	>	void  *nnp,             /* material data */
76	>	FVECT  ldir,                    /* light source direction */
77	>	double  omega                   /* light source size */
78	>	)
79		{
80	+	register NORMDAT *np = nnp;
81		double  ldot;
82	<	double  ldiff;
82	>	double  lrdiff, ltdiff;
83		double  dtmp, d2;
84		FVECT  vtmp;
85		COLOR  ctmp;
#	Line 86 | Line 92 | double  omega;                 /* light source size */
92		return;         /* wrong side */
93
94		/* Fresnel estimate */
95	<	ldiff = np->rdiff;
96	<	if (np->specfl & SP_PURE && (np->rspec > FTINY & ldiff > FTINY))
97	<	ldiff *= 1. - FRESNE(fabs(ldot));
95	>	lrdiff = np->rdiff;
96	>	ltdiff = np->tdiff;
97	>	if (np->specfl & SP_PURE && np->rspec >= FRESTHRESH &&
98	>	(lrdiff > FTINY) | (ltdiff > FTINY)) {
99	>	dtmp = 1. - FRESNE(fabs(ldot));
100	>	lrdiff *= dtmp;
101	>	ltdiff *= dtmp;
102	>	}
103
104	<	if (ldot > FTINY && ldiff > FTINY) {
104	>	if (ldot > FTINY && lrdiff > FTINY) {
105		/*
106		*  Compute and add diffuse reflected component to returned
107		*  color.  The diffuse reflected component will always be
108		*  modified by the color of the material.
109		*/
110		copycolor(ctmp, np->mcolor);
111	<	dtmp = ldot * omega * ldiff / PI;
111	>	dtmp = ldot * omega * lrdiff * (1.0/PI);
112		scalecolor(ctmp, dtmp);
113		addcolor(cval, ctmp);
114		}
#	Line 110 | Line 121 | double  omega;                 /* light source size */
121		dtmp = np->alpha2;
122		/* + source if flat */
123		if (np->specfl & SP_FLAT)
124	<	dtmp += omega/(4.0*PI);
124	>	dtmp += omega * (0.25/PI);
125		/* half vector */
126		vtmp[0] = ldir[0] - np->rp->rdir[0];
127		vtmp[1] = ldir[1] - np->rp->rdir[1];
#	Line 119 | Line 130 | double  omega;                 /* light source size */
130		d2 *= d2;
131		d2 = (DOT(vtmp,vtmp) - d2) / d2;
132		/* gaussian */
133	<	dtmp = exp(-d2/dtmp)/(4.*PI*dtmp);
133	>	dtmp = exp(-d2/dtmp)/(4.*PI * np->pdot * dtmp);
134		/* worth using? */
135		if (dtmp > FTINY) {
136		copycolor(ctmp, np->scolor);
137	<	dtmp *= omega * sqrt(ldot/np->pdot);
137	>	dtmp *= omega;
138		scalecolor(ctmp, dtmp);
139		addcolor(cval, ctmp);
140		}
141		}
142	<	if (ldot < -FTINY && np->tdiff > FTINY) {
142	>	if (ldot < -FTINY && ltdiff > FTINY) {
143		/*
144		*  Compute diffuse transmission.
145		*/
146		copycolor(ctmp, np->mcolor);
147	<	dtmp = -ldot * omega * np->tdiff / PI;
147	>	dtmp = -ldot * omega * ltdiff * (1.0/PI);
148		scalecolor(ctmp, dtmp);
149		addcolor(cval, ctmp);
150		}
#	Line 143 | Line 154 | double  omega;                 /* light source size */
154		*  is always modified by material color.
155		*/
156		/* roughness + source */
157	<	dtmp = np->alpha2 + omega/PI;
157	>	dtmp = np->alpha2 + omega*(1.0/PI);
158		/* gaussian */
159	<	dtmp = exp((2.*DOT(np->prdir,ldir)-2.)/dtmp)/(PI*dtmp);
159	>	dtmp = exp((2.*DOT(np->prdir,ldir)-2.)/dtmp) /
160	>	(PI*np->pdot*dtmp);
161		/* worth using? */
162		if (dtmp > FTINY) {
163		copycolor(ctmp, np->mcolor);
164	<	dtmp *= np->tspec * omega * sqrt(-ldot/np->pdot);
164	>	dtmp *= np->tspec * omega;
165		scalecolor(ctmp, dtmp);
166		addcolor(cval, ctmp);
167		}
#	Line 157 | Line 169 | double  omega;                 /* light source size */
169		}
170
171
172	<	int
173	<	m_normal(m, r)                  /* color a ray that hit something normal */
174	<	register OBJREC  *m;
175	<	register RAY  *r;
172	>	extern int
173	>	m_normal(                       /* color a ray that hit something normal */
174	>	register OBJREC  *m,
175	>	register RAY  *r
176	>	)
177		{
178		NORMDAT  nd;
179		double  fest;
#	Line 198 | Line 211 | register RAY  *r;
211		if ((nd.alpha2 *= nd.alpha2) <= FTINY)
212		nd.specfl |= SP_PURE;
213
214	<	if (hastexture = (DOT(r->pert,r->pert) > FTINY*FTINY)) {
214	>	if ( (hastexture = (DOT(r->pert,r->pert) > FTINY*FTINY)) ) {
215		nd.pdot = raynormal(nd.pnorm, r);       /* perturb normal */
216		} else {
217		VCOPY(nd.pnorm, r->ron);
218		nd.pdot = r->rod;
206	–	if (r->ro != NULL && isflat(r->ro->otype))
207	–	nd.specfl |= SP_FLAT;
219		}
220	+	if (r->ro != NULL && isflat(r->ro->otype))
221	+	nd.specfl |= SP_FLAT;
222		if (nd.pdot < .001)
223		nd.pdot = .001;                 /* non-zero for dirnorm() */
224		multcolor(nd.mcolor, r->pcol);          /* modify material color */
#	Line 213 | Line 226 | register RAY  *r;
226		mirdist = transdist = r->rot;
227		nd.rspec = m->oargs.farg[3];
228		/* compute Fresnel approx. */
229	<	if (nd.specfl & SP_PURE && nd.rspec > FTINY) {
229	>	if (nd.specfl & SP_PURE && nd.rspec >= FRESTHRESH) {
230		fest = FRESNE(r->rod);
231		nd.rspec += fest*(1. - nd.rspec);
232		} else
#	Line 246 | Line 259 | register RAY  *r;
259		/* transmitted ray */
260		if ((nd.specfl&(SP_TRAN|SP_PURE|SP_TBLT)) == (SP_TRAN|SP_PURE)) {
261		RAY  lr;
262	<	if (rayorigin(&lr, r, TRANS, nd.tspec) == 0) {
262	>	copycolor(lr.rcoef, nd.mcolor); /* modified by color */
263	>	scalecolor(lr.rcoef, nd.tspec);
264	>	if (rayorigin(&lr, TRANS, r, lr.rcoef) == 0) {
265		VCOPY(lr.rdir, nd.prdir);
266		rayvalue(&lr);
267	<	scalecolor(lr.rcol, nd.tspec);
253	<	multcolor(lr.rcol, nd.mcolor);  /* modified by color */
267	>	multcolor(lr.rcol, lr.rcoef);
268		addcolor(r->rcol, lr.rcol);
269		transtest *= bright(lr.rcol);
270		transdist = r->rot + lr.rt;
#	Line 290 | Line 304 | register RAY  *r;
304		/* reflected ray */
305		if ((nd.specfl&(SP_REFL|SP_PURE|SP_RBLT)) == (SP_REFL|SP_PURE)) {
306		RAY  lr;
307	<	if (rayorigin(&lr, r, REFLECTED, nd.rspec) == 0) {
307	>	if (rayorigin(&lr, REFLECTED, r, nd.scolor) == 0) {
308		VCOPY(lr.rdir, nd.vrefl);
309		rayvalue(&lr);
310	<	multcolor(lr.rcol, nd.scolor);
310	>	multcolor(lr.rcol, lr.rcoef);
311		addcolor(r->rcol, lr.rcol);
312		if (!hastexture && nd.specfl & SP_FLAT) {
313		mirtest = 2.*bright(lr.rcol);
#	Line 311 | Line 325 | register RAY  *r;
325		gaussamp(r, &nd);               /* checks *BLT flags */
326
327		if (nd.rdiff > FTINY) {         /* ambient from this side */
328	<	ambient(ctmp, r, hastexture?nd.pnorm:r->ron);
328	>	copycolor(ctmp, nd.mcolor);     /* modified by material color */
329		if (nd.specfl & SP_RBLT)
330		scalecolor(ctmp, 1.0-nd.trans);
331		else
332		scalecolor(ctmp, nd.rdiff);
333	<	multcolor(ctmp, nd.mcolor);     /* modified by material color */
333	>	multambient(ctmp, r, hastexture ? nd.pnorm : r->ron);
334		addcolor(r->rcol, ctmp);        /* add to returned color */
335		}
336		if (nd.tdiff > FTINY) {         /* ambient from other side */
337	+	copycolor(ctmp, nd.mcolor);     /* modified by color */
338	+	if (nd.specfl & SP_TBLT)
339	+	scalecolor(ctmp, nd.trans);
340	+	else
341	+	scalecolor(ctmp, nd.tdiff);
342		flipsurface(r);
343		if (hastexture) {
344		FVECT  bnorm;
345		bnorm[0] = -nd.pnorm[0];
346		bnorm[1] = -nd.pnorm[1];
347		bnorm[2] = -nd.pnorm[2];
348	<	ambient(ctmp, r, bnorm);
348	>	multambient(ctmp, r, bnorm);
349		} else
350	<	ambient(ctmp, r, r->ron);
332	<	if (nd.specfl & SP_TBLT)
333	<	scalecolor(ctmp, nd.trans);
334	<	else
335	<	scalecolor(ctmp, nd.tdiff);
336	<	multcolor(ctmp, nd.mcolor);     /* modified by color */
350	>	multambient(ctmp, r, r->ron);
351		addcolor(r->rcol, ctmp);
352		flipsurface(r);
353		}
#	Line 351 | Line 365 | register RAY  *r;
365
366
367		static void
368	<	gaussamp(r, np)                 /* sample gaussian specular */
369	<	RAY  *r;
370	<	register NORMDAT  *np;
368	>	gaussamp(                       /* sample gaussian specular */
369	>	RAY  *r,
370	>	register NORMDAT  *np
371	>	)
372		{
373		RAY  sr;
374		FVECT  u, v, h;
#	Line 376 | Line 391 | register NORMDAT  *np;
391		fcross(v, np->pnorm, u);
392		/* compute reflection */
393		if ((np->specfl & (SP_REFL|SP_RBLT)) == SP_REFL &&
394	<	rayorigin(&sr, r, SPECULAR, np->rspec) == 0) {
394	>	rayorigin(&sr, SPECULAR, r, np->scolor) == 0) {
395		dimlist[ndims++] = (int)np->mp;
396		for (niter = 0; niter < MAXITER; niter++) {
397		if (niter)
#	Line 399 | Line 414 | register NORMDAT  *np;
414		sr.rdir[i] = r->rdir[i] + d*h[i];
415		if (DOT(sr.rdir, r->ron) > FTINY) {
416		rayvalue(&sr);
417	<	multcolor(sr.rcol, np->scolor);
417	>	multcolor(sr.rcol, sr.rcoef);
418		addcolor(r->rcol, sr.rcol);
419		break;
420		}
#	Line 407 | Line 422 | register NORMDAT  *np;
422		ndims--;
423		}
424		/* compute transmission */
425	+	copycolor(sr.rcoef, np->mcolor);        /* modified by color */
426	+	scalecolor(sr.rcoef, np->tspec);
427		if ((np->specfl & (SP_TRAN|SP_TBLT)) == SP_TRAN &&
428	<	rayorigin(&sr, r, SPECULAR, np->tspec) == 0) {
428	>	rayorigin(&sr, SPECULAR, r, sr.rcoef) == 0) {
429		dimlist[ndims++] = (int)np->mp;
430		for (niter = 0; niter < MAXITER; niter++) {
431		if (niter)
#	Line 429 | Line 446 | register NORMDAT  *np;
446		if (DOT(sr.rdir, r->ron) < -FTINY) {
447		normalize(sr.rdir);     /* OK, normalize */
448		rayvalue(&sr);
449	<	scalecolor(sr.rcol, np->tspec);
433	<	multcolor(sr.rcol, np->mcolor); /* modified */
449	>	multcolor(sr.rcol, sr.rcoef);
450		addcolor(r->rcol, sr.rcol);
451		break;
452		}

Diff Legend

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