src/rt/m_brdf.c

#ifndef lint
static const char       RCSid[] = "$Id: m_brdf.c,v 2.42 2024/12/05 19:23:43 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"
#include  "pmapmat.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 */
        SCOLOR  mcolor;         /* material (or pattern) color */
        SCOLOR  rdiff;          /* diffuse reflection */
        SCOLOR  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 */
        SCOLOR  scval,                  /* returned coefficient */
        void  *nnp,                     /* material data */
        FVECT  ldir,                    /* light source direction */
        double  omega                   /* light source size */
)
{
        BRDFDAT *np = nnp;
        double  ldot;
        double  dtmp;
        SCOLOR  sctmp;
        COLOR  ctmp;
        FVECT  ldx;
        static double  vldx[5], pt[MAXDDIM];
        char    **sa;
        int     i;
#define lddx (vldx+1)

        scolorblack(scval);
        
        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.
                 */
                copyscolor(sctmp, np->rdiff);
                dtmp = ldot * omega / PI;
                scalescolor(sctmp, dtmp);
                saddscolor(scval, sctmp);
        } else {
                /*
                 *  Diffuse transmitted component.
                 */
                copyscolor(sctmp, np->tdiff);
                dtmp = -ldot * omega / PI;
                scalescolor(sctmp, dtmp);
                saddscolor(scval, sctmp);
        }
        if ((ldot > 0.0 ? np->rspec <= FTINY : np->tspec <= FTINY) ||
                        ambRayInPmap(np->pr))
                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' && !sa[6][1])       /* special case */
                        colval(ctmp,RED) = 0.0;
                else
                        colval(ctmp,RED) = funvalue(sa[6], 4, lddx);
                if (sa[7][0] == '0' && !sa[7][1])
                        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 (sa[8][0] == '0' && !sa[8][1])
                        colval(ctmp,BLU) = 0.0;
                else 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;
        setscolor(sctmp, colval(ctmp,RED), colval(ctmp,GRN), colval(ctmp,BLU));
        if (ldot > 0.0) {
                /*
                 *  Compute reflected non-diffuse component.
                 */
                if ((np->mp->otype == MAT_MFUNC) | (np->mp->otype == MAT_MDATA))
                        smultscolor(sctmp, np->mcolor);
                dtmp = ldot * omega * np->rspec;
                scalescolor(sctmp, dtmp);
                saddscolor(scval, sctmp);
        } else {
                /*
                 *  Compute transmitted non-diffuse component.
                 */
                if ((np->mp->otype == MAT_TFUNC) | (np->mp->otype == MAT_TDATA))
                        smultscolor(sctmp, np->mcolor);
                dtmp = -ldot * omega * np->tspec;
                scalescolor(sctmp, dtmp);
                saddscolor(scval, sctmp);
        }
#undef lddx
}


int
m_brdf(                 /* color a ray that hit a BRDTfunc material */
        OBJREC  *m,
        RAY  *r
)
{
        BRDFDAT  nd;
        RAY  sr;
        int  hasrefl, hastrans;
        int  hastexture;
        SCOLOR  sctmp;
        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)
                setscolor(nd.rdiff, m->oargs.farg[0],
                                m->oargs.farg[1],
                                m->oargs.farg[2]);
        else
                setscolor(nd.rdiff, m->oargs.farg[3],
                                m->oargs.farg[4],
                                m->oargs.farg[5]);
                                                /* diffuse transmittance */
        setscolor(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];
                }
        }
        copyscolor(nd.mcolor, r->pcol);         /* get pattern color */
        smultscolor(nd.rdiff, nd.mcolor);       /* modify diffuse values */
        smultscolor(nd.tdiff, nd.mcolor);
        hasrefl = (sintens(nd.rdiff) > FTINY);
        hastrans = (sintens(nd.tdiff) > FTINY);
                                                /* load cal file */
        nd.dp = NULL;
        mf = getfunc(m, 9, 0x3F, 0);
                                                /* compute transmitted ray */
        setbrdfunc(&nd);
        errno = 0;
        setscolor(sctmp, 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, sctmp) == 0) {
                if (hastexture && !(r->crtype & (SHADOW|AMBIENT))) {
                                                /* perturb direction */
                        VSUB(sr.rdir, r->rdir, r->pert);
                        if (normalize(sr.rdir) == 0.0) {
                                objerror(m, WARNING, "illegal perturbation");
                                VCOPY(sr.rdir, r->rdir);
                        }
                } else {
                        VCOPY(sr.rdir, r->rdir);
                }
                rayvalue(&sr);
                smultscolor(sr.rcol, sr.rcoef);
                saddscolor(r->rcol, sr.rcol);
                if ((!hastexture || r->crtype & (SHADOW|AMBIENT)) &&
                                nd.tspec > pbright(nd.tdiff) + pbright(nd.rdiff))
                        r->rxt = r->rot + raydistance(&sr);
        }
        if (r->crtype & SHADOW)                 /* the rest is shadow */
                return(1);

                                                /* compute reflected ray */
        setbrdfunc(&nd);
        errno = 0;
        setscolor(sctmp, 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, sctmp) == 0) {
                VSUM(sr.rdir, r->rdir, nd.pnorm, 2.*nd.pdot);
                checknorm(sr.rdir);
                rayvalue(&sr);
                smultscolor(sr.rcol, sr.rcoef);
                copyscolor(r->mcol, sr.rcol);
                saddscolor(r->rcol, sr.rcol);
                r->rmt = r->rot;
                if (r->ro != NULL && isflat(r->ro->otype) &&
                                !hastexture | (r->crtype & AMBIENT))
                        r->rmt += raydistance(&sr);
        }
                                                /* compute ambient */
        if (hasrefl) {
                copyscolor(sctmp, nd.rdiff);
                multambient(sctmp, r, nd.pnorm);
                saddscolor(r->rcol, sctmp);     /* add to returned color */
        }
        if (hastrans) {                         /* from other side */
                vtmp[0] = -nd.pnorm[0];
                vtmp[1] = -nd.pnorm[1];
                vtmp[2] = -nd.pnorm[2];
                copyscolor(sctmp, nd.tdiff);
                multambient(sctmp, r, vtmp);
                saddscolor(r->rcol, sctmp);
        }
        if (hasrefl | hastrans || m->oargs.sarg[6][0] != '0')
                direct(r, dirbrdf, &nd);        /* add direct component */

        return(1);
}


int
m_brdf2(                        /* color a ray that hit a BRDF material */
        OBJREC  *m,
        RAY  *r
)
{
        BRDFDAT  nd;
        SCOLOR  sctmp;
        FVECT  vtmp;
        double  dtmp;
                                                /* always a shadow */
        if (r->crtype & SHADOW)
                return(1);
                                                /* check for back side */
        if (r->rod < 0.0) {
                if (!backvis) {
                        raytrans(r);
                        return(1);
                }
                raytexture(r, m->omod);
                flipsurface(r);                 /* reorient if backvis */
        } else
                raytexture(r, m->omod);
                                                /* 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");

        nd.mp = m;
        nd.pr = r;
                                                /* get material color */
        setscolor(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;
                setscolor(nd.tdiff, dtmp, dtmp, dtmp);
        } else {
                nd.tspec = nd.trans = 0.0;
                scolorblack(nd.tdiff);
        }
                                                /* compute reflectance */
        dtmp = 1.0 - nd.trans - nd.rspec;
        setscolor(nd.rdiff, dtmp, dtmp, dtmp);
        nd.pdot = raynormal(nd.pnorm, r);       /* perturb normal */
        smultscolor(nd.mcolor, r->pcol);        /* modify material color */
        smultscolor(nd.rdiff, nd.mcolor);
        smultscolor(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) {
                copyscolor(sctmp, nd.mcolor);   /* modified by material color */
                scalescolor(sctmp, 1.0-nd.trans);
                multambient(sctmp, r, nd.pnorm);
                saddscolor(r->rcol, sctmp);     /* add to returned color */
        }
        if (nd.trans > FTINY) {                 /* from other side */
                vtmp[0] = -nd.pnorm[0];
                vtmp[1] = -nd.pnorm[1];
                vtmp[2] = -nd.pnorm[2];
                copyscolor(sctmp, nd.mcolor);
                scalescolor(sctmp, nd.trans);
                multambient(sctmp, r, vtmp);
                saddscolor(r->rcol, sctmp);
        }
                                                /* add direct component */
        direct(r, dirbrdf, &nd);

        return(1);
}


static int
setbrdfunc(                     /* set up brdf function and variables */
        BRDFDAT  *np
)
{
        FVECT  vec;
        COLOR  ctmp;

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