ViewVC Help

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

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

Comparing ray/src/rt/aniso.c (file contents):
Revision 2.3 by greg, Mon Jan 6 18:01:41 1992 UTC vs.
Revision 2.33 by gwlarson, Wed Dec 16 18:14:57 1998 UTC

#	Line 1 | Line 1
1	<	/* Copyright (c) 1992 Regents of the University of California */
1	>	/* Copyright (c) 1998 Silicon Graphics, Inc. */
2
3		#ifndef lint
4	<	static char SCCSid[] = "$SunId$ LBL";
4	>	static char SCCSid[] = "$SunId$ SGI";
5		#endif
6
7		/*
#	Line 16 | Line 16 | static char SCCSid[] = "$SunId$ LBL";
16
17		#include  "random.h"
18
19	+	extern double  specthresh;              /* specular sampling threshold */
20	+	extern double  specjitter;              /* specular sampling jitter */
21	+
22	+	extern int  backvis;                    /* back faces visible? */
23	+
24	+	#ifndef  MAXITER
25	+	#define  MAXITER        10              /* maximum # specular ray attempts */
26	+	#endif
27	+
28	+	static  agaussamp(), getacoords();
29	+
30		/*
31	<	*      This anisotropic reflection model uses a variant on the
32	<	*  exponential Gaussian used in normal.c.
31	>	*      This routine implements the anisotropic 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 31 | Line 42 | static char SCCSid[] = "$SunId$ LBL";
42		*  8  red      grn     blu     rspec   u-rough v-rough trans   tspec
43		*/
44
34	–	#define  BSPEC(m)       (6.0)           /* specularity parameter b */
35	–
45		/* specularity flags */
46		#define  SP_REFL        01              /* has reflected specular component */
47		#define  SP_TRAN        02              /* has transmitted specular */
48	<	#define  SP_PURE        010             /* purely specular (zero roughness) */
49	<	#define  SP_BADU        020             /* bad u direction calculation */
50	<	#define  SP_FLAT        040             /* reflecting surface is flat */
48	>	#define  SP_FLAT        04              /* reflecting surface is flat */
49	>	#define  SP_RBLT        010             /* reflection below sample threshold */
50	>	#define  SP_TBLT        020             /* transmission below threshold */
51	>	#define  SP_BADU        040             /* bad u direction calculation */
52
53		typedef struct {
54		OBJREC  *mp;            /* material pointer */
#	Line 46 | Line 56 | typedef struct {
56		short  specfl;          /* specularity flags, defined above */
57		COLOR  mcolor;          /* color of this material */
58		COLOR  scolor;          /* color of specular component */
59	+	FVECT  vrefl;           /* vector in reflected direction */
60		FVECT  prdir;           /* vector in transmitted direction */
61		FVECT  u, v;            /* u and v vectors orienting anisotropy */
62		double  u_alpha;        /* u roughness */
#	Line 65 | Line 76 | FVECT  ldir;                   /* light source direction */
76		double  omega;                  /* light source size */
77		{
78		double  ldot;
79	<	double  dtmp, dtmp2;
79	>	double  dtmp, dtmp1, dtmp2;
80		FVECT  h;
81		double  au2, av2;
82		COLOR  ctmp;
#	Line 88 | Line 99 | double  omega;                 /* light source size */
99		scalecolor(ctmp, dtmp);
100		addcolor(cval, ctmp);
101		}
102	<	if (ldot > FTINY && (np->specfl&(SP_REFL|SP_PURE|SP_BADU)) == SP_REFL) {
102	>	if (ldot > FTINY && (np->specfl&(SP_REFL|SP_BADU)) == SP_REFL) {
103		/*
104		*  Compute specular reflection coefficient using
105		*  anisotropic gaussian distribution model.
#	Line 98 | Line 109 | double  omega;                 /* light source size */
109		au2 = av2 = omega/(4.0*PI);
110		else
111		au2 = av2 = 0.0;
112	<	au2 += np->u_alpha * np->u_alpha;
113	<	av2 += np->v_alpha * np->v_alpha;
112	>	au2 += np->u_alpha*np->u_alpha;
113	>	av2 += np->v_alpha*np->v_alpha;
114		/* half vector */
115		h[0] = ldir[0] - np->rp->rdir[0];
116		h[1] = ldir[1] - np->rp->rdir[1];
117		h[2] = ldir[2] - np->rp->rdir[2];
107	–	normalize(h);
118		/* ellipse */
119	<	dtmp = DOT(np->u, h);
120	<	dtmp *= dtmp / au2;
119	>	dtmp1 = DOT(np->u, h);
120	>	dtmp1 *= dtmp1 / au2;
121		dtmp2 = DOT(np->v, h);
122		dtmp2 *= dtmp2 / av2;
123		/* gaussian */
124	<	dtmp = (dtmp + dtmp2) / (1.0 + DOT(np->pnorm, h));
125	<	dtmp = exp(-2.0*dtmp) / (4.0*PI * sqrt(au2*av2));
124	>	dtmp = DOT(np->pnorm, h);
125	>	dtmp = (dtmp1 + dtmp2) / (dtmp*dtmp);
126	>	dtmp = exp(-dtmp) * (0.25/PI)
127	>	* sqrt(ldot/(np->pdot*au2*av2));
128		/* worth using? */
129		if (dtmp > FTINY) {
130		copycolor(ctmp, np->scolor);
131	<	dtmp *= omega / np->pdot;
131	>	dtmp *= omega;
132		scalecolor(ctmp, dtmp);
133		addcolor(cval, ctmp);
134		}
#	Line 130 | Line 142 | double  omega;                 /* light source size */
142		scalecolor(ctmp, dtmp);
143		addcolor(cval, ctmp);
144		}
145	<	if (ldot < -FTINY && (np->specfl&(SP_TRAN|SP_PURE|SP_BADU)) == SP_TRAN) {
145	>	if (ldot < -FTINY && (np->specfl&(SP_TRAN|SP_BADU)) == SP_TRAN) {
146		/*
147		*  Compute specular transmission.  Specular transmission
148		*  is always modified by material color.
149		*/
150		/* roughness + source */
151	+	au2 = av2 = omega / PI;
152	+	au2 += np->u_alpha*np->u_alpha;
153	+	av2 += np->v_alpha*np->v_alpha;
154	+	/* "half vector" */
155	+	h[0] = ldir[0] - np->prdir[0];
156	+	h[1] = ldir[1] - np->prdir[1];
157	+	h[2] = ldir[2] - np->prdir[2];
158	+	dtmp = DOT(h,h);
159	+	if (dtmp > FTINY*FTINY) {
160	+	dtmp1 = DOT(h,np->pnorm);
161	+	dtmp = 1.0 - dtmp1*dtmp1/dtmp;
162	+	if (dtmp > FTINY*FTINY) {
163	+	dtmp1 = DOT(h,np->u);
164	+	dtmp1 *= dtmp1 / au2;
165	+	dtmp2 = DOT(h,np->v);
166	+	dtmp2 *= dtmp2 / av2;
167	+	dtmp = (dtmp1 + dtmp2) / dtmp;
168	+	}
169	+	} else
170	+	dtmp = 0.0;
171		/* gaussian */
172	<	dtmp = 0.0;
172	>	dtmp = exp(-dtmp) * (1.0/PI)
173	>	* sqrt(-ldot/(np->pdot*au2*av2));
174		/* worth using? */
175		if (dtmp > FTINY) {
176		copycolor(ctmp, np->mcolor);
177	<	dtmp *= np->tspec * omega / np->pdot;
177	>	dtmp *= np->tspec * omega;
178		scalecolor(ctmp, dtmp);
179		addcolor(cval, ctmp);
180		}
#	Line 154 | Line 187 | register OBJREC  *m;
187		register RAY  *r;
188		{
189		ANISODAT  nd;
157	–	double  transtest, transdist;
158	–	double  dtmp;
190		COLOR  ctmp;
191		register int  i;
192		/* easy shadow test */
193	<	if (r->crtype & SHADOW && m->otype != MAT_TRANS2)
194	<	return;
193	>	if (r->crtype & SHADOW)
194	>	return(1);
195
196		if (m->oargs.nfargs != (m->otype == MAT_TRANS2 ? 8 : 6))
197		objerror(m, USER, "bad number of real arguments");
#	Line 174 | Line 205 | register RAY  *r;
205		nd.specfl = 0;
206		nd.u_alpha = m->oargs.farg[4];
207		nd.v_alpha = m->oargs.farg[5];
208	<	if (nd.u_alpha <= FTINY || nd.v_alpha <= FTINY)
209	<	nd.specfl |= SP_PURE;
210	<	/* reorient if necessary */
211	<	if (r->rod < 0.0)
212	<	flipsurface(r);
208	>	if (nd.u_alpha < FTINY || nd.v_alpha <= FTINY)
209	>	objerror(m, USER, "roughness too small");
210	>	/* check for back side */
211	>	if (r->rod < 0.0) {
212	>	if (!backvis && m->otype != MAT_TRANS2) {
213	>	raytrans(r);
214	>	return(1);
215	>	}
216	>	flipsurface(r);                 /* reorient if backvis */
217	>	}
218		/* get modifiers */
219		raytexture(r, m->omod);
220		nd.pdot = raynormal(nd.pnorm, r);       /* perturb normal */
221		if (nd.pdot < .001)
222		nd.pdot = .001;                 /* non-zero for diraniso() */
223		multcolor(nd.mcolor, r->pcol);          /* modify material color */
188	–	transtest = 0;
224		/* get specular component */
225		if ((nd.rspec = m->oargs.farg[3]) > FTINY) {
226		nd.specfl |= SP_REFL;
#	Line 195 | Line 230 | register RAY  *r;
230		else
231		setcolor(nd.scolor, 1.0, 1.0, 1.0);
232		scalecolor(nd.scolor, nd.rspec);
233	<	/* improved model */
234	<	dtmp = exp(-BSPEC(m)*nd.pdot);
233	>	/* check threshold */
234	>	if (specthresh >= nd.rspec-FTINY)
235	>	nd.specfl |= SP_RBLT;
236	>	/* compute refl. direction */
237		for (i = 0; i < 3; i++)
238	<	colval(nd.scolor,i) += (1.0-colval(nd.scolor,i))*dtmp;
239	<	nd.rspec += (1.0-nd.rspec)*dtmp;
240	<
241	<	if (!(r->crtype & SHADOW) && nd.specfl & SP_PURE) {
205	<	RAY  lr;
206	<	if (rayorigin(&lr, r, REFLECTED, nd.rspec) == 0) {
207	<	for (i = 0; i < 3; i++)
208	<	lr.rdir[i] = r->rdir[i] +
209	<	2.0*nd.pdot*nd.pnorm[i];
210	<	rayvalue(&lr);
211	<	multcolor(lr.rcol, nd.scolor);
212	<	addcolor(r->rcol, lr.rcol);
213	<	}
214	<	}
238	>	nd.vrefl[i] = r->rdir[i] + 2.0*nd.pdot*nd.pnorm[i];
239	>	if (DOT(nd.vrefl, r->ron) <= FTINY)     /* penetration? */
240	>	for (i = 0; i < 3; i++)         /* safety measure */
241	>	nd.vrefl[i] = r->rdir[i] + 2.*r->rod*r->ron[i];
242		}
243		/* compute transmission */
244	<	if (m->otype == MAT_TRANS) {
244	>	if (m->otype == MAT_TRANS2) {
245		nd.trans = m->oargs.farg[6]*(1.0 - nd.rspec);
246		nd.tspec = nd.trans * m->oargs.farg[7];
247		nd.tdiff = nd.trans - nd.tspec;
248		if (nd.tspec > FTINY) {
249		nd.specfl |= SP_TRAN;
250	<	if (r->crtype & SHADOW ||
251	<	DOT(r->pert,r->pert) <= FTINY*FTINY) {
250	>	/* check threshold */
251	>	if (specthresh >= nd.tspec-FTINY)
252	>	nd.specfl |= SP_TBLT;
253	>	if (DOT(r->pert,r->pert) <= FTINY*FTINY) {
254		VCOPY(nd.prdir, r->rdir);
226	–	transtest = 2;
255		} else {
256		for (i = 0; i < 3; i++)         /* perturb */
257	<	nd.prdir[i] = r->rdir[i] -
258	<	.75*r->pert[i];
259	<	normalize(nd.prdir);
257	>	nd.prdir[i] = r->rdir[i] - r->pert[i];
258	>	if (DOT(nd.prdir, r->ron) < -FTINY)
259	>	normalize(nd.prdir);    /* OK */
260	>	else
261	>	VCOPY(nd.prdir, r->rdir);
262		}
263		}
264		} else
265		nd.tdiff = nd.tspec = nd.trans = 0.0;
236	–	/* transmitted ray */
237	–	if ((nd.specfl&(SP_TRAN|SP_PURE)) == (SP_TRAN|SP_PURE)) {
238	–	RAY  lr;
239	–	if (rayorigin(&lr, r, TRANS, nd.tspec) == 0) {
240	–	VCOPY(lr.rdir, nd.prdir);
241	–	rayvalue(&lr);
242	–	scalecolor(lr.rcol, nd.tspec);
243	–	multcolor(lr.rcol, nd.mcolor);  /* modified by color */
244	–	addcolor(r->rcol, lr.rcol);
245	–	transtest *= bright(lr.rcol);
246	–	transdist = r->rot + lr.rt;
247	–	}
248	–	}
266
250	–	if (r->crtype & SHADOW)                 /* the rest is shadow */
251	–	return;
267		/* diffuse reflection */
268		nd.rdiff = 1.0 - nd.trans - nd.rspec;
269
270	<	if (nd.specfl & SP_PURE && nd.rdiff <= FTINY && nd.tdiff <= FTINY)
271	<	return;                         /* 100% pure specular */
270	>	if (r->ro != NULL && isflat(r->ro->otype))
271	>	nd.specfl |= SP_FLAT;
272
273		getacoords(r, &nd);                     /* set up coordinates */
274
275	<	if (nd.specfl & (SP_REFL|SP_TRAN) && !(nd.specfl & (SP_PURE|SP_BADU)))
275	>	if (nd.specfl & (SP_REFL|SP_TRAN) && !(nd.specfl & SP_BADU))
276		agaussamp(r, &nd);
277
278		if (nd.rdiff > FTINY) {         /* ambient from this side */
279	<	ambient(ctmp, r);
280	<	scalecolor(ctmp, nd.rdiff);
279	>	ambient(ctmp, r, nd.pnorm);
280	>	if (nd.specfl & SP_RBLT)
281	>	scalecolor(ctmp, 1.0-nd.trans);
282	>	else
283	>	scalecolor(ctmp, nd.rdiff);
284		multcolor(ctmp, nd.mcolor);     /* modified by material color */
285		addcolor(r->rcol, ctmp);        /* add to returned color */
286		}
287		if (nd.tdiff > FTINY) {         /* ambient from other side */
288	+	FVECT  bnorm;
289	+
290		flipsurface(r);
291	<	ambient(ctmp, r);
292	<	scalecolor(ctmp, nd.tdiff);
291	>	bnorm[0] = -nd.pnorm[0];
292	>	bnorm[1] = -nd.pnorm[1];
293	>	bnorm[2] = -nd.pnorm[2];
294	>	ambient(ctmp, r, bnorm);
295	>	if (nd.specfl & SP_TBLT)
296	>	scalecolor(ctmp, nd.trans);
297	>	else
298	>	scalecolor(ctmp, nd.tdiff);
299		multcolor(ctmp, nd.mcolor);     /* modified by color */
300		addcolor(r->rcol, ctmp);
301		flipsurface(r);
302		}
303		/* add direct component */
304		direct(r, diraniso, &nd);
305	<	/* check distance */
306	<	if (transtest > bright(r->rcol))
281	<	r->rt = transdist;
305	>
306	>	return(1);
307		}
308
309
#	Line 300 | Line 325 | register ANISODAT  *np;
325		np->specfl |= SP_BADU;
326		return;
327		}
328	<	multv3(np->u, np->u, mf->f->xfm);
328	>	if (mf->f != &unitxf)
329	>	multv3(np->u, np->u, mf->f->xfm);
330		fcross(np->v, np->pnorm, np->u);
331		if (normalize(np->v) == 0.0) {
332		objerror(np->mp, WARNING, "illegal orientation vector");
#	Line 320 | Line 346 | register ANISODAT  *np;
346		FVECT  h;
347		double  rv[2];
348		double  d, sinp, cosp;
349	<	int  ntries;
349	>	int  niter;
350		register int  i;
351		/* compute reflection */
352	<	if (np->specfl & SP_REFL &&
352	>	if ((np->specfl & (SP_REFL|SP_RBLT)) == SP_REFL &&
353		rayorigin(&sr, r, SPECULAR, np->rspec) == 0) {
354		dimlist[ndims++] = (int)np->mp;
355	<	for (ntries = 0; ntries < 10; ntries++) {
356	<	dimlist[ndims] = ntries * 3601;
357	<	d = urand(ilhash(dimlist,ndims+1)+samplendx);
355	>	for (niter = 0; niter < MAXITER; niter++) {
356	>	if (niter)
357	>	d = frandom();
358	>	else
359	>	d = urand(ilhash(dimlist,ndims)+samplendx);
360		multisamp(rv, 2, d);
361		d = 2.0*PI * rv[0];
362	<	cosp = np->u_alpha * cos(d);
363	<	sinp = np->v_alpha * sin(d);
362	>	cosp = tcos(d) * np->u_alpha;
363	>	sinp = tsin(d) * np->v_alpha;
364		d = sqrt(cosp*cosp + sinp*sinp);
365		cosp /= d;
366		sinp /= d;
367	+	rv[1] = 1.0 - specjitter*rv[1];
368		if (rv[1] <= FTINY)
369		d = 1.0;
370		else
#	Line 358 | Line 387 | register ANISODAT  *np;
387		ndims--;
388		}
389		/* compute transmission */
390	+	if ((np->specfl & (SP_TRAN|SP_TBLT)) == SP_TRAN &&
391	+	rayorigin(&sr, r, SPECULAR, np->tspec) == 0) {
392	+	dimlist[ndims++] = (int)np->mp;
393	+	for (niter = 0; niter < MAXITER; niter++) {
394	+	if (niter)
395	+	d = frandom();
396	+	else
397	+	d = urand(ilhash(dimlist,ndims)+1823+samplendx);
398	+	multisamp(rv, 2, d);
399	+	d = 2.0*PI * rv[0];
400	+	cosp = tcos(d) * np->u_alpha;
401	+	sinp = tsin(d) * np->v_alpha;
402	+	d = sqrt(cosp*cosp + sinp*sinp);
403	+	cosp /= d;
404	+	sinp /= d;
405	+	rv[1] = 1.0 - specjitter*rv[1];
406	+	if (rv[1] <= FTINY)
407	+	d = 1.0;
408	+	else
409	+	d = sqrt(-log(rv[1]) /
410	+	(cosp*cosp/(np->u_alpha*np->u_alpha) +
411	+	sinp*sinp/(np->v_alpha*np->v_alpha)));
412	+	for (i = 0; i < 3; i++)
413	+	sr.rdir[i] = np->prdir[i] +
414	+	d*(cosp*np->u[i] + sinp*np->v[i]);
415	+	if (DOT(sr.rdir, r->ron) < -FTINY) {
416	+	normalize(sr.rdir);     /* OK, normalize */
417	+	rayvalue(&sr);
418	+	scalecolor(sr.rcol, np->tspec);
419	+	multcolor(sr.rcol, np->mcolor); /* modify */
420	+	addcolor(r->rcol, sr.rcol);
421	+	break;
422	+	}
423	+	}
424	+	ndims--;
425	+	}
426		}

Diff Legend

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