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.4 by greg, Tue Jan 14 15:33:08 1992 UTC vs.
Revision 2.28 by greg, Wed Dec 21 09:51:49 1994 UTC

#	Line 20 | Line 20 | static char SCCSid[] = "$SunId$ LBL";
20
21		#include  "random.h"
22
23	+	extern double  specthresh;              /* specular sampling threshold */
24	+	extern double  specjitter;              /* specular sampling jitter */
25	+
26	+	extern int  backvis;                    /* back faces visible? */
27	+
28	+	static  gaussamp();
29	+
30		/*
31	<	*      This routine uses portions of the reflection
32	<	*  model described by Cook and Torrance.
26	<	*      The computation of specular components has been simplified by
27	<	*  numerous approximations and ommisions to improve speed.
31	>	*      This routine implements the isotropic Gaussian
32	>	*  model described by Ward in Siggraph `92 article.
33		*      We orient the surface towards the incoming ray, so a single
34		*  surface can be used to represent an infinitely thin object.
35		*
#	Line 35 | Line 40 | static char SCCSid[] = "$SunId$ LBL";
40		*      red     grn     blu     rspec   rough   trans   tspec
41		*/
42
38	–	#define  BSPEC(m)       (6.0)           /* specularity parameter b */
39	–
43		/* specularity flags */
44		#define  SP_REFL        01              /* has reflected specular component */
45		#define  SP_TRAN        02              /* has transmitted specular */
46	<	#define  SP_PURE        010             /* purely specular (zero roughness) */
47	<	#define  SP_FLAT        020             /* flat reflecting surface */
46	>	#define  SP_PURE        04              /* purely specular (zero roughness) */
47	>	#define  SP_FLAT        010             /* flat reflecting surface */
48	>	#define  SP_RBLT        020             /* reflection below sample threshold */
49	>	#define  SP_TBLT        040             /* transmission below threshold */
50
51		typedef struct {
52		OBJREC  *mp;            /* material pointer */
53	+	RAY  *rp;               /* ray pointer */
54		short  specfl;          /* specularity flags, defined above */
55		COLOR  mcolor;          /* color of this material */
56		COLOR  scolor;          /* color of specular component */
#	Line 66 | Line 72 | FVECT  ldir;                   /* light source direction */
72		double  omega;                  /* light source size */
73		{
74		double  ldot;
75	<	double  dtmp;
76	<	int     i;
75	>	double  dtmp, d2;
76	>	FVECT  vtmp;
77		COLOR  ctmp;
78
79		setcolor(cval, 0.0, 0.0, 0.0);
#	Line 94 | Line 100 | double  omega;                 /* light source size */
100		*  gaussian distribution model.
101		*/
102		/* roughness */
103	<	dtmp = 2.0*np->alpha2;
103	>	dtmp = np->alpha2;
104		/* + source if flat */
105		if (np->specfl & SP_FLAT)
106	<	dtmp += omega/(2.0*PI);
106	>	dtmp += omega/(4.0*PI);
107	>	/* half vector */
108	>	vtmp[0] = ldir[0] - np->rp->rdir[0];
109	>	vtmp[1] = ldir[1] - np->rp->rdir[1];
110	>	vtmp[2] = ldir[2] - np->rp->rdir[2];
111	>	d2 = DOT(vtmp, np->pnorm);
112	>	d2 *= d2;
113	>	d2 = (DOT(vtmp,vtmp) - d2) / d2;
114		/* gaussian */
115	<	dtmp = exp((DOT(np->vrefl,ldir)-1.)/dtmp)/(2.*PI)/dtmp;
115	>	dtmp = exp(-d2/dtmp)/(4.*PI*dtmp);
116		/* worth using? */
117		if (dtmp > FTINY) {
118		copycolor(ctmp, np->scolor);
119	<	dtmp *= omega / np->pdot;
119	>	dtmp *= omega * sqrt(ldot/np->pdot);
120		scalecolor(ctmp, dtmp);
121		addcolor(cval, ctmp);
122		}
#	Line 123 | Line 136 | double  omega;                 /* light source size */
136		*  is always modified by material color.
137		*/
138		/* roughness + source */
139	<	dtmp = np->alpha2 + omega/(2.0*PI);
139	>	dtmp = np->alpha2 + omega/PI;
140		/* gaussian */
141	<	dtmp = exp((DOT(np->prdir,ldir)-1.)/dtmp)/(2.*PI)/dtmp;
141	>	dtmp = exp((2.*DOT(np->prdir,ldir)-2.)/dtmp)/(PI*dtmp);
142		/* worth using? */
143		if (dtmp > FTINY) {
144		copycolor(ctmp, np->mcolor);
145	<	dtmp *= np->tspec * omega / np->pdot;
145	>	dtmp *= np->tspec * omega * sqrt(-ldot/np->pdot);
146		scalecolor(ctmp, dtmp);
147		addcolor(cval, ctmp);
148		}
#	Line 143 | Line 156 | register RAY  *r;
156		{
157		NORMDAT  nd;
158		double  transtest, transdist;
146	–	double  dtmp;
159		COLOR  ctmp;
160		register int  i;
161		/* easy shadow test */
162		if (r->crtype & SHADOW && m->otype != MAT_TRANS)
163	<	return;
163	>	return(1);
164
165		if (m->oargs.nfargs != (m->otype == MAT_TRANS ? 7 : 5))
166		objerror(m, USER, "bad number of arguments");
167		nd.mp = m;
168	+	nd.rp = r;
169		/* get material color */
170		setcolor(nd.mcolor, m->oargs.farg[0],
171		m->oargs.farg[1],
#	Line 162 | Line 175 | register RAY  *r;
175		nd.alpha2 = m->oargs.farg[4];
176		if ((nd.alpha2 *= nd.alpha2) <= FTINY)
177		nd.specfl |= SP_PURE;
178	<	/* reorient if necessary */
179	<	if (r->rod < 0.0)
180	<	flipsurface(r);
178	>	/* check for back side */
179	>	if (r->rod < 0.0) {
180	>	if (!backvis && m->otype != MAT_TRANS) {
181	>	raytrans(r);
182	>	return(1);
183	>	}
184	>	flipsurface(r);                 /* reorient if backvis */
185	>	}
186		/* get modifiers */
187		raytexture(r, m->omod);
188		nd.pdot = raynormal(nd.pnorm, r);       /* perturb normal */
#	Line 172 | Line 190 | register RAY  *r;
190		nd.pdot = .001;                 /* non-zero for dirnorm() */
191		multcolor(nd.mcolor, r->pcol);          /* modify material color */
192		transtest = 0;
193	+	transdist = r->rot;
194		/* get specular component */
195		if ((nd.rspec = m->oargs.farg[3]) > FTINY) {
196		nd.specfl |= SP_REFL;
#	Line 181 | Line 200 | register RAY  *r;
200		else
201		setcolor(nd.scolor, 1.0, 1.0, 1.0);
202		scalecolor(nd.scolor, nd.rspec);
203	<	/* improved model */
204	<	dtmp = exp(-BSPEC(m)*nd.pdot);
205	<	for (i = 0; i < 3; i++)
187	<	colval(nd.scolor,i) += (1.0-colval(nd.scolor,i))*dtmp;
188	<	nd.rspec += (1.0-nd.rspec)*dtmp;
203	>	/* check threshold */
204	>	if (!(nd.specfl & SP_PURE) && specthresh >= nd.rspec-FTINY)
205	>	nd.specfl |= SP_RBLT;
206		/* compute reflected ray */
207		for (i = 0; i < 3; i++)
208		nd.vrefl[i] = r->rdir[i] + 2.0*nd.pdot*nd.pnorm[i];
209	+	if (DOT(nd.vrefl, r->ron) <= FTINY)     /* penetration? */
210	+	for (i = 0; i < 3; i++)         /* safety measure */
211	+	nd.vrefl[i] = r->rdir[i] + 2.*r->rod*r->ron[i];
212
213		if (!(r->crtype & SHADOW) && nd.specfl & SP_PURE) {
214		RAY  lr;
#	Line 207 | Line 227 | register RAY  *r;
227		nd.tdiff = nd.trans - nd.tspec;
228		if (nd.tspec > FTINY) {
229		nd.specfl |= SP_TRAN;
230	+	/* check threshold */
231	+	if (!(nd.specfl & SP_PURE) &&
232	+	specthresh >= nd.tspec-FTINY)
233	+	nd.specfl |= SP_TBLT;
234		if (r->crtype & SHADOW ||
235		DOT(r->pert,r->pert) <= FTINY*FTINY) {
236		VCOPY(nd.prdir, r->rdir);
237		transtest = 2;
238		} else {
239		for (i = 0; i < 3; i++)         /* perturb */
240	<	nd.prdir[i] = r->rdir[i] -
241	<	.75*r->pert[i];
242	<	normalize(nd.prdir);
240	>	nd.prdir[i] = r->rdir[i] - r->pert[i];
241	>	if (DOT(nd.prdir, r->ron) < -FTINY)
242	>	normalize(nd.prdir);    /* OK */
243	>	else
244	>	VCOPY(nd.prdir, r->rdir);
245		}
246		}
247		} else
#	Line 232 | Line 258 | register RAY  *r;
258		transtest *= bright(lr.rcol);
259		transdist = r->rot + lr.rt;
260		}
261	<	}
261	>	} else
262	>	transtest = 0;
263
264		if (r->crtype & SHADOW)                 /* the rest is shadow */
265	<	return;
265	>	return(1);
266		/* diffuse reflection */
267		nd.rdiff = 1.0 - nd.trans - nd.rspec;
268
269		if (nd.specfl & SP_PURE && nd.rdiff <= FTINY && nd.tdiff <= FTINY)
270	<	return;                         /* 100% pure specular */
270	>	return(1);                      /* 100% pure specular */
271
272	<	if (r->ro->otype == OBJ_FACE || r->ro->otype == OBJ_RING)
272	>	if (r->ro != NULL && (r->ro->otype == OBJ_FACE ||
273	>	r->ro->otype == OBJ_RING))
274		nd.specfl |= SP_FLAT;
275
276		if (nd.specfl & (SP_REFL|SP_TRAN) && !(nd.specfl & SP_PURE))
#	Line 250 | Line 278 | register RAY  *r;
278
279		if (nd.rdiff > FTINY) {         /* ambient from this side */
280		ambient(ctmp, r);
281	<	scalecolor(ctmp, nd.rdiff);
281	>	if (nd.specfl & SP_RBLT)
282	>	scalecolor(ctmp, 1.0-nd.trans);
283	>	else
284	>	scalecolor(ctmp, nd.rdiff);
285		multcolor(ctmp, nd.mcolor);     /* modified by material color */
286		addcolor(r->rcol, ctmp);        /* add to returned color */
287		}
288		if (nd.tdiff > FTINY) {         /* ambient from other side */
289		flipsurface(r);
290		ambient(ctmp, r);
291	<	scalecolor(ctmp, nd.tdiff);
291	>	if (nd.specfl & SP_TBLT)
292	>	scalecolor(ctmp, nd.trans);
293	>	else
294	>	scalecolor(ctmp, nd.tdiff);
295		multcolor(ctmp, nd.mcolor);     /* modified by color */
296		addcolor(r->rcol, ctmp);
297		flipsurface(r);
#	Line 267 | Line 301 | register RAY  *r;
301		/* check distance */
302		if (transtest > bright(r->rcol))
303		r->rt = transdist;
304	+
305	+	return(1);
306		}
307
308
#	Line 279 | Line 315 | register NORMDAT  *np;
315		FVECT  u, v, h;
316		double  rv[2];
317		double  d, sinp, cosp;
282	–	int  ntries;
318		register int  i;
319	+	/* quick test */
320	+	if ((np->specfl & (SP_REFL|SP_RBLT)) != SP_REFL &&
321	+	(np->specfl & (SP_TRAN|SP_TBLT)) != SP_TRAN)
322	+	return;
323		/* set up sample coordinates */
324		v[0] = v[1] = v[2] = 0.0;
325		for (i = 0; i < 3; i++)
#	Line 291 | Line 330 | register NORMDAT  *np;
330		normalize(u);
331		fcross(v, np->pnorm, u);
332		/* compute reflection */
333	<	if (np->specfl & SP_REFL &&
333	>	if ((np->specfl & (SP_REFL|SP_RBLT)) == SP_REFL &&
334		rayorigin(&sr, r, SPECULAR, np->rspec) == 0) {
335		dimlist[ndims++] = (int)np->mp;
336	<	for (ntries = 0; ntries < 10; ntries++) {
337	<	dimlist[ndims] = ntries * 8912;
338	<	d = urand(ilhash(dimlist,ndims+1)+samplendx);
339	<	multisamp(rv, 2, d);
340	<	d = 2.0*PI * rv[0];
341	<	cosp = cos(d);
342	<	sinp = sin(d);
343	<	if (rv[1] <= FTINY)
344	<	d = 1.0;
345	<	else
346	<	d = sqrt( np->alpha2 * -log(rv[1]) );
347	<	for (i = 0; i < 3; i++)
348	<	h[i] = np->pnorm[i] + d*(cosp*u[i] + sinp*v[i]);
349	<	d = -2.0 * DOT(h, r->rdir) / (1.0 + d*d);
350	<	for (i = 0; i < 3; i++)
351	<	sr.rdir[i] = r->rdir[i] + d*h[i];
352	<	if (DOT(sr.rdir, r->ron) > FTINY) {
353	<	rayvalue(&sr);
354	<	multcolor(sr.rcol, np->scolor);
355	<	addcolor(r->rcol, sr.rcol);
317	<	break;
318	<	}
319	<	}
336	>	d = urand(ilhash(dimlist,ndims)+samplendx);
337	>	multisamp(rv, 2, d);
338	>	d = 2.0*PI * rv[0];
339	>	cosp = cos(d);
340	>	sinp = sin(d);
341	>	rv[1] = 1.0 - specjitter*rv[1];
342	>	if (rv[1] <= FTINY)
343	>	d = 1.0;
344	>	else
345	>	d = sqrt( np->alpha2 * -log(rv[1]) );
346	>	for (i = 0; i < 3; i++)
347	>	h[i] = np->pnorm[i] + d*(cosp*u[i] + sinp*v[i]);
348	>	d = -2.0 * DOT(h, r->rdir) / (1.0 + d*d);
349	>	for (i = 0; i < 3; i++)
350	>	sr.rdir[i] = r->rdir[i] + d*h[i];
351	>	if (DOT(sr.rdir, r->ron) <= FTINY)
352	>	VCOPY(sr.rdir, np->vrefl);      /* jitter no good */
353	>	rayvalue(&sr);
354	>	multcolor(sr.rcol, np->scolor);
355	>	addcolor(r->rcol, sr.rcol);
356		ndims--;
357		}
358		/* compute transmission */
359	+	if ((np->specfl & (SP_TRAN|SP_TBLT)) == SP_TRAN &&
360	+	rayorigin(&sr, r, SPECULAR, np->tspec) == 0) {
361	+	dimlist[ndims++] = (int)np->mp;
362	+	d = urand(ilhash(dimlist,ndims)+1823+samplendx);
363	+	multisamp(rv, 2, d);
364	+	d = 2.0*PI * rv[0];
365	+	cosp = cos(d);
366	+	sinp = sin(d);
367	+	rv[1] = 1.0 - specjitter*rv[1];
368	+	if (rv[1] <= FTINY)
369	+	d = 1.0;
370	+	else
371	+	d = sqrt( -log(rv[1]) * np->alpha2 );
372	+	for (i = 0; i < 3; i++)
373	+	sr.rdir[i] = np->prdir[i] + d*(cosp*u[i] + sinp*v[i]);
374	+	if (DOT(sr.rdir, r->ron) < -FTINY)
375	+	normalize(sr.rdir);             /* OK, normalize */
376	+	else
377	+	VCOPY(sr.rdir, np->prdir);      /* else no jitter */
378	+	rayvalue(&sr);
379	+	scalecolor(sr.rcol, np->tspec);
380	+	multcolor(sr.rcol, np->mcolor);         /* modified by color */
381	+	addcolor(r->rcol, sr.rcol);
382	+	ndims--;
383	+	}
384		}

Diff Legend

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