src/rt/m_direct.c

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

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

/*
 * Routines for light-redirecting materials and
 *   their associated virtual light sources
 */

#include  "ray.h"

#include  "otypes.h"

#include  "source.h"

#include  "func.h"

/*
 * The arguments for MAT_DIRECT1 are:
 *
 *      5+ coef1 dx1 dy1 dz1 funcfile transform..
 *      0
 *      n A1 A2 .. An
 *
 * The arguments for MAT_DIRECT2 are:
 *
 *      9+ coef1 dx1 dy1 dz1 coef2 dx2 dy2 dz2 funcfile transform..
 *      0
 *      n A1 A2 .. An
 */


int  dir_proj();
VSMATERIAL  direct1_vs = {dir_proj, 1};
VSMATERIAL  direct2_vs = {dir_proj, 2};

#define getdfunc(m)     ( (m)->otype == MAT_DIRECT1 ? \
                                getfunc(m, 4, 0xf, 1) : \
                                getfunc(m, 8, 0xff, 1) )


m_direct(m, r)                  /* shade redirected ray */
register OBJREC  *m;
register RAY  *r;
{
                                        /* check if source ray */
        if (r->rsrc >= 0 && source[r->rsrc].so != r->ro)
                return;                         /* got the wrong guy */
                                        /* compute first projection */
        if (m->otype == MAT_DIRECT1 ||
                        (r->rsrc < 0 || source[r->rsrc].sa.sv.pn == 0))
                redirect(m, r, 0);
                                        /* compute second projection */
        if (m->otype == MAT_DIRECT2 &&
                        (r->rsrc < 0 || source[r->rsrc].sa.sv.pn == 1))
                redirect(m, r, 1);
}


redirect(m, r, n)               /* compute n'th ray redirection */
OBJREC  *m;
RAY  *r;
int  n;
{
        MFUNC  *mf;
        register EPNODE  **va;
        FVECT  nsdir;
        RAY  nr;
        double  coef;
        register int  j;
                                        /* set up function */
        mf = getdfunc(m);
        setfunc(m, r);
                                        /* assign direction variable */
        if (r->rsrc >= 0) {
                register SRCREC  *sp = source + source[r->rsrc].sa.sv.sn;

                if (sp->sflags & SDISTANT)
                        VCOPY(nsdir, sp->sloc);
                else {
                        for (j = 0; j < 3; j++)
                                nsdir[j] = sp->sloc[j] - r->rop[j];
                        normalize(nsdir);
                }
                if (r->rox != NULL)
                        multv3(nsdir, nsdir, r->rox->b.xfm);
                if (mf->b != &unitxf)
                        multv3(nsdir, nsdir, mf->b->xfm);
        } else
                nsdir[0] = nsdir[1] = nsdir[2] = 0.0;
        varset("DxA", '=', nsdir[0]);
        varset("DyA", '=', nsdir[1]);
        varset("DzA", '=', nsdir[2]);
                                        /* compute coefficient */
        errno = 0;
        va = mf->ep + 4*n;
        coef = evalue(va[0]);
        if (errno)
                goto computerr;
        if (coef <= FTINY || rayorigin(&nr, r, TRANS, coef) < 0)
                return(0);
        va++;                           /* compute direction */
        for (j = 0; j < 3; j++) {
                nr.rdir[j] = evalue(va[j]);
                if (errno)
                        goto computerr;
        }
        if (mf->f != &unitxf)
                multv3(nr.rdir, nr.rdir, mf->f->xfm);
        if (r->rox != NULL)
                multv3(nr.rdir, nr.rdir, r->rox->f.xfm);
        if (normalize(nr.rdir) == 0.0)
                goto computerr;
                                        /* compute value */
        if (r->rsrc >= 0)
                nr.rsrc = source[r->rsrc].sa.sv.sn;
        rayvalue(&nr);
        scalecolor(nr.rcol, coef);
        addcolor(r->rcol, nr.rcol);
        return(1);
computerr:
        objerror(m, WARNING, "compute error");
        return(-1);
}


dir_proj(pm, o, s, n)           /* compute a director's projection */
MAT4  pm;
OBJREC  *o;
SRCREC  *s;
int  n;
{
        RAY  tr;
        OBJREC  *m;
        MFUNC  *mf;
        EPNODE  **va;
        FVECT  cent, newdir, nv, h;
        double  coef, olddot, newdot, od;
        register int  i, j;
                                /* initialize test ray */
        getmaxdisk(cent, o);
        if (s->sflags & SDISTANT)
                for (i = 0; i < 3; i++) {
                        tr.rdir[i] = -s->sloc[i];
                        tr.rorg[i] = cent[i] - tr.rdir[i];
                }
        else {
                for (i = 0; i < 3; i++) {
                        tr.rdir[i] = cent[i] - s->sloc[i];
                        tr.rorg[i] = s->sloc[i];
                }
                if (normalize(tr.rdir) == 0.0)
                        return(0);              /* at source! */
        }
        od = getplaneq(nv, o);
        olddot = DOT(tr.rdir, nv);
        if (olddot <= FTINY && olddot >= -FTINY)
                return(0);              /* old dir parallels plane */
        rayorigin(&tr, NULL, PRIMARY, 1.0);
        if (!(*ofun[o->otype].funp)(o, &tr))
                return(0);              /* no intersection! */
                                /* compute redirection */
        m = vsmaterial(o);
        mf = getdfunc(m);
        setfunc(m, &tr);
        varset("DxA", '=', 0.0);
        varset("DyA", '=', 0.0);
        varset("DzA", '=', 0.0);
        errno = 0;
        va = mf->ep + 4*n;
        coef = evalue(va[0]);
        if (errno)
                goto computerr;
        if (coef <= FTINY)
                return(0);              /* insignificant */
        va++;
        for (i = 0; i < 3; i++) {
                newdir[i] = evalue(va[i]);
                if (errno)
                        goto computerr;
        }
        if (mf->f != &unitxf)
                multv3(newdir, newdir, mf->f->xfm);
                                        /* normalization unnecessary */
        newdot = DOT(newdir, nv);
        if (newdot <= FTINY && newdot >= -FTINY)
                return(0);              /* new dir parallels plane */
                                /* everything OK -- compute shear */
        for (i = 0; i < 3; i++)
                h[i] = newdir[i]/newdot - tr.rdir[i]/olddot;
        setident4(pm);
        for (j = 0; j < 3; j++) {
                for (i = 0; i < 3; i++)
                        pm[i][j] += nv[i]*h[j];
                pm[3][j] = -od*h[j];
        }
        if (newdot > 0.0 ^ olddot > 0.0)        /* add mirroring */
                for (j = 0; j < 3; j++) {
                        for (i = 0; i < 3; i++)
                                pm[i][j] -= 2.*nv[i]*nv[j];
                        pm[3][j] += 2.*od*nv[j];
                }
        return(1);
computerr:
        objerror(m, WARNING, "projection compute error");
        return(0);
}
Revision:	2.3
Committed:	Fri May 15 09:29:09 1992 UTC (31 years, 11 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.2:	+24 -0 lines
Log Message:	added DxA, DyA and DzA variables for finding source direction
#	User	Rev	Content
1	greg	1.1	/* Copyright (c) 1991 Regents of the University of California */
2
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ LBL";
5			#endif
6
7			/*
8			* Routines for light-redirecting materials and
9			* their associated virtual light sources
10			*/
11
12			#include "ray.h"
13
14			#include "otypes.h"
15
16			#include "source.h"
17
18	greg	2.2	#include "func.h"
19
20	greg	1.1	/*
21			* The arguments for MAT_DIRECT1 are:
22			*
23	greg	1.3	* 5+ coef1 dx1 dy1 dz1 funcfile transform..
24	greg	1.1	* 0
25			* n A1 A2 .. An
26			*
27			* The arguments for MAT_DIRECT2 are:
28			*
29	greg	1.3	* 9+ coef1 dx1 dy1 dz1 coef2 dx2 dy2 dz2 funcfile transform..
30	greg	1.1	* 0
31			* n A1 A2 .. An
32			*/
33
34
35			int dir_proj();
36			VSMATERIAL direct1_vs = {dir_proj, 1};
37			VSMATERIAL direct2_vs = {dir_proj, 2};
38
39	greg	2.2	#define getdfunc(m) ( (m)->otype == MAT_DIRECT1 ? \
40			getfunc(m, 4, 0xf, 1) : \
41			getfunc(m, 8, 0xff, 1) )
42	greg	1.1
43	greg	1.6
44	greg	1.1	m_direct(m, r) /* shade redirected ray */
45			register OBJREC *m;
46			register RAY *r;
47			{
48			/* check if source ray */
49			if (r->rsrc >= 0 && source[r->rsrc].so != r->ro)
50			return; /* got the wrong guy */
51			/* compute first projection */
52			if (m->otype == MAT_DIRECT1 \|\|
53			(r->rsrc < 0 \|\| source[r->rsrc].sa.sv.pn == 0))
54			redirect(m, r, 0);
55			/* compute second projection */
56			if (m->otype == MAT_DIRECT2 &&
57			(r->rsrc < 0 \|\| source[r->rsrc].sa.sv.pn == 1))
58			redirect(m, r, 1);
59			}
60
61
62			redirect(m, r, n) /* compute n'th ray redirection */
63			OBJREC *m;
64			RAY *r;
65			int n;
66			{
67	greg	2.2	MFUNC *mf;
68			register EPNODE **va;
69	greg	2.3	FVECT nsdir;
70	greg	1.1	RAY nr;
71			double coef;
72			register int j;
73			/* set up function */
74	greg	2.2	mf = getdfunc(m);
75			setfunc(m, r);
76	greg	2.3	/* assign direction variable */
77			if (r->rsrc >= 0) {
78			register SRCREC *sp = source + source[r->rsrc].sa.sv.sn;
79
80			if (sp->sflags & SDISTANT)
81			VCOPY(nsdir, sp->sloc);
82			else {
83			for (j = 0; j < 3; j++)
84			nsdir[j] = sp->sloc[j] - r->rop[j];
85			normalize(nsdir);
86			}
87			if (r->rox != NULL)
88			multv3(nsdir, nsdir, r->rox->b.xfm);
89			if (mf->b != &unitxf)
90			multv3(nsdir, nsdir, mf->b->xfm);
91			} else
92			nsdir[0] = nsdir[1] = nsdir[2] = 0.0;
93			varset("DxA", '=', nsdir[0]);
94			varset("DyA", '=', nsdir[1]);
95			varset("DzA", '=', nsdir[2]);
96	greg	1.1	/* compute coefficient */
97			errno = 0;
98	greg	2.2	va = mf->ep + 4*n;
99			coef = evalue(va[0]);
100	greg	1.1	if (errno)
101			goto computerr;
102			if (coef <= FTINY \|\| rayorigin(&nr, r, TRANS, coef) < 0)
103			return(0);
104	greg	2.2	va++; /* compute direction */
105			for (j = 0; j < 3; j++) {
106			nr.rdir[j] = evalue(va[j]);
107			if (errno)
108			goto computerr;
109			}
110			if (mf->f != &unitxf)
111			multv3(nr.rdir, nr.rdir, mf->f->xfm);
112	greg	1.4	if (r->rox != NULL)
113			multv3(nr.rdir, nr.rdir, r->rox->f.xfm);
114			if (normalize(nr.rdir) == 0.0)
115			goto computerr;
116	greg	1.1	/* compute value */
117			if (r->rsrc >= 0)
118			nr.rsrc = source[r->rsrc].sa.sv.sn;
119			rayvalue(&nr);
120			scalecolor(nr.rcol, coef);
121			addcolor(r->rcol, nr.rcol);
122			return(1);
123			computerr:
124			objerror(m, WARNING, "compute error");
125			return(-1);
126			}
127
128
129			dir_proj(pm, o, s, n) /* compute a director's projection */
130			MAT4 pm;
131			OBJREC *o;
132			SRCREC *s;
133			int n;
134			{
135			RAY tr;
136	greg	2.2	OBJREC *m;
137			MFUNC *mf;
138			EPNODE **va;
139	greg	1.1	FVECT cent, newdir, nv, h;
140	greg	2.2	double coef, olddot, newdot, od;
141	greg	1.1	register int i, j;
142			/* initialize test ray */
143			getmaxdisk(cent, o);
144			if (s->sflags & SDISTANT)
145			for (i = 0; i < 3; i++) {
146			tr.rdir[i] = -s->sloc[i];
147			tr.rorg[i] = cent[i] - tr.rdir[i];
148			}
149			else {
150			for (i = 0; i < 3; i++) {
151			tr.rdir[i] = cent[i] - s->sloc[i];
152	greg	1.2	tr.rorg[i] = s->sloc[i];
153	greg	1.1	}
154			if (normalize(tr.rdir) == 0.0)
155			return(0); /* at source! */
156			}
157			od = getplaneq(nv, o);
158			olddot = DOT(tr.rdir, nv);
159			if (olddot <= FTINY && olddot >= -FTINY)
160			return(0); /* old dir parallels plane */
161			rayorigin(&tr, NULL, PRIMARY, 1.0);
162			if (!(*ofun[o->otype].funp)(o, &tr))
163			return(0); /* no intersection! */
164			/* compute redirection */
165	greg	2.2	m = vsmaterial(o);
166			mf = getdfunc(m);
167			setfunc(m, &tr);
168	greg	2.3	varset("DxA", '=', 0.0);
169			varset("DyA", '=', 0.0);
170			varset("DzA", '=', 0.0);
171	greg	1.1	errno = 0;
172	greg	2.2	va = mf->ep + 4*n;
173			coef = evalue(va[0]);
174	greg	1.1	if (errno)
175			goto computerr;
176	greg	2.2	if (coef <= FTINY)
177			return(0); /* insignificant */
178			va++;
179			for (i = 0; i < 3; i++) {
180			newdir[i] = evalue(va[i]);
181			if (errno)
182			goto computerr;
183			}
184			if (mf->f != &unitxf)
185			multv3(newdir, newdir, mf->f->xfm);
186	greg	1.4	/* normalization unnecessary */
187	greg	1.1	newdot = DOT(newdir, nv);
188			if (newdot <= FTINY && newdot >= -FTINY)
189			return(0); /* new dir parallels plane */
190			/* everything OK -- compute shear */
191			for (i = 0; i < 3; i++)
192	greg	1.4	h[i] = newdir[i]/newdot - tr.rdir[i]/olddot;
193	greg	1.1	setident4(pm);
194			for (j = 0; j < 3; j++) {
195			for (i = 0; i < 3; i++)
196			pm[i][j] += nv[i]*h[j];
197			pm[3][j] = -od*h[j];
198			}
199			if (newdot > 0.0 ^ olddot > 0.0) /* add mirroring */
200			for (j = 0; j < 3; j++) {
201			for (i = 0; i < 3; i++)
202			pm[i][j] -= 2.nv[i]nv[j];
203			pm[3][j] += 2.odnv[j];
204			}
205			return(1);
206			computerr:
207			objerror(m, WARNING, "projection compute error");
208			return(0);
209			}