src/rt/m_brdf.c

#ifndef lint
static const char       RCSid[] = "$Id: m_brdf.c,v 2.29 2013/03/20 23:07:51 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
 *      6+      red     grn     blu     rspec   trans   tspec   A7 ..
 *
 *  Arguments for MAT_TDATA are:
 *      4+      func    datafile        funcfile        v0 ..   transform
 *      0
 *      6+      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 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 */
)
{
        BRDFDAT *np = nnp;
        double  ldot;
        double  dtmp;
        COLOR  ctmp;
        FVECT  ldx;
        static double  vldx[5], pt[MAXDIM];
        char    **sa;
        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
}


int
m_brdf(                 /* color a ray that hit a BRDTfunc material */
        OBJREC  *m,
        RAY  *r
)
{
        int  hitfront = 1;
        BRDFDAT  nd;
        RAY  sr;
        double  mirtest=0, mirdist=0;
        double  transtest=0, transdist=0;
        int  hasrefl, hastrans;
        int  hastexture;
        COLOR  ctmp;
        FVECT  vtmp;
        double  d;
        MFUNC  *mf;
        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);
}


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