src/rt/m_brdf.c

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

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

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

#include  "ray.h"

#include  "data.h"

#include  "otypes.h"

/*
 *      Arguments to this material include the color and specularity.
 *  String arguments include the reflection function and files.
 *  The BRDF is currently used just for the specular component to light
 *  sources.  Reflectance values or data coordinates are functions
 *  of the direction to the light source.
 *      We orient the surface towards the incoming ray, so a single
 *  surface can be used to represent an infinitely thin object.
 *
 *  Arguments for MAT_PFUNC and MAT_MFUNC are:
 *      2+      func    funcfile        transform ..
 *      0
 *      4+      red     grn     blu     specularity     args ..
 *
 *  Arguments for MAT_PDATA and MAT_MDATA are:
 *      4+      func    datafile        funcfile        v0 ..   transform ..
 *      0
 *      4+      red     grn     blu     specularity     args ..
 */

extern double   funvalue(), varvalue();

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


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

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

        if (ldot < 0.0)
                return;         /* wrong side */

        if (np->rdiff > FTINY) {
                /*
                 *  Compute and add diffuse reflected component to returned
                 *  color.  The diffuse reflected component will always be
                 *  modified by the color of the material.
                 */
                copycolor(ctmp, np->mcolor);
                dtmp = ldot * omega * np->rdiff / PI;
                scalecolor(ctmp, dtmp);
                addcolor(cval, ctmp);
        }
        if (np->rspec > FTINY) {
                /*
                 *  Compute specular component.
                 */
                setfunc(np->mp, np->pr);
                errno = 0;
                if (np->dp == NULL)
                        dtmp = funvalue(np->mp->oargs.sarg[0], 3, ldir);
                else {
                        for (i = 0; i < np->dp->nd; i++)
                                pt[i] = funvalue(np->mp->oargs.sarg[3+i],
                                                3, ldir);
                        dtmp = datavalue(np->dp, pt);
                        dtmp = funvalue(np->mp->oargs.sarg[0], 1, &dtmp);
                }
                if (errno)
                        goto computerr;
                if (dtmp > FTINY) {
                        copycolor(ctmp, np->scolor);
                        dtmp *= ldot * omega;
                        scalecolor(ctmp, dtmp);
                        addcolor(cval, ctmp);
                }
        }
        return;
computerr:
        objerror(np->mp, WARNING, "compute error");
        return;
}


m_brdf(m, r)                    /* color a ray which hit a BRDF material */
register OBJREC  *m;
register RAY  *r;
{
        BRDFDAT  nd;
        double  dtmp;
        COLOR  ctmp;
        register int  i;

        if (m->oargs.nsargs < 2 || m->oargs.nfargs < 4)
                objerror(m, USER, "bad # arguments");
                                                /* easy shadow test */
        if (r->crtype & SHADOW)
                return;
        nd.mp = m;
        nd.pr = r;
                                                /* load auxiliary files */
        if (m->otype == MAT_PDATA || m->otype == MAT_MDATA) {
                nd.dp = getdata(m->oargs.sarg[1]);
                for (i = 3; i < m->oargs.nsargs; i++)
                        if (m->oargs.sarg[i][0] == '-')
                                break;
                if (i-3 != nd.dp->nd)
                        objerror(m, USER, "dimension error");
                if (!fundefined(m->oargs.sarg[3]))
                        loadfunc(m->oargs.sarg[2]);
        } else {
                nd.dp = NULL;
                if (!fundefined(m->oargs.sarg[0]))
                        loadfunc(m->oargs.sarg[1]);
        }
                                                /* get material color */
        setcolor(nd.mcolor, m->oargs.farg[0],
                           m->oargs.farg[1],
                           m->oargs.farg[2]);
                                                /* get roughness */
        if (r->rod < 0.0)
                flipsurface(r);
                                                /* get modifiers */
        raytexture(r, m->omod);
        nd.pdot = raynormal(nd.pnorm, r);       /* perturb normal */
        multcolor(nd.mcolor, r->pcol);          /* modify material color */
        r->rt = r->rot;                         /* default ray length */
                                                /* get specular component */
        nd.rspec = m->oargs.farg[3];

        if (nd.rspec > FTINY) {                 /* has specular component */
                                                /* compute specular color */
                if (m->otype == MAT_MFUNC || m->otype == MAT_MDATA)
                        copycolor(nd.scolor, nd.mcolor);
                else
                        setcolor(nd.scolor, 1.0, 1.0, 1.0);
                scalecolor(nd.scolor, nd.rspec);
        }
                                                /* diffuse reflection */
        nd.rdiff = 1.0 - nd.rspec;
                                                /* compute ambient */
        if (nd.rdiff > FTINY) {
                ambient(ctmp, r);
                multcolor(ctmp, nd.mcolor);     /* modified by material color */
                addcolor(r->rcol, ctmp);        /* add to returned color */
        }
                                                /* add direct component */
        direct(r, dirbrdf, &nd);
}
Revision:	1.3
Committed:	Fri Dec 14 21:57:59 1990 UTC (33 years, 4 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 1.2:	+0 -7 lines
Log Message:	removed Fresnel approximation for specularity
#	User	Rev	Content
1	greg	1.1	/* Copyright (c) 1990 Regents of the University of California */
2
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ LBL";
5			#endif
6
7			/*
8			* Shading for materials with arbitrary BRDF's
9			*/
10
11			#include "ray.h"
12
13			#include "data.h"
14
15			#include "otypes.h"
16
17			/*
18			* Arguments to this material include the color and specularity.
19			* String arguments include the reflection function and files.
20			* The BRDF is currently used just for the specular component to light
21			* sources. Reflectance values or data coordinates are functions
22			* of the direction to the light source.
23			* We orient the surface towards the incoming ray, so a single
24			* surface can be used to represent an infinitely thin object.
25			*
26			* Arguments for MAT_PFUNC and MAT_MFUNC are:
27			* 2+ func funcfile transform ..
28			* 0
29			* 4+ red grn blu specularity args ..
30			*
31			* Arguments for MAT_PDATA and MAT_MDATA are:
32			* 4+ func datafile funcfile v0 .. transform ..
33			* 0
34			* 4+ red grn blu specularity args ..
35			*/
36
37	greg	1.2	extern double funvalue(), varvalue();
38
39	greg	1.1	typedef struct {
40			OBJREC mp; / material pointer */
41			RAY pr; / intersected ray */
42			DATARRAY dp; / data array for PDATA or MDATA */
43			COLOR mcolor; /* color of this material */
44			COLOR scolor; /* color of specular component */
45			double rspec; /* specular reflection */
46			double rdiff; /* diffuse reflection */
47			FVECT pnorm; /* perturbed surface normal */
48			double pdot; /* perturbed dot product */
49			} BRDFDAT; /* BRDF material data */
50
51
52			dirbrdf(cval, np, ldir, omega) /* compute source contribution */
53			COLOR cval; /* returned coefficient */
54			register BRDFDAT np; / material data */
55			FVECT ldir; /* light source direction */
56			double omega; /* light source size */
57			{
58			double ldot;
59			double dtmp;
60			COLOR ctmp;
61			double pt[MAXDIM];
62			register int i;
63
64			setcolor(cval, 0.0, 0.0, 0.0);
65
66			ldot = DOT(np->pnorm, ldir);
67
68			if (ldot < 0.0)
69			return; /* wrong side */
70
71			if (np->rdiff > FTINY) {
72			/*
73			* Compute and add diffuse reflected component to returned
74			* color. The diffuse reflected component will always be
75			* modified by the color of the material.
76			*/
77			copycolor(ctmp, np->mcolor);
78			dtmp = ldot * omega * np->rdiff / PI;
79			scalecolor(ctmp, dtmp);
80			addcolor(cval, ctmp);
81			}
82			if (np->rspec > FTINY) {
83			/*
84			* Compute specular component.
85			*/
86			setfunc(np->mp, np->pr);
87			errno = 0;
88			if (np->dp == NULL)
89			dtmp = funvalue(np->mp->oargs.sarg[0], 3, ldir);
90			else {
91			for (i = 0; i < np->dp->nd; i++)
92			pt[i] = funvalue(np->mp->oargs.sarg[3+i],
93			3, ldir);
94			dtmp = datavalue(np->dp, pt);
95			dtmp = funvalue(np->mp->oargs.sarg[0], 1, &dtmp);
96			}
97			if (errno)
98			goto computerr;
99			if (dtmp > FTINY) {
100			copycolor(ctmp, np->scolor);
101			dtmp = ldot omega;
102			scalecolor(ctmp, dtmp);
103			addcolor(cval, ctmp);
104			}
105			}
106			return;
107			computerr:
108			objerror(np->mp, WARNING, "compute error");
109			return;
110			}
111
112
113			m_brdf(m, r) /* color a ray which hit a BRDF material */
114			register OBJREC *m;
115			register RAY *r;
116			{
117			BRDFDAT nd;
118			double dtmp;
119			COLOR ctmp;
120			register int i;
121
122			if (m->oargs.nsargs < 2 \|\| m->oargs.nfargs < 4)
123			objerror(m, USER, "bad # arguments");
124			/* easy shadow test */
125			if (r->crtype & SHADOW)
126			return;
127			nd.mp = m;
128			nd.pr = r;
129			/* load auxiliary files */
130			if (m->otype == MAT_PDATA \|\| m->otype == MAT_MDATA) {
131			nd.dp = getdata(m->oargs.sarg[1]);
132			for (i = 3; i < m->oargs.nsargs; i++)
133			if (m->oargs.sarg[i][0] == '-')
134			break;
135			if (i-3 != nd.dp->nd)
136			objerror(m, USER, "dimension error");
137			if (!fundefined(m->oargs.sarg[3]))
138			loadfunc(m->oargs.sarg[2]);
139			} else {
140			nd.dp = NULL;
141			if (!fundefined(m->oargs.sarg[0]))
142			loadfunc(m->oargs.sarg[1]);
143			}
144			/* get material color */
145			setcolor(nd.mcolor, m->oargs.farg[0],
146			m->oargs.farg[1],
147			m->oargs.farg[2]);
148			/* get roughness */
149			if (r->rod < 0.0)
150			flipsurface(r);
151			/* get modifiers */
152			raytexture(r, m->omod);
153			nd.pdot = raynormal(nd.pnorm, r); /* perturb normal */
154			multcolor(nd.mcolor, r->pcol); /* modify material color */
155			r->rt = r->rot; /* default ray length */
156			/* get specular component */
157			nd.rspec = m->oargs.farg[3];
158
159			if (nd.rspec > FTINY) { /* has specular component */
160			/* compute specular color */
161			if (m->otype == MAT_MFUNC \|\| m->otype == MAT_MDATA)
162			copycolor(nd.scolor, nd.mcolor);
163			else
164			setcolor(nd.scolor, 1.0, 1.0, 1.0);
165			scalecolor(nd.scolor, nd.rspec);
166			}
167			/* diffuse reflection */
168			nd.rdiff = 1.0 - nd.rspec;
169			/* compute ambient */
170			if (nd.rdiff > FTINY) {
171			ambient(ctmp, r);
172			multcolor(ctmp, nd.mcolor); /* modified by material color */
173			addcolor(r->rcol, ctmp); /* add to returned color */
174			}
175			/* add direct component */
176			direct(r, dirbrdf, &nd);
177			}