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.29 by greg, Fri Sep 15 15:47:30 1995 UTC vs.
Revision 2.47 by schorsch, Tue Mar 30 16:13:01 2004 UTC

#	Line 1 | Line 1
1	–	/* Copyright (c) 1992 Regents of the University of California */
2	–
1		#ifndef lint
2	<	static char SCCSid[] = "$SunId$ LBL";
2	>	static const char RCSid[] = "$Id$";
3		#endif
6	–
4		/*
5		*  normal.c - shading function for normal materials.
6		*
#	Line 14 | Line 11 | static char SCCSid[] = "$SunId$ LBL";
11		*     Later changes described in delta comments.
12		*/
13
14	<	#include  "ray.h"
14	>	#include "copyright.h"
15
16	+	#include  "ray.h"
17	+	#include  "ambient.h"
18	+	#include  "source.h"
19		#include  "otypes.h"
20	<
20	>	#include  "rtotypes.h"
21		#include  "random.h"
22
23	<	extern double  specthresh;              /* specular sampling threshold */
24	<	extern double  specjitter;              /* specular sampling jitter */
23	>	#ifndef  MAXITER
24	>	#define  MAXITER        10              /* maximum # specular ray attempts */
25	>	#endif
26	>	/* estimate of Fresnel function */
27	>	#define  FRESNE(ci)     (exp(-5.85*(ci)) - 0.00287989916)
28
26	–	extern int  backvis;                    /* back faces visible? */
29
28	–	static  gaussamp();
29	–
30		/*
31		*      This routine implements the isotropic Gaussian
32		*  model described by Ward in Siggraph `92 article.
#	Line 64 | Line 64 | typedef struct {
64		double  pdot;           /* perturbed dot product */
65		}  NORMDAT;             /* normal material data */
66
67	+	static srcdirf_t dirnorm;
68	+	static void gaussamp(RAY  *r, NORMDAT  *np);
69
70	<	dirnorm(cval, np, ldir, omega)          /* compute source contribution */
71	<	COLOR  cval;                    /* returned coefficient */
72	<	register NORMDAT  *np;          /* material data */
73	<	FVECT  ldir;                    /* light source direction */
74	<	double  omega;                  /* light source size */
70	>
71	>	static void
72	>	dirnorm(                /* compute source contribution */
73	>	COLOR  cval,                    /* returned coefficient */
74	>	void  *nnp,             /* material data */
75	>	FVECT  ldir,                    /* light source direction */
76	>	double  omega                   /* light source size */
77	>	)
78		{
79	+	register NORMDAT *np = nnp;
80		double  ldot;
81	+	double  ldiff;
82		double  dtmp, d2;
83		FVECT  vtmp;
84		COLOR  ctmp;
#	Line 83 | Line 90 | double  omega;                 /* light source size */
90		if (ldot < 0.0 ? np->trans <= FTINY : np->trans >= 1.0-FTINY)
91		return;         /* wrong side */
92
93	<	if (ldot > FTINY && np->rdiff > FTINY) {
93	>	/* Fresnel estimate */
94	>	ldiff = np->rdiff;
95	>	if (np->specfl & SP_PURE && (np->rspec > FTINY) & (ldiff > FTINY))
96	>	ldiff *= 1. - FRESNE(fabs(ldot));
97	>
98	>	if (ldot > FTINY && ldiff > FTINY) {
99		/*
100		*  Compute and add diffuse reflected component to returned
101		*  color.  The diffuse reflected component will always be
102		*  modified by the color of the material.
103		*/
104		copycolor(ctmp, np->mcolor);
105	<	dtmp = ldot * omega * np->rdiff / PI;
105	>	dtmp = ldot * omega * ldiff / PI;
106		scalecolor(ctmp, dtmp);
107		addcolor(cval, ctmp);
108		}
#	Line 150 | Line 162 | double  omega;                 /* light source size */
162		}
163
164
165	<	m_normal(m, r)                  /* color a ray that hit something normal */
166	<	register OBJREC  *m;
167	<	register RAY  *r;
165	>	extern int
166	>	m_normal(                       /* color a ray that hit something normal */
167	>	register OBJREC  *m,
168	>	register RAY  *r
169	>	)
170		{
171		NORMDAT  nd;
172	+	double  fest;
173		double  transtest, transdist;
174		double  mirtest, mirdist;
175		int     hastexture;
#	Line 173 | Line 188 | register RAY  *r;
188		raytrans(r);
189		return(1);
190		}
191	+	raytexture(r, m->omod);
192		flipsurface(r);                 /* reorient if backvis */
193	<	}
193	>	} else
194	>	raytexture(r, m->omod);
195		nd.mp = m;
196		nd.rp = r;
197		/* get material color */
#	Line 186 | Line 203 | register RAY  *r;
203		nd.alpha2 = m->oargs.farg[4];
204		if ((nd.alpha2 *= nd.alpha2) <= FTINY)
205		nd.specfl |= SP_PURE;
206	<	if (r->ro != NULL && isflat(r->ro->otype))
207	<	nd.specfl |= SP_FLAT;
191	<	/* get modifiers */
192	<	raytexture(r, m->omod);
193	<	if (hastexture = DOT(r->pert,r->pert) > FTINY*FTINY)
206	>
207	>	if ( (hastexture = (DOT(r->pert,r->pert) > FTINY*FTINY)) ) {
208		nd.pdot = raynormal(nd.pnorm, r);       /* perturb normal */
209	<	else {
209	>	} else {
210		VCOPY(nd.pnorm, r->ron);
211		nd.pdot = r->rod;
212		}
213	+	if (r->ro != NULL && isflat(r->ro->otype))
214	+	nd.specfl |= SP_FLAT;
215		if (nd.pdot < .001)
216		nd.pdot = .001;                 /* non-zero for dirnorm() */
217		multcolor(nd.mcolor, r->pcol);          /* modify material color */
218		mirtest = transtest = 0;
219		mirdist = transdist = r->rot;
220	<	/* get specular component */
221	<	if ((nd.rspec = m->oargs.farg[3]) > FTINY) {
222	<	nd.specfl |= SP_REFL;
223	<	/* compute specular color */
224	<	if (m->otype == MAT_METAL)
225	<	copycolor(nd.scolor, nd.mcolor);
226	<	else
211	<	setcolor(nd.scolor, 1.0, 1.0, 1.0);
212	<	scalecolor(nd.scolor, nd.rspec);
213	<	/* check threshold */
214	<	if (!(nd.specfl & SP_PURE) && specthresh >= nd.rspec-FTINY)
215	<	nd.specfl |= SP_RBLT;
216	<	/* compute reflected ray */
217	<	for (i = 0; i < 3; i++)
218	<	nd.vrefl[i] = r->rdir[i] + 2.*nd.pdot*nd.pnorm[i];
219	<	/* penetration? */
220	<	if (hastexture && DOT(nd.vrefl, r->ron) <= FTINY)
221	<	for (i = 0; i < 3; i++)         /* safety measure */
222	<	nd.vrefl[i] = r->rdir[i] + 2.*r->rod*r->ron[i];
223	<
224	<	if (!(r->crtype & SHADOW) && nd.specfl & SP_PURE) {
225	<	RAY  lr;
226	<	if (rayorigin(&lr, r, REFLECTED, nd.rspec) == 0) {
227	<	VCOPY(lr.rdir, nd.vrefl);
228	<	rayvalue(&lr);
229	<	multcolor(lr.rcol, nd.scolor);
230	<	addcolor(r->rcol, lr.rcol);
231	<	if (!hastexture && nd.specfl & SP_FLAT) {
232	<	mirtest = 2.*bright(lr.rcol);
233	<	mirdist = r->rot + lr.rt;
234	<	}
235	<	}
236	<	}
237	<	}
220	>	nd.rspec = m->oargs.farg[3];
221	>	/* compute Fresnel approx. */
222	>	if (nd.specfl & SP_PURE && nd.rspec > FTINY) {
223	>	fest = FRESNE(r->rod);
224	>	nd.rspec += fest*(1. - nd.rspec);
225	>	} else
226	>	fest = 0.;
227		/* compute transmission */
228		if (m->otype == MAT_TRANS) {
229		nd.trans = m->oargs.farg[5]*(1.0 - nd.rspec);
#	Line 261 | Line 250 | register RAY  *r;
250		} else
251		nd.tdiff = nd.tspec = nd.trans = 0.0;
252		/* transmitted ray */
253	<	if ((nd.specfl&(SP_TRAN|SP_PURE)) == (SP_TRAN|SP_PURE)) {
253	>	if ((nd.specfl&(SP_TRAN|SP_PURE|SP_TBLT)) == (SP_TRAN|SP_PURE)) {
254		RAY  lr;
255		if (rayorigin(&lr, r, TRANS, nd.tspec) == 0) {
256		VCOPY(lr.rdir, nd.prdir);
#	Line 279 | Line 268 | register RAY  *r;
268		r->rt = transdist;
269		return(1);
270		}
271	+	/* get specular reflection */
272	+	if (nd.rspec > FTINY) {
273	+	nd.specfl |= SP_REFL;
274	+	/* compute specular color */
275	+	if (m->otype != MAT_METAL) {
276	+	setcolor(nd.scolor, nd.rspec, nd.rspec, nd.rspec);
277	+	} else if (fest > FTINY) {
278	+	d = nd.rspec*(1. - fest);
279	+	for (i = 0; i < 3; i++)
280	+	nd.scolor[i] = fest + nd.mcolor[i]*d;
281	+	} else {
282	+	copycolor(nd.scolor, nd.mcolor);
283	+	scalecolor(nd.scolor, nd.rspec);
284	+	}
285	+	/* check threshold */
286	+	if (!(nd.specfl & SP_PURE) && specthresh >= nd.rspec-FTINY)
287	+	nd.specfl |= SP_RBLT;
288	+	/* compute reflected ray */
289	+	for (i = 0; i < 3; i++)
290	+	nd.vrefl[i] = r->rdir[i] + 2.*nd.pdot*nd.pnorm[i];
291	+	/* penetration? */
292	+	if (hastexture && DOT(nd.vrefl, r->ron) <= FTINY)
293	+	for (i = 0; i < 3; i++)         /* safety measure */
294	+	nd.vrefl[i] = r->rdir[i] + 2.*r->rod*r->ron[i];
295	+	}
296	+	/* reflected ray */
297	+	if ((nd.specfl&(SP_REFL|SP_PURE|SP_RBLT)) == (SP_REFL|SP_PURE)) {
298	+	RAY  lr;
299	+	if (rayorigin(&lr, r, REFLECTED, nd.rspec) == 0) {
300	+	VCOPY(lr.rdir, nd.vrefl);
301	+	rayvalue(&lr);
302	+	multcolor(lr.rcol, nd.scolor);
303	+	addcolor(r->rcol, lr.rcol);
304	+	if (!hastexture && nd.specfl & SP_FLAT) {
305	+	mirtest = 2.*bright(lr.rcol);
306	+	mirdist = r->rot + lr.rt;
307	+	}
308	+	}
309	+	}
310		/* diffuse reflection */
311		nd.rdiff = 1.0 - nd.trans - nd.rspec;
312
313		if (nd.specfl & SP_PURE && nd.rdiff <= FTINY && nd.tdiff <= FTINY)
314		return(1);                      /* 100% pure specular */
315
316	<	if (nd.specfl & (SP_REFL|SP_TRAN) && !(nd.specfl & SP_PURE))
317	<	gaussamp(r, &nd);
316	>	if (!(nd.specfl & SP_PURE))
317	>	gaussamp(r, &nd);               /* checks *BLT flags */
318
319		if (nd.rdiff > FTINY) {         /* ambient from this side */
320	<	ambient(ctmp, r);
320	>	ambient(ctmp, r, hastexture?nd.pnorm:r->ron);
321		if (nd.specfl & SP_RBLT)
322		scalecolor(ctmp, 1.0-nd.trans);
323		else
#	Line 299 | Line 327 | register RAY  *r;
327		}
328		if (nd.tdiff > FTINY) {         /* ambient from other side */
329		flipsurface(r);
330	<	ambient(ctmp, r);
330	>	if (hastexture) {
331	>	FVECT  bnorm;
332	>	bnorm[0] = -nd.pnorm[0];
333	>	bnorm[1] = -nd.pnorm[1];
334	>	bnorm[2] = -nd.pnorm[2];
335	>	ambient(ctmp, r, bnorm);
336	>	} else
337	>	ambient(ctmp, r, r->ron);
338		if (nd.specfl & SP_TBLT)
339		scalecolor(ctmp, nd.trans);
340		else
#	Line 321 | Line 356 | register RAY  *r;
356		}
357
358
359	<	static
360	<	gaussamp(r, np)                 /* sample gaussian specular */
361	<	RAY  *r;
362	<	register NORMDAT  *np;
359	>	static void
360	>	gaussamp(                       /* sample gaussian specular */
361	>	RAY  *r,
362	>	register NORMDAT  *np
363	>	)
364		{
365		RAY  sr;
366		FVECT  u, v, h;
367		double  rv[2];
368		double  d, sinp, cosp;
369	+	int  niter;
370		register int  i;
371		/* quick test */
372		if ((np->specfl & (SP_REFL|SP_RBLT)) != SP_REFL &&
#	Line 348 | Line 385 | register NORMDAT  *np;
385		if ((np->specfl & (SP_REFL|SP_RBLT)) == SP_REFL &&
386		rayorigin(&sr, r, SPECULAR, np->rspec) == 0) {
387		dimlist[ndims++] = (int)np->mp;
388	<	d = urand(ilhash(dimlist,ndims)+samplendx);
389	<	multisamp(rv, 2, d);
390	<	d = 2.0*PI * rv[0];
391	<	cosp = cos(d);
392	<	sinp = sin(d);
393	<	rv[1] = 1.0 - specjitter*rv[1];
394	<	if (rv[1] <= FTINY)
395	<	d = 1.0;
396	<	else
397	<	d = sqrt( np->alpha2 * -log(rv[1]) );
398	<	for (i = 0; i < 3; i++)
399	<	h[i] = np->pnorm[i] + d*(cosp*u[i] + sinp*v[i]);
400	<	d = -2.0 * DOT(h, r->rdir) / (1.0 + d*d);
401	<	for (i = 0; i < 3; i++)
402	<	sr.rdir[i] = r->rdir[i] + d*h[i];
403	<	if (DOT(sr.rdir, r->ron) <= FTINY)
404	<	VCOPY(sr.rdir, np->vrefl);      /* jitter no good */
405	<	rayvalue(&sr);
406	<	multcolor(sr.rcol, np->scolor);
407	<	addcolor(r->rcol, sr.rcol);
388	>	for (niter = 0; niter < MAXITER; niter++) {
389	>	if (niter)
390	>	d = frandom();
391	>	else
392	>	d = urand(ilhash(dimlist,ndims)+samplendx);
393	>	multisamp(rv, 2, d);
394	>	d = 2.0*PI * rv[0];
395	>	cosp = tcos(d);
396	>	sinp = tsin(d);
397	>	rv[1] = 1.0 - specjitter*rv[1];
398	>	if (rv[1] <= FTINY)
399	>	d = 1.0;
400	>	else
401	>	d = sqrt( np->alpha2 * -log(rv[1]) );
402	>	for (i = 0; i < 3; i++)
403	>	h[i] = np->pnorm[i] + d*(cosp*u[i] + sinp*v[i]);
404	>	d = -2.0 * DOT(h, r->rdir) / (1.0 + d*d);
405	>	for (i = 0; i < 3; i++)
406	>	sr.rdir[i] = r->rdir[i] + d*h[i];
407	>	if (DOT(sr.rdir, r->ron) > FTINY) {
408	>	rayvalue(&sr);
409	>	multcolor(sr.rcol, np->scolor);
410	>	addcolor(r->rcol, sr.rcol);
411	>	break;
412	>	}
413	>	}
414		ndims--;
415		}
416		/* compute transmission */
417		if ((np->specfl & (SP_TRAN|SP_TBLT)) == SP_TRAN &&
418		rayorigin(&sr, r, SPECULAR, np->tspec) == 0) {
419		dimlist[ndims++] = (int)np->mp;
420	<	d = urand(ilhash(dimlist,ndims)+1823+samplendx);
421	<	multisamp(rv, 2, d);
422	<	d = 2.0*PI * rv[0];
423	<	cosp = cos(d);
424	<	sinp = sin(d);
425	<	rv[1] = 1.0 - specjitter*rv[1];
426	<	if (rv[1] <= FTINY)
427	<	d = 1.0;
428	<	else
429	<	d = sqrt( -log(rv[1]) * np->alpha2 );
430	<	for (i = 0; i < 3; i++)
431	<	sr.rdir[i] = np->prdir[i] + d*(cosp*u[i] + sinp*v[i]);
432	<	if (DOT(sr.rdir, r->ron) < -FTINY)
433	<	normalize(sr.rdir);             /* OK, normalize */
434	<	else
435	<	VCOPY(sr.rdir, np->prdir);      /* else no jitter */
436	<	rayvalue(&sr);
437	<	scalecolor(sr.rcol, np->tspec);
438	<	multcolor(sr.rcol, np->mcolor);         /* modified by color */
439	<	addcolor(r->rcol, sr.rcol);
420	>	for (niter = 0; niter < MAXITER; niter++) {
421	>	if (niter)
422	>	d = frandom();
423	>	else
424	>	d = urand(ilhash(dimlist,ndims)+1823+samplendx);
425	>	multisamp(rv, 2, d);
426	>	d = 2.0*PI * rv[0];
427	>	cosp = tcos(d);
428	>	sinp = tsin(d);
429	>	rv[1] = 1.0 - specjitter*rv[1];
430	>	if (rv[1] <= FTINY)
431	>	d = 1.0;
432	>	else
433	>	d = sqrt( np->alpha2 * -log(rv[1]) );
434	>	for (i = 0; i < 3; i++)
435	>	sr.rdir[i] = np->prdir[i] + d*(cosp*u[i] + sinp*v[i]);
436	>	if (DOT(sr.rdir, r->ron) < -FTINY) {
437	>	normalize(sr.rdir);     /* OK, normalize */
438	>	rayvalue(&sr);
439	>	scalecolor(sr.rcol, np->tspec);
440	>	multcolor(sr.rcol, np->mcolor); /* modified */
441	>	addcolor(r->rcol, sr.rcol);
442	>	break;
443	>	}
444	>	}
445		ndims--;
446		}
447		}

Diff Legend

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