--- ray/src/rt/m_brdf.c 1990/12/14 21:57:59 1.3 +++ ray/src/rt/m_brdf.c 2003/03/05 16:16:53 2.18 @@ -1,54 +1,83 @@ -/* Copyright (c) 1990 Regents of the University of California */ - #ifndef lint -static char SCCSid[] = "$SunId$ LBL"; +static const char RCSid[] = "$Id: m_brdf.c,v 2.18 2003/03/05 16:16:53 greg Exp $"; #endif - /* * Shading for materials with arbitrary BRDF's */ +#include "copyright.h" + #include "ray.h" #include "data.h" #include "otypes.h" +#include "func.h" + /* * Arguments to this material include the color and specularity. * String arguments include the reflection function and files. * The BRDF is currently used just for the specular component to light * sources. Reflectance values or data coordinates are functions - * of the direction to the light source. + * 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 .. + * 2+ func funcfile transform * 0 - * 4+ red grn blu specularity args .. + * 4+ red grn blu specularity A5 .. * * Arguments for MAT_PDATA and MAT_MDATA are: - * 4+ func datafile funcfile v0 .. transform .. + * 4+ func datafile funcfile v0 .. transform * 0 - * 4+ red grn blu specularity args .. + * 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) */ -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 */ + 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 void dirbrdf(cval, np, ldir, omega) /* compute source contribution */ COLOR cval; /* returned coefficient */ register BRDFDAT *np; /* material data */ @@ -58,120 +87,344 @@ double omega; /* light source size */ double ldot; double dtmp; COLOR ctmp; - double pt[MAXDIM]; + 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 < 0.0) + 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 (np->rdiff > FTINY) { + 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->mcolor); - dtmp = ldot * omega * np->rdiff / PI; + 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 (np->rspec > FTINY) { + if (ldot > 0.0 ? np->rspec <= FTINY : np->tspec <= FTINY) + return; /* no specular component */ + /* set up function */ + setbrdfunc(np); + sa = np->mp->oargs.sarg; + errno = 0; + /* transform light vector */ + multv3(ldx, ldir, funcxf.xfm); + for (i = 0; i < 3; i++) + lddx[i] = ldx[i]/funcxf.sca; + 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 (!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 specular component. + * Compute reflected non-diffuse 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); - } + 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); } - return; -computerr: - objerror(np->mp, WARNING, "compute error"); - return; +#undef lddx } -m_brdf(m, r) /* color a ray which hit a BRDF material */ +int +m_brdf(m, r) /* color a ray that hit a BRDTfunc material */ register OBJREC *m; register RAY *r; { + int hitfront = 1; BRDFDAT nd; - double dtmp; + RAY sr; + double transtest, transdist; + int hasrefl, hastrans; COLOR ctmp; + FVECT vtmp; + register MFUNC *mf; register int i; - - if (m->oargs.nsargs < 2 || m->oargs.nfargs < 4) + /* check arguments */ + if (m->oargs.nsargs < 10 | m->oargs.nfargs < 9) 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); + /* 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); nd.pdot = raynormal(nd.pnorm, r); /* perturb normal */ - multcolor(nd.mcolor, r->pcol); /* modify material color */ - r->rt = r->rot; /* default ray length */ + 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); + transtest = 0; + transdist = r->rot; + 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, r, TRANS, bright(ctmp)) == 0) { + if (!(r->crtype & SHADOW) && + DOT(r->pert,r->pert) > FTINY*FTINY) { + for (i = 0; i < 3; i++) /* perturb direction */ + sr.rdir[i] = r->rdir[i] - .75*r->pert[i]; + if (normalize(sr.rdir) == 0.0) { + objerror(m, WARNING, "illegal perturbation"); + VCOPY(sr.rdir, r->rdir); + } + } else { + VCOPY(sr.rdir, r->rdir); + transtest = 2; + } + rayvalue(&sr); + multcolor(sr.rcol, ctmp); + addcolor(r->rcol, sr.rcol); + transtest *= bright(sr.rcol); + transdist = r->rot + sr.rt; + } + if (r->crtype & SHADOW) /* the rest is shadow */ + return(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, r, REFLECTED, bright(ctmp)) == 0) { + for (i = 0; i < 3; i++) + sr.rdir[i] = r->rdir[i] + 2.0*nd.pdot*nd.pnorm[i]; + rayvalue(&sr); + multcolor(sr.rcol, ctmp); + addcolor(r->rcol, sr.rcol); + } + /* compute ambient */ + if (hasrefl) { + if (!hitfront) + flipsurface(r); + ambient(ctmp, r, nd.pnorm); + multcolor(ctmp, nd.rdiff); + 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]; + ambient(ctmp, r, vtmp); + multcolor(ctmp, nd.tdiff); + addcolor(r->rcol, ctmp); + if (hitfront) + flipsurface(r); + } + if (hasrefl | hastrans || m->oargs.sarg[6][0] != '0') + direct(r, dirbrdf, &nd); /* add direct component */ + /* check distance */ + if (transtest > bright(r->rcol)) + r->rt = transdist; + + return(1); +} + + + +int +m_brdf2(m, r) /* 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]; - - 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); + /* 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); } - /* diffuse reflection */ - nd.rdiff = 1.0 - nd.rspec; + /* 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.rdiff > FTINY) { - ambient(ctmp, r); + if (nd.trans < 1.0-FTINY) { + ambient(ctmp, r, nd.pnorm); + scalecolor(ctmp, 1.0-nd.trans); multcolor(ctmp, nd.mcolor); /* modified by material color */ 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]; + ambient(ctmp, r, vtmp); + scalecolor(ctmp, nd.trans); + multcolor(ctmp, nd.mcolor); + addcolor(r->rcol, ctmp); + flipsurface(r); + } /* add direct component */ direct(r, dirbrdf, &nd); + + return(1); +} + + +int +setbrdfunc(np) /* set up brdf function and variables */ +register BRDFDAT *np; +{ + FVECT vec; + + if (setfunc(np->mp, np->pr) == 0) + return(0); /* it's OK, setfunc says we're done */ + /* else (re)assign special variables */ + multv3(vec, np->pnorm, funcxf.xfm); + varset("NxP", '=', vec[0]/funcxf.sca); + varset("NyP", '=', vec[1]/funcxf.sca); + varset("NzP", '=', vec[2]/funcxf.sca); + varset("RdotP", '=', np->pdot <= -1.0 ? -1.0 : + np->pdot >= 1.0 ? 1.0 : np->pdot); + varset("CrP", '=', colval(np->mcolor,RED)); + varset("CgP", '=', colval(np->mcolor,GRN)); + varset("CbP", '=', colval(np->mcolor,BLU)); + return(1); }