src/rt/m_brdf.c

#ifndef lint
static const char       RCSid[] = "$Id: m_brdf.c,v 2.26 2010/09/26 15:51:15 greg Exp $";
#endif
/*
 *  Shading for materials with arbitrary BRDF's
 */

#include "copyright.h"

#include  "ray.h"
#include  "ambient.h"
#include  "data.h"
#include  "source.h"
#include  "otypes.h"
#include  "rtotypes.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.  (Data modification functions
 *  are passed the source direction as args 2-4.)
 *      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
 *      9+      rdf     gdf     bdf
 *              rdb     gdb     bdb
 *              rdt     gdt     bdt     A10 ..
 *
 *      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 (or pattern)
 */

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


static srcdirf_t dirbrdf;
static int setbrdfunc(BRDFDAT  *np);


static void
dirbrdf(                /* compute source contribution */
        COLOR  cval,                    /* returned coefficient */
        void  *nnp,             /* material data */
        FVECT  ldir,                    /* light source direction */
        double  omega                   /* light source size */
)
{
        register BRDFDAT *np = nnp;
        double  ldot;
        double  dtmp;
        COLOR  ctmp;
        FVECT  ldx;
        static double  vldx[5], pt[MAXDIM];
        register char   **sa;
        register int    i;
#define lddx (vldx+1)

        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) {
                /*
                 *  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->rdiff);
                dtmp = ldot * omega / PI;
                scalecolor(ctmp, dtmp);
                addcolor(cval, ctmp);
        } else {
                /*
                 *  Diffuse transmitted component.
                 */
                copycolor(ctmp, np->tdiff);
                dtmp = -ldot * omega / PI;
                scalecolor(ctmp, dtmp);
                addcolor(cval, ctmp);
        }
        if (ldot > 0.0 ? np->rspec <= FTINY : np->tspec <= FTINY)
                return;         /* diffuse only */
                                        /* 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;
        lddx[3] = omega;
                                        /* compute BRTDF */
        if (np->mp->otype == MAT_BRTDF) {
                if (sa[6][0] == '0')            /* special case */
                        colval(ctmp,RED) = 0.0;
                else
                        colval(ctmp,RED) = funvalue(sa[6], 4, lddx);
                if (sa[7][0] == '0')
                        colval(ctmp,GRN) = 0.0;
                else if (!strcmp(sa[7],sa[6]))
                        colval(ctmp,GRN) = colval(ctmp,RED);
                else
                        colval(ctmp,GRN) = funvalue(sa[7], 4, 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], 4, lddx);
                dtmp = bright(ctmp);
        } else if (np->dp == NULL) {
                dtmp = funvalue(sa[0], 4, lddx);
                setcolor(ctmp, dtmp, dtmp, dtmp);
        } else {
                for (i = 0; i < np->dp->nd; i++)
                        pt[i] = funvalue(sa[3+i], 4, lddx);
                vldx[0] = datavalue(np->dp, pt);
                dtmp = funvalue(sa[0], 5, vldx);
                setcolor(ctmp, dtmp, dtmp, dtmp);
        }
        if ((errno == EDOM) | (errno == ERANGE)) {
                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);
        }
#undef lddx
}


extern int
m_brdf(                 /* color a ray that hit a BRDTfunc material */
        register OBJREC  *m,
        register RAY  *r
)
{
        int  hitfront = 1;
        BRDFDAT  nd;
        RAY  sr;
        double  mirtest=0, mirdist=0;
        double  transtest, transdist;
        int  hasrefl, hastrans;
        int  hastexture;
        COLOR  ctmp;
        FVECT  vtmp;
        double  d;
        register MFUNC  *mf;
        register int  i;
                                                /* check arguments */
        if ((m->oargs.nsargs < 10) | (m->oargs.nfargs < 9))
                objerror(m, USER, "bad # arguments");
        nd.mp = m;
        nd.pr = r;
                                                /* dummy values */
        nd.rspec = nd.tspec = 1.0;
        nd.trans = 0.5;
                                                /* diffuse reflectance */
        if (r->rod > 0.0)
                setcolor(nd.rdiff, m->oargs.farg[0],
                                m->oargs.farg[1],
                                m->oargs.farg[2]);
        else
                setcolor(nd.rdiff, m->oargs.farg[3],
                                m->oargs.farg[4],
                                m->oargs.farg[5]);
                                                /* diffuse transmittance */
        setcolor(nd.tdiff, m->oargs.farg[6],
                        m->oargs.farg[7],
                        m->oargs.farg[8]);
                                                /* get modifiers */
        raytexture(r, m->omod);
        hastexture = DOT(r->pert,r->pert) > FTINY*FTINY;
        if (hastexture) {                       /* perturb normal */
                nd.pdot = raynormal(nd.pnorm, r);
        } else {
                VCOPY(nd.pnorm, r->ron);
                nd.pdot = r->rod;
        }
        if (r->rod < 0.0) {                     /* orient perturbed values */
                nd.pdot = -nd.pdot;
                for (i = 0; i < 3; i++) {
                        nd.pnorm[i] = -nd.pnorm[i];
                        r->pert[i] = -r->pert[i];
                }
                hitfront = 0;
        }
        copycolor(nd.mcolor, r->pcol);          /* get pattern color */
        multcolor(nd.rdiff, nd.mcolor);         /* modify diffuse values */
        multcolor(nd.tdiff, nd.mcolor);
        hasrefl = bright(nd.rdiff) > FTINY;
        hastrans = bright(nd.tdiff) > FTINY;
                                                /* load cal file */
        nd.dp = NULL;
        mf = getfunc(m, 9, 0x3f, 0);
                                                /* compute transmitted ray */
        setbrdfunc(&nd);
        errno = 0;
        setcolor(ctmp, evalue(mf->ep[3]),
                        evalue(mf->ep[4]),
                        evalue(mf->ep[5]));
        if ((errno == EDOM) | (errno == ERANGE))
                objerror(m, WARNING, "compute error");
        else if (rayorigin(&sr, TRANS, r, ctmp) == 0) {
                if (!(r->crtype & SHADOW) && hastexture) {
                                                /* perturb direction */
                        VSUM(sr.rdir, r->rdir, r->pert, -.75);
                        if (normalize(sr.rdir) == 0.0) {
                                objerror(m, WARNING, "illegal perturbation");
                                VCOPY(sr.rdir, r->rdir);
                        }
                } else {
                        VCOPY(sr.rdir, r->rdir);
                }
                rayvalue(&sr);
                multcolor(sr.rcol, sr.rcoef);
                addcolor(r->rcol, sr.rcol);
                if (!hastexture) {
                        transtest = 2.0*bright(sr.rcol);
                        transdist = r->rot + sr.rt;
                }
        }
        if (r->crtype & SHADOW)                 /* the rest is shadow */
                return(1);
                                                /* compute reflected ray */
        setbrdfunc(&nd);
        errno = 0;
        setcolor(ctmp, evalue(mf->ep[0]),
                        evalue(mf->ep[1]),
                        evalue(mf->ep[2]));
        if ((errno == EDOM) | (errno == ERANGE))
                objerror(m, WARNING, "compute error");
        else if (rayorigin(&sr, REFLECTED, r, ctmp) == 0) {
                VSUM(sr.rdir, r->rdir, nd.pnorm, 2.*nd.pdot);
                checknorm(sr.rdir);
                rayvalue(&sr);
                multcolor(sr.rcol, sr.rcoef);
                addcolor(r->rcol, sr.rcol);
                if (!hastexture && r->ro != NULL && isflat(r->ro->otype)) {
                        mirtest = 2.0*bright(sr.rcol);
                        mirdist = r->rot + sr.rt;
                }
        }
                                                /* compute ambient */
        if (hasrefl) {
                if (!hitfront)
                        flipsurface(r);
                copycolor(ctmp, nd.rdiff);
                multambient(ctmp, r, nd.pnorm);
                addcolor(r->rcol, ctmp);        /* add to returned color */
                if (!hitfront)
                        flipsurface(r);
        }
        if (hastrans) {                         /* from other side */
                if (hitfront)
                        flipsurface(r);
                vtmp[0] = -nd.pnorm[0];
                vtmp[1] = -nd.pnorm[1];
                vtmp[2] = -nd.pnorm[2];
                copycolor(ctmp, nd.tdiff);
                multambient(ctmp, r, vtmp);
                addcolor(r->rcol, ctmp);
                if (hitfront)
                        flipsurface(r);
        }
        if (hasrefl | hastrans || m->oargs.sarg[6][0] != '0')
                direct(r, dirbrdf, &nd);        /* add direct component */

        d = bright(r->rcol);                    /* set effective distance */
        if (transtest > d)
                r->rt = transdist;
        else if (mirtest > d)
                r->rt = mirdist;

        return(1);
}


extern int
m_brdf2(                        /* color a ray that hit a BRDF material */
        register OBJREC  *m,
        register RAY  *r
)
{
        BRDFDAT  nd;
        COLOR  ctmp;
        FVECT  vtmp;
        double  dtmp;
                                                /* always a shadow */
        if (r->crtype & SHADOW)
                return(1);
                                                /* check arguments */
        if ((m->oargs.nsargs < (hasdata(m->otype)?4:2)) | (m->oargs.nfargs <
                        ((m->otype==MAT_TFUNC)|(m->otype==MAT_TDATA)?6:4)))
                objerror(m, USER, "bad # arguments");
                                                /* check for back side */
        if (r->rod < 0.0) {
                if (!backvis && m->otype != MAT_TFUNC
                                && m->otype != MAT_TDATA) {
                        raytrans(r);
                        return(1);
                }
                raytexture(r, m->omod);
                flipsurface(r);                 /* reorient if backvis */
        } else
                raytexture(r, m->omod);

        nd.mp = m;
        nd.pr = r;
                                                /* get material color */
        setcolor(nd.mcolor, m->oargs.farg[0],
                        m->oargs.farg[1],
                        m->oargs.farg[2]);
                                                /* get specular component */
        nd.rspec = m->oargs.farg[3];
                                                /* compute transmittance */
        if ((m->otype == MAT_TFUNC) | (m->otype == MAT_TDATA)) {
                nd.trans = m->oargs.farg[4]*(1.0 - nd.rspec);
                nd.tspec = nd.trans * m->oargs.farg[5];
                dtmp = nd.trans - nd.tspec;
                setcolor(nd.tdiff, dtmp, dtmp, dtmp);
        } else {
                nd.tspec = nd.trans = 0.0;
                setcolor(nd.tdiff, 0.0, 0.0, 0.0);
        }
                                                /* compute reflectance */
        dtmp = 1.0 - nd.trans - nd.rspec;
        setcolor(nd.rdiff, dtmp, dtmp, dtmp);
        nd.pdot = raynormal(nd.pnorm, r);       /* perturb normal */
        multcolor(nd.mcolor, r->pcol);          /* modify material color */
        multcolor(nd.rdiff, nd.mcolor);
        multcolor(nd.tdiff, nd.mcolor);
                                                /* load auxiliary files */
        if (hasdata(m->otype)) {
                nd.dp = getdata(m->oargs.sarg[1]);
                getfunc(m, 2, 0, 0);
        } else {
                nd.dp = NULL;
                getfunc(m, 1, 0, 0);
        }
                                                /* compute ambient */
        if (nd.trans < 1.0-FTINY) {
                copycolor(ctmp, nd.mcolor);     /* modified by material color */
                scalecolor(ctmp, 1.0-nd.trans);
                multambient(ctmp, r, nd.pnorm);
                addcolor(r->rcol, ctmp);        /* add to returned color */
        }
        if (nd.trans > FTINY) {         /* from other side */
                flipsurface(r);
                vtmp[0] = -nd.pnorm[0];
                vtmp[1] = -nd.pnorm[1];
                vtmp[2] = -nd.pnorm[2];
                copycolor(ctmp, nd.mcolor);
                scalecolor(ctmp, nd.trans);
                multambient(ctmp, r, vtmp);
                addcolor(r->rcol, ctmp);
                flipsurface(r);
        }
                                                /* add direct component */
        direct(r, dirbrdf, &nd);

        return(1);
}


static int
setbrdfunc(                     /* 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.27
Committed:	Mon Oct 25 22:57:45 2010 UTC (13 years, 6 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad4R1
Changes since 2.26:	+4 -5 lines
Log Message:	Changed to FVECT macros where appropriate
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.27	static const char RCSid[] = "$Id: m_brdf.c,v 2.26 2010/09/26 15:51:15 greg Exp $";
3	greg	1.1	#endif
4			/*
5			* Shading for materials with arbitrary BRDF's
6			*/
7
8	greg	2.16	#include "copyright.h"
9	greg	2.15
10	greg	1.1	#include "ray.h"
11	greg	2.20	#include "ambient.h"
12	greg	1.1	#include "data.h"
13	schorsch	2.21	#include "source.h"
14	greg	1.1	#include "otypes.h"
15	schorsch	2.21	#include "rtotypes.h"
16	greg	2.2	#include "func.h"
17
18	greg	1.1	/*
19			* Arguments to this material include the color and specularity.
20			* String arguments include the reflection function and files.
21			* The BRDF is currently used just for the specular component to light
22			* sources. Reflectance values or data coordinates are functions
23	greg	2.7	* of the direction to the light source. (Data modification functions
24			* are passed the source direction as args 2-4.)
25	greg	1.1	* 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	greg	2.6	* 9+ rdf gdf bdf
55			* rdb gdb bdb
56			* rdt gdt bdt A10 ..
57	greg	1.5	*
58			* In addition to the normal variables available to functions,
59			* we define the following:
60			* NxP, NyP, NzP - perturbed surface normal
61			* RdotP - perturbed ray dot product
62	greg	2.6	* CrP, CgP, CbP - perturbed material color (or pattern)
63	greg	1.1	*/
64
65			typedef struct {
66			OBJREC mp; / material pointer */
67			RAY pr; / intersected ray */
68	greg	1.5	DATARRAY dp; / data array for PDATA, MDATA or TDATA */
69	greg	2.6	COLOR mcolor; /* material (or pattern) color */
70			COLOR rdiff; /* diffuse reflection */
71			COLOR tdiff; /* diffuse transmission */
72			double rspec; /* specular reflectance (1 for BRDTF) */
73			double trans; /* transmissivity (.5 for BRDTF) */
74			double tspec; /* specular transmittance (1 for BRDTF) */
75	greg	1.1	FVECT pnorm; /* perturbed surface normal */
76			double pdot; /* perturbed dot product */
77			} BRDFDAT; /* BRDF material data */
78
79
80	schorsch	2.21	static srcdirf_t dirbrdf;
81			static int setbrdfunc(BRDFDAT *np);
82
83
84	greg	2.15	static void
85	schorsch	2.21	dirbrdf( /* compute source contribution */
86			COLOR cval, /* returned coefficient */
87			void nnp, / material data */
88			FVECT ldir, /* light source direction */
89			double omega /* light source size */
90			)
91	greg	1.1	{
92	schorsch	2.21	register BRDFDAT *np = nnp;
93	greg	1.1	double ldot;
94			double dtmp;
95			COLOR ctmp;
96	greg	1.4	FVECT ldx;
97	greg	2.12	static double vldx[5], pt[MAXDIM];
98	greg	1.5	register char **sa;
99	greg	1.1	register int i;
100	greg	2.12	#define lddx (vldx+1)
101	greg	1.1
102			setcolor(cval, 0.0, 0.0, 0.0);
103
104			ldot = DOT(np->pnorm, ldir);
105
106	greg	1.5	if (ldot <= FTINY && ldot >= -FTINY)
107			return; /* too close to grazing */
108	greg	2.6
109	greg	1.5	if (ldot < 0.0 ? np->trans <= FTINY : np->trans >= 1.0-FTINY)
110	greg	1.1	return; /* wrong side */
111
112	greg	2.6	if (ldot > 0.0) {
113	greg	1.1	/*
114			* Compute and add diffuse reflected component to returned
115			* color. The diffuse reflected component will always be
116			* modified by the color of the material.
117			*/
118	greg	2.6	copycolor(ctmp, np->rdiff);
119			dtmp = ldot * omega / PI;
120	greg	1.1	scalecolor(ctmp, dtmp);
121			addcolor(cval, ctmp);
122	greg	2.6	} else {
123	greg	1.1	/*
124	greg	1.5	* Diffuse transmitted component.
125	greg	1.1	*/
126	greg	2.6	copycolor(ctmp, np->tdiff);
127			dtmp = -ldot * omega / PI;
128	greg	1.5	scalecolor(ctmp, dtmp);
129			addcolor(cval, ctmp);
130	greg	1.1	}
131	greg	1.5	if (ldot > 0.0 ? np->rspec <= FTINY : np->tspec <= FTINY)
132	greg	2.24	return; /* diffuse only */
133	greg	1.5	/* set up function */
134	greg	1.10	setbrdfunc(np);
135	greg	1.5	sa = np->mp->oargs.sarg;
136			errno = 0;
137			/* transform light vector */
138			multv3(ldx, ldir, funcxf.xfm);
139			for (i = 0; i < 3; i++)
140	greg	2.3	lddx[i] = ldx[i]/funcxf.sca;
141	greg	2.12	lddx[3] = omega;
142	greg	1.5	/* compute BRTDF */
143			if (np->mp->otype == MAT_BRTDF) {
144	greg	2.6	if (sa[6][0] == '0') /* special case */
145			colval(ctmp,RED) = 0.0;
146			else
147	greg	2.12	colval(ctmp,RED) = funvalue(sa[6], 4, lddx);
148	greg	2.24	if (sa[7][0] == '0')
149			colval(ctmp,GRN) = 0.0;
150			else if (!strcmp(sa[7],sa[6]))
151	greg	1.5	colval(ctmp,GRN) = colval(ctmp,RED);
152			else
153	greg	2.12	colval(ctmp,GRN) = funvalue(sa[7], 4, lddx);
154	greg	1.7	if (!strcmp(sa[8],sa[6]))
155	greg	1.5	colval(ctmp,BLU) = colval(ctmp,RED);
156	greg	1.7	else if (!strcmp(sa[8],sa[7]))
157	greg	1.5	colval(ctmp,BLU) = colval(ctmp,GRN);
158			else
159	greg	2.12	colval(ctmp,BLU) = funvalue(sa[8], 4, lddx);
160	greg	1.5	dtmp = bright(ctmp);
161			} else if (np->dp == NULL) {
162	greg	2.12	dtmp = funvalue(sa[0], 4, lddx);
163	greg	1.5	setcolor(ctmp, dtmp, dtmp, dtmp);
164			} else {
165			for (i = 0; i < np->dp->nd; i++)
166	greg	2.12	pt[i] = funvalue(sa[3+i], 4, lddx);
167	greg	2.7	vldx[0] = datavalue(np->dp, pt);
168	greg	2.12	dtmp = funvalue(sa[0], 5, vldx);
169	greg	1.5	setcolor(ctmp, dtmp, dtmp, dtmp);
170			}
171	greg	2.25	if ((errno == EDOM) \| (errno == ERANGE)) {
172	greg	2.2	objerror(np->mp, WARNING, "compute error");
173			return;
174			}
175	greg	1.5	if (dtmp <= FTINY)
176			return;
177			if (ldot > 0.0) {
178			/*
179			* Compute reflected non-diffuse component.
180			*/
181	schorsch	2.19	if ((np->mp->otype == MAT_MFUNC) \| (np->mp->otype == MAT_MDATA))
182	greg	1.6	multcolor(ctmp, np->mcolor);
183			dtmp = ldot * omega * np->rspec;
184	greg	1.5	scalecolor(ctmp, dtmp);
185			addcolor(cval, ctmp);
186			} else {
187			/*
188			* Compute transmitted non-diffuse component.
189			*/
190	schorsch	2.19	if ((np->mp->otype == MAT_TFUNC) \| (np->mp->otype == MAT_TDATA))
191	greg	1.6	multcolor(ctmp, np->mcolor);
192	greg	1.5	dtmp = -ldot * omega * np->tspec;
193			scalecolor(ctmp, dtmp);
194			addcolor(cval, ctmp);
195			}
196	greg	2.12	#undef lddx
197	greg	1.1	}
198
199
200	schorsch	2.21	extern int
201			m_brdf( /* color a ray that hit a BRDTfunc material */
202			register OBJREC *m,
203			register RAY *r
204			)
205	greg	1.1	{
206	greg	2.15	int hitfront = 1;
207	greg	1.1	BRDFDAT nd;
208	greg	2.6	RAY sr;
209	greg	2.22	double mirtest=0, mirdist=0;
210	greg	1.7	double transtest, transdist;
211	greg	2.6	int hasrefl, hastrans;
212	greg	2.22	int hastexture;
213	greg	1.1	COLOR ctmp;
214	greg	2.14	FVECT vtmp;
215	greg	2.22	double d;
216	greg	2.6	register MFUNC *mf;
217	greg	1.1	register int i;
218	greg	1.5	/* check arguments */
219	schorsch	2.19	if ((m->oargs.nsargs < 10) \| (m->oargs.nfargs < 9))
220	greg	2.6	objerror(m, USER, "bad # arguments");
221			nd.mp = m;
222			nd.pr = r;
223			/* dummy values */
224			nd.rspec = nd.tspec = 1.0;
225			nd.trans = 0.5;
226			/* diffuse reflectance */
227			if (r->rod > 0.0)
228			setcolor(nd.rdiff, m->oargs.farg[0],
229			m->oargs.farg[1],
230			m->oargs.farg[2]);
231			else
232			setcolor(nd.rdiff, m->oargs.farg[3],
233			m->oargs.farg[4],
234			m->oargs.farg[5]);
235			/* diffuse transmittance */
236			setcolor(nd.tdiff, m->oargs.farg[6],
237			m->oargs.farg[7],
238			m->oargs.farg[8]);
239	greg	2.17	/* get modifiers */
240	greg	2.6	raytexture(r, m->omod);
241	greg	2.22	hastexture = DOT(r->pert,r->pert) > FTINY*FTINY;
242			if (hastexture) { /* perturb normal */
243			nd.pdot = raynormal(nd.pnorm, r);
244			} else {
245			VCOPY(nd.pnorm, r->ron);
246			nd.pdot = r->rod;
247			}
248	greg	2.6	if (r->rod < 0.0) { /* orient perturbed values */
249			nd.pdot = -nd.pdot;
250			for (i = 0; i < 3; i++) {
251			nd.pnorm[i] = -nd.pnorm[i];
252			r->pert[i] = -r->pert[i];
253			}
254	greg	2.15	hitfront = 0;
255	greg	1.5	}
256	greg	2.6	copycolor(nd.mcolor, r->pcol); /* get pattern color */
257			multcolor(nd.rdiff, nd.mcolor); /* modify diffuse values */
258			multcolor(nd.tdiff, nd.mcolor);
259			hasrefl = bright(nd.rdiff) > FTINY;
260			hastrans = bright(nd.tdiff) > FTINY;
261			/* load cal file */
262			nd.dp = NULL;
263			mf = getfunc(m, 9, 0x3f, 0);
264			/* compute transmitted ray */
265			setbrdfunc(&nd);
266			errno = 0;
267			setcolor(ctmp, evalue(mf->ep[3]),
268			evalue(mf->ep[4]),
269			evalue(mf->ep[5]));
270	greg	2.25	if ((errno == EDOM) \| (errno == ERANGE))
271	greg	2.6	objerror(m, WARNING, "compute error");
272	greg	2.23	else if (rayorigin(&sr, TRANS, r, ctmp) == 0) {
273	greg	2.22	if (!(r->crtype & SHADOW) && hastexture) {
274	greg	2.27	/* perturb direction */
275			VSUM(sr.rdir, r->rdir, r->pert, -.75);
276	greg	2.6	if (normalize(sr.rdir) == 0.0) {
277			objerror(m, WARNING, "illegal perturbation");
278			VCOPY(sr.rdir, r->rdir);
279			}
280			} else {
281			VCOPY(sr.rdir, r->rdir);
282			}
283			rayvalue(&sr);
284	greg	2.23	multcolor(sr.rcol, sr.rcoef);
285	greg	2.6	addcolor(r->rcol, sr.rcol);
286	greg	2.22	if (!hastexture) {
287			transtest = 2.0*bright(sr.rcol);
288			transdist = r->rot + sr.rt;
289			}
290	greg	2.6	}
291			if (r->crtype & SHADOW) /* the rest is shadow */
292	greg	2.10	return(1);
293	greg	2.6	/* compute reflected ray */
294			setbrdfunc(&nd);
295			errno = 0;
296			setcolor(ctmp, evalue(mf->ep[0]),
297			evalue(mf->ep[1]),
298			evalue(mf->ep[2]));
299	greg	2.25	if ((errno == EDOM) \| (errno == ERANGE))
300	greg	2.6	objerror(m, WARNING, "compute error");
301	greg	2.23	else if (rayorigin(&sr, REFLECTED, r, ctmp) == 0) {
302	greg	2.27	VSUM(sr.rdir, r->rdir, nd.pnorm, 2.*nd.pdot);
303	greg	2.26	checknorm(sr.rdir);
304	greg	2.6	rayvalue(&sr);
305	greg	2.23	multcolor(sr.rcol, sr.rcoef);
306	greg	2.6	addcolor(r->rcol, sr.rcol);
307	greg	2.22	if (!hastexture && r->ro != NULL && isflat(r->ro->otype)) {
308			mirtest = 2.0*bright(sr.rcol);
309			mirdist = r->rot + sr.rt;
310			}
311	greg	2.6	}
312			/* compute ambient */
313			if (hasrefl) {
314	greg	2.15	if (!hitfront)
315	greg	2.6	flipsurface(r);
316	greg	2.23	copycolor(ctmp, nd.rdiff);
317			multambient(ctmp, r, nd.pnorm);
318	greg	2.6	addcolor(r->rcol, ctmp); /* add to returned color */
319	greg	2.15	if (!hitfront)
320	greg	2.6	flipsurface(r);
321			}
322			if (hastrans) { /* from other side */
323	greg	2.15	if (hitfront)
324	greg	2.6	flipsurface(r);
325	greg	2.15	vtmp[0] = -nd.pnorm[0];
326			vtmp[1] = -nd.pnorm[1];
327			vtmp[2] = -nd.pnorm[2];
328	greg	2.23	copycolor(ctmp, nd.tdiff);
329			multambient(ctmp, r, vtmp);
330	greg	2.6	addcolor(r->rcol, ctmp);
331	greg	2.15	if (hitfront)
332	greg	2.6	flipsurface(r);
333			}
334			if (hasrefl \| hastrans \|\| m->oargs.sarg[6][0] != '0')
335			direct(r, dirbrdf, &nd); /* add direct component */
336	greg	2.22
337			d = bright(r->rcol); /* set effective distance */
338			if (transtest > d)
339	greg	2.6	r->rt = transdist;
340	greg	2.22	else if (mirtest > d)
341			r->rt = mirdist;
342	greg	2.10
343			return(1);
344	greg	2.6	}
345
346
347
348	schorsch	2.21	extern int
349			m_brdf2( /* color a ray that hit a BRDF material */
350			register OBJREC *m,
351			register RAY *r
352			)
353	greg	2.6	{
354			BRDFDAT nd;
355			COLOR ctmp;
356	greg	2.14	FVECT vtmp;
357	greg	2.6	double dtmp;
358			/* always a shadow */
359			if (r->crtype & SHADOW)
360	greg	2.10	return(1);
361	greg	2.6	/* check arguments */
362	schorsch	2.19	if ((m->oargs.nsargs < (hasdata(m->otype)?4:2)) \| (m->oargs.nfargs <
363			((m->otype==MAT_TFUNC)\|(m->otype==MAT_TDATA)?6:4)))
364	greg	1.1	objerror(m, USER, "bad # arguments");
365	greg	2.17	/* check for back side */
366			if (r->rod < 0.0) {
367			if (!backvis && m->otype != MAT_TFUNC
368			&& m->otype != MAT_TDATA) {
369			raytrans(r);
370			return(1);
371			}
372			raytexture(r, m->omod);
373			flipsurface(r); /* reorient if backvis */
374			} else
375			raytexture(r, m->omod);
376
377	greg	1.1	nd.mp = m;
378			nd.pr = r;
379	greg	2.6	/* get material color */
380			setcolor(nd.mcolor, m->oargs.farg[0],
381			m->oargs.farg[1],
382			m->oargs.farg[2]);
383	greg	1.5	/* get specular component */
384			nd.rspec = m->oargs.farg[3];
385	greg	2.6	/* compute transmittance */
386	schorsch	2.19	if ((m->otype == MAT_TFUNC) \| (m->otype == MAT_TDATA)) {
387	greg	1.5	nd.trans = m->oargs.farg[4]*(1.0 - nd.rspec);
388			nd.tspec = nd.trans * m->oargs.farg[5];
389	greg	2.6	dtmp = nd.trans - nd.tspec;
390			setcolor(nd.tdiff, dtmp, dtmp, dtmp);
391			} else {
392			nd.tspec = nd.trans = 0.0;
393			setcolor(nd.tdiff, 0.0, 0.0, 0.0);
394			}
395			/* compute reflectance */
396			dtmp = 1.0 - nd.trans - nd.rspec;
397			setcolor(nd.rdiff, dtmp, dtmp, dtmp);
398	greg	1.5	nd.pdot = raynormal(nd.pnorm, r); /* perturb normal */
399			multcolor(nd.mcolor, r->pcol); /* modify material color */
400	greg	2.6	multcolor(nd.rdiff, nd.mcolor);
401			multcolor(nd.tdiff, nd.mcolor);
402	greg	1.1	/* load auxiliary files */
403	greg	2.2	if (hasdata(m->otype)) {
404	greg	1.1	nd.dp = getdata(m->oargs.sarg[1]);
405	greg	2.6	getfunc(m, 2, 0, 0);
406	greg	1.1	} else {
407			nd.dp = NULL;
408	greg	2.6	getfunc(m, 1, 0, 0);
409	greg	1.1	}
410			/* compute ambient */
411	greg	2.6	if (nd.trans < 1.0-FTINY) {
412	greg	2.23	copycolor(ctmp, nd.mcolor); /* modified by material color */
413	greg	2.6	scalecolor(ctmp, 1.0-nd.trans);
414	greg	2.23	multambient(ctmp, r, nd.pnorm);
415	greg	1.1	addcolor(r->rcol, ctmp); /* add to returned color */
416	greg	1.5	}
417	greg	2.6	if (nd.trans > FTINY) { /* from other side */
418	greg	1.5	flipsurface(r);
419	greg	2.14	vtmp[0] = -nd.pnorm[0];
420			vtmp[1] = -nd.pnorm[1];
421			vtmp[2] = -nd.pnorm[2];
422	greg	2.23	copycolor(ctmp, nd.mcolor);
423	greg	2.6	scalecolor(ctmp, nd.trans);
424	greg	2.23	multambient(ctmp, r, vtmp);
425	greg	1.5	addcolor(r->rcol, ctmp);
426			flipsurface(r);
427	greg	1.1	}
428			/* add direct component */
429			direct(r, dirbrdf, &nd);
430	greg	2.10
431			return(1);
432	greg	1.10	}
433
434
435	schorsch	2.21	static int
436			setbrdfunc( /* set up brdf function and variables */
437			register BRDFDAT *np
438			)
439	greg	1.10	{
440			FVECT vec;
441
442			if (setfunc(np->mp, np->pr) == 0)
443			return(0); /* it's OK, setfunc says we're done */
444			/* else (re)assign special variables */
445			multv3(vec, np->pnorm, funcxf.xfm);
446			varset("NxP", '=', vec[0]/funcxf.sca);
447			varset("NyP", '=', vec[1]/funcxf.sca);
448			varset("NzP", '=', vec[2]/funcxf.sca);
449	greg	1.11	varset("RdotP", '=', np->pdot <= -1.0 ? -1.0 :
450			np->pdot >= 1.0 ? 1.0 : np->pdot);
451	greg	1.10	varset("CrP", '=', colval(np->mcolor,RED));
452			varset("CgP", '=', colval(np->mcolor,GRN));
453			varset("CbP", '=', colval(np->mcolor,BLU));
454			return(1);
455	greg	1.1	}