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.35 by greg, Tue Feb 25 02:47:22 2003 UTC vs.
Revision 2.46 by greg, Fri Oct 1 18:11:18 2010 UTC

#	Line 1 | Line 1
1		#ifndef lint
2	<	static const char       RCSid[] = "$Id$";
2	>	static const char RCSid[] = "$Id$";
3		#endif
4		/*
5		*  Shading functions for anisotropic materials.
#	Line 8 | Line 8 | static const char      RCSid[] = "$Id$";
8		#include "copyright.h"
9
10		#include  "ray.h"
11	<
11	>	#include  "ambient.h"
12		#include  "otypes.h"
13	<
13	>	#include  "rtotypes.h"
14	>	#include  "source.h"
15		#include  "func.h"
15	–
16		#include  "random.h"
17
18		#ifndef  MAXITER
#	Line 60 | Line 60 | typedef struct {
60		double  pdot;           /* perturbed dot product */
61		}  ANISODAT;            /* anisotropic material data */
62
63	<	static void     getacoords();
64	<	static void     agaussamp();
63	>	static srcdirf_t diraniso;
64	>	static void getacoords(RAY  *r, ANISODAT  *np);
65	>	static void agaussamp(RAY  *r, ANISODAT  *np);
66
67
68		static void
69	<	diraniso(cval, np, ldir, omega)         /* compute source contribution */
70	<	COLOR  cval;                    /* returned coefficient */
71	<	register ANISODAT  *np;         /* material data */
72	<	FVECT  ldir;                    /* light source direction */
73	<	double  omega;                  /* light source size */
69	>	diraniso(               /* compute source contribution */
70	>	COLOR  cval,                    /* returned coefficient */
71	>	void  *nnp,             /* material data */
72	>	FVECT  ldir,                    /* light source direction */
73	>	double  omega                   /* light source size */
74	>	)
75		{
76	+	register ANISODAT *np = nnp;
77		double  ldot;
78		double  dtmp, dtmp1, dtmp2;
79		FVECT  h;
#	Line 91 | Line 94 | double  omega;                 /* light source size */
94		*  modified by the color of the material.
95		*/
96		copycolor(ctmp, np->mcolor);
97	<	dtmp = ldot * omega * np->rdiff / PI;
97	>	dtmp = ldot * omega * np->rdiff * (1.0/PI);
98		scalecolor(ctmp, dtmp);
99		addcolor(cval, ctmp);
100		}
101		if (ldot > FTINY && (np->specfl&(SP_REFL|SP_BADU)) == SP_REFL) {
102		/*
103		*  Compute specular reflection coefficient using
104	<	*  anisotropic gaussian distribution model.
104	>	*  anisotropic Gaussian distribution model.
105		*/
106		/* add source width if flat */
107		if (np->specfl & SP_FLAT)
108	<	au2 = av2 = omega/(4.0*PI);
108	>	au2 = av2 = omega * (0.25/PI);
109		else
110		au2 = av2 = 0.0;
111		au2 += np->u_alpha*np->u_alpha;
#	Line 116 | Line 119 | double  omega;                 /* light source size */
119		dtmp1 *= dtmp1 / au2;
120		dtmp2 = DOT(np->v, h);
121		dtmp2 *= dtmp2 / av2;
122	<	/* gaussian */
122	>	/* new W-G-M-D model */
123		dtmp = DOT(np->pnorm, h);
124	<	dtmp = (dtmp1 + dtmp2) / (dtmp*dtmp);
125	<	dtmp = exp(-dtmp) * (0.25/PI)
126	<	* sqrt(ldot/(np->pdot*au2*av2));
124	>	dtmp *= dtmp;
125	>	dtmp1 = (dtmp1 + dtmp2) / dtmp;
126	>	dtmp = exp(-dtmp1) * DOT(h,h) /
127	>	(PI * dtmp*dtmp * sqrt(au2*av2));
128		/* worth using? */
129		if (dtmp > FTINY) {
130		copycolor(ctmp, np->scolor);
131	<	dtmp *= omega;
131	>	dtmp *= ldot * omega;
132		scalecolor(ctmp, dtmp);
133		addcolor(cval, ctmp);
134		}
#	Line 134 | Line 138 | double  omega;                 /* light source size */
138		*  Compute diffuse transmission.
139		*/
140		copycolor(ctmp, np->mcolor);
141	<	dtmp = -ldot * omega * np->tdiff / PI;
141	>	dtmp = -ldot * omega * np->tdiff * (1.0/PI);
142		scalecolor(ctmp, dtmp);
143		addcolor(cval, ctmp);
144		}
#	Line 144 | Line 148 | double  omega;                 /* light source size */
148		*  is always modified by material color.
149		*/
150		/* roughness + source */
151	<	au2 = av2 = omega / PI;
151	>	au2 = av2 = omega * (1.0/PI);
152		au2 += np->u_alpha*np->u_alpha;
153		av2 += np->v_alpha*np->v_alpha;
154		/* "half vector" */
#	Line 164 | Line 168 | double  omega;                 /* light source size */
168		}
169		} else
170		dtmp = 0.0;
171	<	/* gaussian */
172	<	dtmp = exp(-dtmp) * (1.0/PI)
169	<	* sqrt(-ldot/(np->pdot*au2*av2));
171	>	/* Gaussian */
172	>	dtmp = exp(-dtmp) * (1.0/PI) * sqrt(-ldot/(np->pdot*au2*av2));
173		/* worth using? */
174		if (dtmp > FTINY) {
175		copycolor(ctmp, np->mcolor);
#	Line 178 | Line 181 | double  omega;                 /* light source size */
181		}
182
183
184	<	int
185	<	m_aniso(m, r)                   /* shade ray that hit something anisotropic */
186	<	register OBJREC  *m;
187	<	register RAY  *r;
184	>	extern int
185	>	m_aniso(                        /* shade ray that hit something anisotropic */
186	>	register OBJREC  *m,
187	>	register RAY  *r
188	>	)
189		{
190		ANISODAT  nd;
191		COLOR  ctmp;
#	Line 192 | Line 196 | register RAY  *r;
196
197		if (m->oargs.nfargs != (m->otype == MAT_TRANS2 ? 8 : 6))
198		objerror(m, USER, "bad number of real arguments");
199	+	/* check for back side */
200	+	if (r->rod < 0.0) {
201	+	if (!backvis && m->otype != MAT_TRANS2) {
202	+	raytrans(r);
203	+	return(1);
204	+	}
205	+	raytexture(r, m->omod);
206	+	flipsurface(r);                 /* reorient if backvis */
207	+	} else
208	+	raytexture(r, m->omod);
209	+	/* get material color */
210		nd.mp = m;
211		nd.rp = r;
197	–	/* get material color */
212		setcolor(nd.mcolor, m->oargs.farg[0],
213		m->oargs.farg[1],
214		m->oargs.farg[2]);
#	Line 202 | Line 216 | register RAY  *r;
216		nd.specfl = 0;
217		nd.u_alpha = m->oargs.farg[4];
218		nd.v_alpha = m->oargs.farg[5];
219	<	if (nd.u_alpha < FTINY || nd.v_alpha <= FTINY)
219	>	if (nd.u_alpha <= FTINY || nd.v_alpha <= FTINY)
220		objerror(m, USER, "roughness too small");
221	<	/* check for back side */
208	<	if (r->rod < 0.0) {
209	<	if (!backvis && m->otype != MAT_TRANS2) {
210	<	raytrans(r);
211	<	return(1);
212	<	}
213	<	flipsurface(r);                 /* reorient if backvis */
214	<	}
215	<	/* get modifiers */
216	<	raytexture(r, m->omod);
221	>
222		nd.pdot = raynormal(nd.pnorm, r);       /* perturb normal */
223		if (nd.pdot < .001)
224		nd.pdot = .001;                 /* non-zero for diraniso() */
#	Line 273 | Line 278 | register RAY  *r;
278		agaussamp(r, &nd);
279
280		if (nd.rdiff > FTINY) {         /* ambient from this side */
281	<	ambient(ctmp, r, nd.pnorm);
281	>	copycolor(ctmp, nd.mcolor);     /* modified by material color */
282		if (nd.specfl & SP_RBLT)
283		scalecolor(ctmp, 1.0-nd.trans);
284		else
285		scalecolor(ctmp, nd.rdiff);
286	<	multcolor(ctmp, nd.mcolor);     /* modified by material color */
286	>	multambient(ctmp, r, nd.pnorm);
287		addcolor(r->rcol, ctmp);        /* add to returned color */
288		}
289		if (nd.tdiff > FTINY) {         /* ambient from other side */
#	Line 288 | Line 293 | register RAY  *r;
293		bnorm[0] = -nd.pnorm[0];
294		bnorm[1] = -nd.pnorm[1];
295		bnorm[2] = -nd.pnorm[2];
296	<	ambient(ctmp, r, bnorm);
296	>	copycolor(ctmp, nd.mcolor);     /* modified by color */
297		if (nd.specfl & SP_TBLT)
298		scalecolor(ctmp, nd.trans);
299		else
300		scalecolor(ctmp, nd.tdiff);
301	<	multcolor(ctmp, nd.mcolor);     /* modified by color */
301	>	multambient(ctmp, r, bnorm);
302		addcolor(r->rcol, ctmp);
303		flipsurface(r);
304		}
#	Line 305 | Line 310 | register RAY  *r;
310
311
312		static void
313	<	getacoords(r, np)               /* set up coordinate system */
314	<	RAY  *r;
315	<	register ANISODAT  *np;
313	>	getacoords(             /* set up coordinate system */
314	>	RAY  *r,
315	>	register ANISODAT  *np
316	>	)
317		{
318		register MFUNC  *mf;
319		register int  i;
#	Line 317 | Line 323 | register ANISODAT  *np;
323		errno = 0;
324		for (i = 0; i < 3; i++)
325		np->u[i] = evalue(mf->ep[i]);
326	<	if (errno) {
326	>	if (errno == EDOM || errno == ERANGE) {
327		objerror(np->mp, WARNING, "compute error");
328		np->specfl |= SP_BADU;
329		return;
#	Line 335 | Line 341 | register ANISODAT  *np;
341
342
343		static void
344	<	agaussamp(r, np)                /* sample anisotropic gaussian specular */
345	<	RAY  *r;
346	<	register ANISODAT  *np;
344	>	agaussamp(              /* sample anisotropic Gaussian specular */
345	>	RAY  *r,
346	>	register ANISODAT  *np
347	>	)
348		{
349		RAY  sr;
350		FVECT  h;
#	Line 347 | Line 354 | register ANISODAT  *np;
354		register int  i;
355		/* compute reflection */
356		if ((np->specfl & (SP_REFL|SP_RBLT)) == SP_REFL &&
357	<	rayorigin(&sr, r, SPECULAR, np->rspec) == 0) {
357	>	rayorigin(&sr, SPECULAR, r, np->scolor) == 0) {
358		dimlist[ndims++] = (int)np->mp;
359		for (niter = 0; niter < MAXITER; niter++) {
360		if (niter)
#	Line 375 | Line 382 | register ANISODAT  *np;
382		for (i = 0; i < 3; i++)
383		sr.rdir[i] = r->rdir[i] + d*h[i];
384		if (DOT(sr.rdir, r->ron) > FTINY) {
385	+	checknorm(sr.rdir);
386		rayvalue(&sr);
387	<	multcolor(sr.rcol, np->scolor);
387	>	multcolor(sr.rcol, sr.rcoef);
388		addcolor(r->rcol, sr.rcol);
389		break;
390		}
#	Line 384 | Line 392 | register ANISODAT  *np;
392		ndims--;
393		}
394		/* compute transmission */
395	+	copycolor(sr.rcoef, np->mcolor);                /* modify by material color */
396	+	scalecolor(sr.rcoef, np->tspec);
397		if ((np->specfl & (SP_TRAN|SP_TBLT)) == SP_TRAN &&
398	<	rayorigin(&sr, r, SPECULAR, np->tspec) == 0) {
398	>	rayorigin(&sr, SPECULAR, r, sr.rcoef) == 0) {
399		dimlist[ndims++] = (int)np->mp;
400		for (niter = 0; niter < MAXITER; niter++) {
401		if (niter)
#	Line 412 | Line 422 | register ANISODAT  *np;
422		if (DOT(sr.rdir, r->ron) < -FTINY) {
423		normalize(sr.rdir);     /* OK, normalize */
424		rayvalue(&sr);
425	<	scalecolor(sr.rcol, np->tspec);
416	<	multcolor(sr.rcol, np->mcolor); /* modify */
425	>	multcolor(sr.rcol, sr.rcoef);
426		addcolor(r->rcol, sr.rcol);
427		break;
428		}

Diff Legend

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