src/rt/m_brdf.c

/* Copyright (c) 1991 Regents of the University of California */

#ifndef lint
static char SCCSid[] = "$SunId$ LBL";
#endif

/*
 *  Shading for materials with arbitrary BRDF's
 */

#include  "ray.h"

#include  "data.h"

#include  "otypes.h"

#include  "func.h"

/*
 *      Arguments to this material include the color and specularity.
 *  String arguments include the reflection function and files.
 *  The BRDF is currently used just for the specular component to light
 *  sources.  Reflectance values or data coordinates are functions
 *  of the direction to the light source.
 *      We orient the surface towards the incoming ray, so a single
 *  surface can be used to represent an infinitely thin object.
 *
 *  Arguments for MAT_PFUNC and MAT_MFUNC are:
 *      2+      func    funcfile        transform
 *      0
 *      4+      red     grn     blu     specularity     A5 ..
 *
 *  Arguments for MAT_PDATA and MAT_MDATA are:
 *      4+      func    datafile        funcfile        v0 ..   transform
 *      0
 *      4+      red     grn     blu     specularity     A5 ..
 *
 *  Arguments for MAT_TFUNC are:
 *      2+      func    funcfile        transform
 *      0
 *      4+      red     grn     blu     rspec   trans   tspec   A7 ..
 *
 *  Arguments for MAT_TDATA are:
 *      4+      func    datafile        funcfile        v0 ..   transform
 *      0
 *      4+      red     grn     blu     rspec   trans   tspec   A7 ..
 *
 *  Arguments for the more general MAT_BRTDF are:
 *      10+     rrefl   grefl   brefl
 *              rtrns   gtrns   btrns
 *              rbrtd   gbrtd   bbrtd
 *              funcfile        transform
 *      0
 *      6+      red     grn     blu     rspec   trans   tspec   A7 ..
 *
 *      In addition to the normal variables available to functions,
 *  we define the following:
 *              NxP, NyP, NzP -         perturbed surface normal
 *              RdotP -                 perturbed ray dot product
 *              CrP, CgP, CbP -         perturbed material color
 */

typedef struct {
        OBJREC  *mp;            /* material pointer */
        RAY  *pr;               /* intersected ray */
        DATARRAY  *dp;          /* data array for PDATA, MDATA or TDATA */
        COLOR  mcolor;          /* color of this material */
        double  rspec;          /* specular reflection */
        double  rdiff;          /* diffuse reflection */
        double  trans;          /* transmissivity */
        double  tspec;          /* specular transmission */
        double  tdiff;          /* diffuse transmission */
        FVECT  pnorm;           /* perturbed surface normal */
        double  pdot;           /* perturbed dot product */
}  BRDFDAT;             /* BRDF material data */


dirbrdf(cval, np, ldir, omega)          /* compute source contribution */
COLOR  cval;                    /* returned coefficient */
register BRDFDAT  *np;          /* material data */
FVECT  ldir;                    /* light source direction */
double  omega;                  /* light source size */
{
        double  ldot;
        double  dtmp;
        COLOR  ctmp;
        FVECT  ldx;
        double  lddx[3], pt[MAXDIM];
        register char   **sa;
        register int    i;

        setcolor(cval, 0.0, 0.0, 0.0);
        
        ldot = DOT(np->pnorm, ldir);

        if (ldot <= FTINY && ldot >= -FTINY)
                return;         /* too close to grazing */
        if (ldot < 0.0 ? np->trans <= FTINY : np->trans >= 1.0-FTINY)
                return;         /* wrong side */

        if (ldot > 0.0 && np->rdiff > FTINY) {
                /*
                 *  Compute and add diffuse reflected component to returned
                 *  color.  The diffuse reflected component will always be
                 *  modified by the color of the material.
                 */
                copycolor(ctmp, np->mcolor);
                dtmp = ldot * omega * np->rdiff / PI;
                scalecolor(ctmp, dtmp);
                addcolor(cval, ctmp);
        }
        if (ldot < 0.0 && np->tdiff > FTINY) {
                /*
                 *  Diffuse transmitted component.
                 */
                copycolor(ctmp, np->mcolor);
                dtmp = -ldot * omega * np->tdiff / PI;
                scalecolor(ctmp, dtmp);
                addcolor(cval, ctmp);
        }
        if (ldot > 0.0 ? np->rspec <= FTINY : np->tspec <= FTINY)
                return;         /* no specular component */
                                        /* set up function */
        setbrdfunc(np);
        sa = np->mp->oargs.sarg;
        errno = 0;
                                        /* transform light vector */
        multv3(ldx, ldir, funcxf.xfm);
        for (i = 0; i < 3; i++)
                lddx[i] = ldx[i]/funcxf.sca;
                                        /* compute BRTDF */
        if (np->mp->otype == MAT_BRTDF) {
                colval(ctmp,RED) = funvalue(sa[6], 3, lddx);
                if (!strcmp(sa[7],sa[6]))
                        colval(ctmp,GRN) = colval(ctmp,RED);
                else
                        colval(ctmp,GRN) = funvalue(sa[7], 3, lddx);
                if (!strcmp(sa[8],sa[6]))
                        colval(ctmp,BLU) = colval(ctmp,RED);
                else if (!strcmp(sa[8],sa[7]))
                        colval(ctmp,BLU) = colval(ctmp,GRN);
                else
                        colval(ctmp,BLU) = funvalue(sa[8], 3, lddx);
                dtmp = bright(ctmp);
        } else if (np->dp == NULL) {
                dtmp = funvalue(sa[0], 3, lddx);
                setcolor(ctmp, dtmp, dtmp, dtmp);
        } else {
                for (i = 0; i < np->dp->nd; i++)
                        pt[i] = funvalue(sa[3+i], 3, lddx);
                dtmp = datavalue(np->dp, pt);
                dtmp = funvalue(sa[0], 1, &dtmp);
                setcolor(ctmp, dtmp, dtmp, dtmp);
        }
        if (errno) {
                objerror(np->mp, WARNING, "compute error");
                return;
        }
        if (dtmp <= FTINY)
                return;
        if (ldot > 0.0) {
                /*
                 *  Compute reflected non-diffuse component.
                 */
                if (np->mp->otype == MAT_MFUNC || np->mp->otype == MAT_MDATA)
                        multcolor(ctmp, np->mcolor);
                dtmp = ldot * omega * np->rspec;
                scalecolor(ctmp, dtmp);
                addcolor(cval, ctmp);
        } else {
                /*
                 *  Compute transmitted non-diffuse component.
                 */
                if (np->mp->otype == MAT_TFUNC || np->mp->otype == MAT_TDATA)
                        multcolor(ctmp, np->mcolor);
                dtmp = -ldot * omega * np->tspec;
                scalecolor(ctmp, dtmp);
                addcolor(cval, ctmp);
        }
}


m_brdf(m, r)                    /* color a ray which hit a BRDF material */
register OBJREC  *m;
register RAY  *r;
{
        int  minsa, minfa;
        BRDFDAT  nd;
        double  transtest, transdist;
        COLOR  ctmp;
        double  dtmp, tspect, rspecr;
        MFUNC  *mf;
        register int  i;
                                                /* check arguments */
        switch (m->otype) {
        case MAT_PFUNC: case MAT_MFUNC:
                minsa = 2; minfa = 4; break;
        case MAT_PDATA: case MAT_MDATA:
                minsa = 4; minfa = 4; break;
        case MAT_TFUNC:
                minsa = 2; minfa = 6; break;
        case MAT_TDATA:
                minsa = 4; minfa = 6; break;
        case MAT_BRTDF:
                minsa = 10; minfa = 6; break;
        }
        if (m->oargs.nsargs < minsa || m->oargs.nfargs < minfa)
                objerror(m, USER, "bad # arguments");
        nd.mp = m;
        nd.pr = r;
                                                /* get specular component */
        nd.rspec = m->oargs.farg[3];
                                                /* compute transmission */
        if (m->otype == MAT_TFUNC || m->otype == MAT_TDATA
                        || m->otype == MAT_BRTDF) {
                nd.trans = m->oargs.farg[4]*(1.0 - nd.rspec);
                nd.tspec = nd.trans * m->oargs.farg[5];
                nd.tdiff = nd.trans - nd.tspec;
        } else
                nd.tdiff = nd.tspec = nd.trans = 0.0;
                                                /* early shadow check */
        if (r->crtype & SHADOW && (m->otype != MAT_BRTDF || nd.tspec <= FTINY))
                return;
                                                /* diffuse reflection */
        nd.rdiff = 1.0 - nd.trans - nd.rspec;
                                                /* get material color */
        setcolor(nd.mcolor, m->oargs.farg[0],
                           m->oargs.farg[1],
                           m->oargs.farg[2]);
                                                /* fix orientation */
        if (r->rod < 0.0)
                flipsurface(r);
                                                /* get modifiers */
        raytexture(r, m->omod);
        nd.pdot = raynormal(nd.pnorm, r);       /* perturb normal */
        multcolor(nd.mcolor, r->pcol);          /* modify material color */
        transtest = 0;
                                                /* load auxiliary files */
        if (hasdata(m->otype)) {
                nd.dp = getdata(m->oargs.sarg[1]);
                i = (1 << nd.dp->nd) - 1;
                mf = getfunc(m, 2, i<<3, 0);
        } else if (m->otype == MAT_BRTDF) {
                nd.dp = NULL;
                mf = getfunc(m, 9, 0x3f, 0);
        } else {
                nd.dp = NULL;
                mf = getfunc(m, 1, 0, 0);
        }
                                                /* set special variables */
        setbrdfunc(&nd);
                                                /* compute transmitted ray */
        tspect = 0.;
        if (m->otype == MAT_BRTDF && nd.tspec > FTINY) {
                RAY  sr;
                errno = 0;
                setcolor(ctmp, evalue(mf->ep[3]),
                                evalue(mf->ep[4]),
                                evalue(mf->ep[5]));
                scalecolor(ctmp, nd.trans);
                if (errno)
                        objerror(m, WARNING, "compute error");
                else if ((tspect = bright(ctmp)) > FTINY &&
                                rayorigin(&sr, r, TRANS, tspect) == 0) {
                        if (!(r->crtype & SHADOW) &&
                                        DOT(r->pert,r->pert) > FTINY*FTINY) {
                                for (i = 0; i < 3; i++) /* perturb direction */
                                        sr.rdir[i] = r->rdir[i] -
                                                        .75*r->pert[i];
                                if (normalize(sr.rdir) == 0.0) {
                                        objerror(m, WARNING, "illegal perturbation");
                                        VCOPY(sr.rdir, r->rdir);
                                }
                        } else {
                                VCOPY(sr.rdir, r->rdir);
                                transtest = 2;
                        }
                        rayvalue(&sr);
                        multcolor(sr.rcol, ctmp);
                        addcolor(r->rcol, sr.rcol);
                        transtest *= bright(sr.rcol);
                        transdist = r->rot + sr.rt;
                }
        }
        if (r->crtype & SHADOW)                 /* the rest is shadow */
                return;
                                                /* compute reflected ray */
        rspecr = 0.;
        if (m->otype == MAT_BRTDF && nd.rspec > FTINY) {
                RAY  sr;
                errno = 0;
                setcolor(ctmp, evalue(mf->ep[0]),
                                evalue(mf->ep[1]),
                                evalue(mf->ep[2]));
                if (errno)
                        objerror(m, WARNING, "compute error");
                else if ((rspecr = bright(ctmp)) > FTINY &&
                                rayorigin(&sr, r, REFLECTED, rspecr) == 0) {
                        for (i = 0; i < 3; i++)
                                sr.rdir[i] = r->rdir[i] +
                                                2.0*nd.pdot*nd.pnorm[i];
                        rayvalue(&sr);
                        multcolor(sr.rcol, ctmp);
                        addcolor(r->rcol, sr.rcol);
                }
        }
                                                /* compute ambient */
        if ((dtmp = 1.0-nd.trans-rspecr) > FTINY) {
                ambient(ctmp, r);
                scalecolor(ctmp, dtmp);
                multcolor(ctmp, nd.mcolor);     /* modified by material color */
                addcolor(r->rcol, ctmp);        /* add to returned color */
        }
        if ((dtmp = nd.trans-tspect) > FTINY) { /* from other side */
                flipsurface(r);
                ambient(ctmp, r);
                scalecolor(ctmp, dtmp);
                multcolor(ctmp, nd.mcolor);
                addcolor(r->rcol, ctmp);
                flipsurface(r);
        }
                                                /* add direct component */
        direct(r, dirbrdf, &nd);
                                                /* check distance */
        if (transtest > bright(r->rcol))
                r->rt = transdist;
}


setbrdfunc(np)                  /* set up brdf function and variables */
register BRDFDAT  *np;
{
        FVECT  vec;

        if (setfunc(np->mp, np->pr) == 0)
                return(0);      /* it's OK, setfunc says we're done */
                                /* else (re)assign special variables */
        multv3(vec, np->pnorm, funcxf.xfm);
        varset("NxP", '=', vec[0]/funcxf.sca);
        varset("NyP", '=', vec[1]/funcxf.sca);
        varset("NzP", '=', vec[2]/funcxf.sca);
        varset("RdotP", '=', np->pdot <= -1.0 ? -1.0 :
                        np->pdot >= 1.0 ? 1.0 : np->pdot);
        varset("CrP", '=', colval(np->mcolor,RED));
        varset("CgP", '=', colval(np->mcolor,GRN));
        varset("CbP", '=', colval(np->mcolor,BLU));
        return(1);
}
Revision:	2.4
Committed:	Wed Oct 14 12:30:54 1992 UTC (33 years ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.3:	+4 -1 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	greg	1.7	/* Copyright (c) 1991 Regents of the University of California */
2	greg	1.1
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ LBL";
5			#endif
6
7			/*
8			* Shading for materials with arbitrary BRDF's
9			*/
10
11			#include "ray.h"
12
13			#include "data.h"
14
15			#include "otypes.h"
16
17	greg	2.2	#include "func.h"
18
19	greg	1.1	/*
20			* Arguments to this material include the color and specularity.
21			* String arguments include the reflection function and files.
22			* The BRDF is currently used just for the specular component to light
23			* sources. Reflectance values or data coordinates are functions
24			* of the direction to the light source.
25			* We orient the surface towards the incoming ray, so a single
26			* surface can be used to represent an infinitely thin object.
27			*
28			* Arguments for MAT_PFUNC and MAT_MFUNC are:
29	greg	1.4	* 2+ func funcfile transform
30	greg	1.1	* 0
31	greg	1.4	* 4+ red grn blu specularity A5 ..
32	greg	1.1	*
33			* Arguments for MAT_PDATA and MAT_MDATA are:
34	greg	1.4	* 4+ func datafile funcfile v0 .. transform
35	greg	1.1	* 0
36	greg	1.4	* 4+ red grn blu specularity A5 ..
37	greg	1.5	*
38			* Arguments for MAT_TFUNC are:
39			* 2+ func funcfile transform
40			* 0
41			* 4+ red grn blu rspec trans tspec A7 ..
42			*
43			* Arguments for MAT_TDATA are:
44			* 4+ func datafile funcfile v0 .. transform
45			* 0
46			* 4+ red grn blu rspec trans tspec A7 ..
47			*
48			* Arguments for the more general MAT_BRTDF are:
49			* 10+ rrefl grefl brefl
50			* rtrns gtrns btrns
51			* rbrtd gbrtd bbrtd
52			* funcfile transform
53			* 0
54			* 6+ red grn blu rspec trans tspec A7 ..
55			*
56			* In addition to the normal variables available to functions,
57			* we define the following:
58			* NxP, NyP, NzP - perturbed surface normal
59			* RdotP - perturbed ray dot product
60			* CrP, CgP, CbP - perturbed material color
61	greg	1.1	*/
62
63			typedef struct {
64			OBJREC mp; / material pointer */
65			RAY pr; / intersected ray */
66	greg	1.5	DATARRAY dp; / data array for PDATA, MDATA or TDATA */
67	greg	1.1	COLOR mcolor; /* color of this material */
68			double rspec; /* specular reflection */
69			double rdiff; /* diffuse reflection */
70	greg	1.5	double trans; /* transmissivity */
71			double tspec; /* specular transmission */
72			double tdiff; /* diffuse transmission */
73	greg	1.1	FVECT pnorm; /* perturbed surface normal */
74			double pdot; /* perturbed dot product */
75			} BRDFDAT; /* BRDF material data */
76
77
78			dirbrdf(cval, np, ldir, omega) /* compute source contribution */
79			COLOR cval; /* returned coefficient */
80			register BRDFDAT np; / material data */
81			FVECT ldir; /* light source direction */
82			double omega; /* light source size */
83			{
84			double ldot;
85			double dtmp;
86			COLOR ctmp;
87	greg	1.4	FVECT ldx;
88	greg	2.3	double lddx[3], pt[MAXDIM];
89	greg	1.5	register char **sa;
90	greg	1.1	register int i;
91
92			setcolor(cval, 0.0, 0.0, 0.0);
93
94			ldot = DOT(np->pnorm, ldir);
95
96	greg	1.5	if (ldot <= FTINY && ldot >= -FTINY)
97			return; /* too close to grazing */
98			if (ldot < 0.0 ? np->trans <= FTINY : np->trans >= 1.0-FTINY)
99	greg	1.1	return; /* wrong side */
100
101	greg	1.5	if (ldot > 0.0 && np->rdiff > FTINY) {
102	greg	1.1	/*
103			* Compute and add diffuse reflected component to returned
104			* color. The diffuse reflected component will always be
105			* modified by the color of the material.
106			*/
107			copycolor(ctmp, np->mcolor);
108			dtmp = ldot * omega * np->rdiff / PI;
109			scalecolor(ctmp, dtmp);
110			addcolor(cval, ctmp);
111			}
112	greg	1.5	if (ldot < 0.0 && np->tdiff > FTINY) {
113	greg	1.1	/*
114	greg	1.5	* Diffuse transmitted component.
115	greg	1.1	*/
116	greg	1.5	copycolor(ctmp, np->mcolor);
117			dtmp = -ldot * omega * np->tdiff / PI;
118			scalecolor(ctmp, dtmp);
119			addcolor(cval, ctmp);
120	greg	1.1	}
121	greg	1.5	if (ldot > 0.0 ? np->rspec <= FTINY : np->tspec <= FTINY)
122			return; /* no specular component */
123			/* set up function */
124	greg	1.10	setbrdfunc(np);
125	greg	1.5	sa = np->mp->oargs.sarg;
126			errno = 0;
127			/* transform light vector */
128			multv3(ldx, ldir, funcxf.xfm);
129			for (i = 0; i < 3; i++)
130	greg	2.3	lddx[i] = ldx[i]/funcxf.sca;
131	greg	1.5	/* compute BRTDF */
132			if (np->mp->otype == MAT_BRTDF) {
133	greg	2.3	colval(ctmp,RED) = funvalue(sa[6], 3, lddx);
134	greg	1.7	if (!strcmp(sa[7],sa[6]))
135	greg	1.5	colval(ctmp,GRN) = colval(ctmp,RED);
136			else
137	greg	2.3	colval(ctmp,GRN) = funvalue(sa[7], 3, lddx);
138	greg	1.7	if (!strcmp(sa[8],sa[6]))
139	greg	1.5	colval(ctmp,BLU) = colval(ctmp,RED);
140	greg	1.7	else if (!strcmp(sa[8],sa[7]))
141	greg	1.5	colval(ctmp,BLU) = colval(ctmp,GRN);
142			else
143	greg	2.3	colval(ctmp,BLU) = funvalue(sa[8], 3, lddx);
144	greg	1.5	dtmp = bright(ctmp);
145			} else if (np->dp == NULL) {
146	greg	2.3	dtmp = funvalue(sa[0], 3, lddx);
147	greg	1.5	setcolor(ctmp, dtmp, dtmp, dtmp);
148			} else {
149			for (i = 0; i < np->dp->nd; i++)
150	greg	2.3	pt[i] = funvalue(sa[3+i], 3, lddx);
151	greg	1.5	dtmp = datavalue(np->dp, pt);
152			dtmp = funvalue(sa[0], 1, &dtmp);
153			setcolor(ctmp, dtmp, dtmp, dtmp);
154			}
155	greg	2.2	if (errno) {
156			objerror(np->mp, WARNING, "compute error");
157			return;
158			}
159	greg	1.5	if (dtmp <= FTINY)
160			return;
161			if (ldot > 0.0) {
162			/*
163			* Compute reflected non-diffuse component.
164			*/
165	greg	1.6	if (np->mp->otype == MAT_MFUNC \|\| np->mp->otype == MAT_MDATA)
166			multcolor(ctmp, np->mcolor);
167			dtmp = ldot * omega * np->rspec;
168	greg	1.5	scalecolor(ctmp, dtmp);
169			addcolor(cval, ctmp);
170			} else {
171			/*
172			* Compute transmitted non-diffuse component.
173			*/
174	greg	1.6	if (np->mp->otype == MAT_TFUNC \|\| np->mp->otype == MAT_TDATA)
175			multcolor(ctmp, np->mcolor);
176	greg	1.5	dtmp = -ldot * omega * np->tspec;
177			scalecolor(ctmp, dtmp);
178			addcolor(cval, ctmp);
179			}
180	greg	1.1	}
181
182
183			m_brdf(m, r) /* color a ray which hit a BRDF material */
184			register OBJREC *m;
185			register RAY *r;
186			{
187	greg	1.5	int minsa, minfa;
188	greg	1.1	BRDFDAT nd;
189	greg	1.7	double transtest, transdist;
190	greg	1.1	COLOR ctmp;
191	greg	1.13	double dtmp, tspect, rspecr;
192	greg	2.2	MFUNC *mf;
193	greg	1.1	register int i;
194	greg	1.5	/* check arguments */
195			switch (m->otype) {
196			case MAT_PFUNC: case MAT_MFUNC:
197			minsa = 2; minfa = 4; break;
198			case MAT_PDATA: case MAT_MDATA:
199			minsa = 4; minfa = 4; break;
200			case MAT_TFUNC:
201			minsa = 2; minfa = 6; break;
202			case MAT_TDATA:
203			minsa = 4; minfa = 6; break;
204			case MAT_BRTDF:
205			minsa = 10; minfa = 6; break;
206			}
207			if (m->oargs.nsargs < minsa \|\| m->oargs.nfargs < minfa)
208	greg	1.1	objerror(m, USER, "bad # arguments");
209			nd.mp = m;
210			nd.pr = r;
211	greg	1.5	/* get specular component */
212			nd.rspec = m->oargs.farg[3];
213			/* compute transmission */
214			if (m->otype == MAT_TFUNC \|\| m->otype == MAT_TDATA
215			\|\| m->otype == MAT_BRTDF) {
216			nd.trans = m->oargs.farg[4]*(1.0 - nd.rspec);
217			nd.tspec = nd.trans * m->oargs.farg[5];
218			nd.tdiff = nd.trans - nd.tspec;
219			} else
220			nd.tdiff = nd.tspec = nd.trans = 0.0;
221			/* early shadow check */
222			if (r->crtype & SHADOW && (m->otype != MAT_BRTDF \|\| nd.tspec <= FTINY))
223			return;
224			/* diffuse reflection */
225			nd.rdiff = 1.0 - nd.trans - nd.rspec;
226			/* get material color */
227			setcolor(nd.mcolor, m->oargs.farg[0],
228			m->oargs.farg[1],
229			m->oargs.farg[2]);
230			/* fix orientation */
231			if (r->rod < 0.0)
232			flipsurface(r);
233			/* get modifiers */
234			raytexture(r, m->omod);
235			nd.pdot = raynormal(nd.pnorm, r); /* perturb normal */
236			multcolor(nd.mcolor, r->pcol); /* modify material color */
237	greg	1.7	transtest = 0;
238	greg	1.1	/* load auxiliary files */
239	greg	2.2	if (hasdata(m->otype)) {
240	greg	1.1	nd.dp = getdata(m->oargs.sarg[1]);
241	greg	2.2	i = (1 << nd.dp->nd) - 1;
242			mf = getfunc(m, 2, i<<3, 0);
243	greg	1.5	} else if (m->otype == MAT_BRTDF) {
244			nd.dp = NULL;
245	greg	2.2	mf = getfunc(m, 9, 0x3f, 0);
246	greg	1.1	} else {
247			nd.dp = NULL;
248	greg	2.2	mf = getfunc(m, 1, 0, 0);
249	greg	1.1	}
250	greg	1.5	/* set special variables */
251	greg	1.10	setbrdfunc(&nd);
252	greg	1.5	/* compute transmitted ray */
253	greg	1.13	tspect = 0.;
254	greg	1.5	if (m->otype == MAT_BRTDF && nd.tspec > FTINY) {
255			RAY sr;
256			errno = 0;
257	greg	2.2	setcolor(ctmp, evalue(mf->ep[3]),
258			evalue(mf->ep[4]),
259			evalue(mf->ep[5]));
260	greg	1.14	scalecolor(ctmp, nd.trans);
261	greg	1.5	if (errno)
262			objerror(m, WARNING, "compute error");
263	greg	1.13	else if ((tspect = bright(ctmp)) > FTINY &&
264			rayorigin(&sr, r, TRANS, tspect) == 0) {
265	greg	1.16	if (!(r->crtype & SHADOW) &&
266			DOT(r->pert,r->pert) > FTINY*FTINY) {
267	greg	1.7	for (i = 0; i < 3; i++) /* perturb direction */
268			sr.rdir[i] = r->rdir[i] -
269			.75*r->pert[i];
270	greg	2.4	if (normalize(sr.rdir) == 0.0) {
271			objerror(m, WARNING, "illegal perturbation");
272			VCOPY(sr.rdir, r->rdir);
273			}
274	greg	1.8	} else {
275			VCOPY(sr.rdir, r->rdir);
276	greg	1.7	transtest = 2;
277	greg	1.8	}
278	greg	1.5	rayvalue(&sr);
279			multcolor(sr.rcol, ctmp);
280			addcolor(r->rcol, sr.rcol);
281	greg	1.7	transtest *= bright(sr.rcol);
282			transdist = r->rot + sr.rt;
283	greg	1.5	}
284			}
285			if (r->crtype & SHADOW) /* the rest is shadow */
286			return;
287			/* compute reflected ray */
288	greg	1.13	rspecr = 0.;
289	greg	1.6	if (m->otype == MAT_BRTDF && nd.rspec > FTINY) {
290			RAY sr;
291			errno = 0;
292	greg	2.2	setcolor(ctmp, evalue(mf->ep[0]),
293			evalue(mf->ep[1]),
294			evalue(mf->ep[2]));
295	greg	1.6	if (errno)
296			objerror(m, WARNING, "compute error");
297	greg	1.13	else if ((rspecr = bright(ctmp)) > FTINY &&
298			rayorigin(&sr, r, REFLECTED, rspecr) == 0) {
299	greg	1.6	for (i = 0; i < 3; i++)
300			sr.rdir[i] = r->rdir[i] +
301	greg	1.5	2.0nd.pdotnd.pnorm[i];
302	greg	1.6	rayvalue(&sr);
303			multcolor(sr.rcol, ctmp);
304			addcolor(r->rcol, sr.rcol);
305	greg	1.5	}
306	greg	1.1	}
307			/* compute ambient */
308	greg	1.13	if ((dtmp = 1.0-nd.trans-rspecr) > FTINY) {
309	greg	1.1	ambient(ctmp, r);
310	greg	1.13	scalecolor(ctmp, dtmp);
311	greg	1.1	multcolor(ctmp, nd.mcolor); /* modified by material color */
312			addcolor(r->rcol, ctmp); /* add to returned color */
313	greg	1.5	}
314	greg	1.13	if ((dtmp = nd.trans-tspect) > FTINY) { /* from other side */
315	greg	1.5	flipsurface(r);
316			ambient(ctmp, r);
317	greg	1.13	scalecolor(ctmp, dtmp);
318	greg	1.5	multcolor(ctmp, nd.mcolor);
319			addcolor(r->rcol, ctmp);
320			flipsurface(r);
321	greg	1.1	}
322			/* add direct component */
323			direct(r, dirbrdf, &nd);
324	greg	1.7	/* check distance */
325			if (transtest > bright(r->rcol))
326			r->rt = transdist;
327	greg	1.10	}
328
329
330			setbrdfunc(np) /* set up brdf function and variables */
331			register BRDFDAT *np;
332			{
333			FVECT vec;
334
335			if (setfunc(np->mp, np->pr) == 0)
336			return(0); /* it's OK, setfunc says we're done */
337			/* else (re)assign special variables */
338			multv3(vec, np->pnorm, funcxf.xfm);
339			varset("NxP", '=', vec[0]/funcxf.sca);
340			varset("NyP", '=', vec[1]/funcxf.sca);
341			varset("NzP", '=', vec[2]/funcxf.sca);
342	greg	1.11	varset("RdotP", '=', np->pdot <= -1.0 ? -1.0 :
343			np->pdot >= 1.0 ? 1.0 : np->pdot);
344	greg	1.10	varset("CrP", '=', colval(np->mcolor,RED));
345			varset("CgP", '=', colval(np->mcolor,GRN));
346			varset("CbP", '=', colval(np->mcolor,BLU));
347			return(1);
348	greg	1.1	}