src/rt/glass.c

#ifndef lint
static const char RCSid[] = "$Id: glass.c,v 2.14 2003/07/27 22:12:03 schorsch Exp $";
#endif
/*
 *  glass.c - simpler shading function for thin glass surfaces.
 */

#include "copyright.h"

#include  "ray.h"
#include  "otypes.h"
#include  "rtotypes.h"

/*
 *  This definition of glass provides for a quick calculation
 *  using a single surface where two closely spaced parallel
 *  dielectric surfaces would otherwise be used.  The chief
 *  advantage to using this material is speed, since internal
 *  reflections are avoided.
 *
 *  The specification for glass is as follows:
 *
 *      modifier glass id
 *      0
 *      0
 *      3+ red grn blu [refractive_index]
 *
 *  The color is used for the transmission at normal incidence.
 *  To compute transmissivity (tn) from transmittance (Tn) use:
 *
 *      tn = (sqrt(.8402528435+.0072522239*Tn*Tn)-.9166530661)/.0036261119/Tn
 *
 *  The transmissivity of standard 88% transmittance glass is 0.96.
 *  A refractive index other than the default can be used by giving
 *  it as the fourth real argument.  The above formula no longer applies.
 *
 *  If we appear to hit the back side of the surface, then we
 *  turn the normal around.
 */

#define  RINDEX         1.52            /* refractive index of glass */


extern int
m_glass(                /* color a ray which hit a thin glass surface */
        OBJREC  *m,
        register RAY  *r
)
{
        COLOR  mcolor;
        double  pdot;
        FVECT  pnorm;
        double  rindex, cos2;
        COLOR  trans, refl;
        int  hastexture;
        double  d, r1e, r1m;
        double  transtest, transdist;
        double  mirtest, mirdist;
        RAY  p;
        register int  i;
                                                /* check arguments */
        if (m->oargs.nfargs == 3)
                rindex = RINDEX;                /* default value of n */
        else if (m->oargs.nfargs == 4)
                rindex = m->oargs.farg[3];      /* use their value */
        else
                objerror(m, USER, "bad arguments");

        setcolor(mcolor, m->oargs.farg[0], m->oargs.farg[1], m->oargs.farg[2]);

                                                /* get modifiers */
        raytexture(r, m->omod);
        if (r->rod < 0.0)                       /* reorient if necessary */
                flipsurface(r);
        mirtest = transtest = 0;
        mirdist = transdist = r->rot;
                                                /* perturb normal */
        if ( (hastexture = (DOT(r->pert,r->pert) > FTINY*FTINY)) ) {
                pdot = raynormal(pnorm, r);
        } else {
                VCOPY(pnorm, r->ron);
                pdot = r->rod;
        }
                                                /* angular transmission */
        cos2 = sqrt( (1.0-1.0/(rindex*rindex)) +
                     pdot*pdot/(rindex*rindex) );
        setcolor(mcolor, pow(colval(mcolor,RED), 1.0/cos2),
                         pow(colval(mcolor,GRN), 1.0/cos2),
                         pow(colval(mcolor,BLU), 1.0/cos2));

                                                /* compute reflection */
        r1e = (pdot - rindex*cos2) / (pdot + rindex*cos2);
        r1e *= r1e;
        r1m = (1.0/pdot - rindex/cos2) / (1.0/pdot + rindex/cos2);
        r1m *= r1m;
                                                /* compute transmittance */
        for (i = 0; i < 3; i++) {
                d = colval(mcolor, i);
                colval(trans,i) = .5*(1.0-r1e)*(1.0-r1e)*d/(1.0-r1e*r1e*d*d);
                colval(trans,i) += .5*(1.0-r1m)*(1.0-r1m)*d/(1.0-r1m*r1m*d*d);
        }
                                                /* transmitted ray */
        if (rayorigin(&p, r, TRANS, bright(trans)) == 0) {
                if (!(r->crtype & SHADOW) && hastexture) {
                        for (i = 0; i < 3; i++)         /* perturb direction */
                                p.rdir[i] = r->rdir[i] +
                                                2.*(1.-rindex)*r->pert[i];
                        if (normalize(p.rdir) == 0.0) {
                                objerror(m, WARNING, "bad perturbation");
                                VCOPY(p.rdir, r->rdir);
                        }
                } else {
                        VCOPY(p.rdir, r->rdir);
                        transtest = 2;
                }
                rayvalue(&p);
                multcolor(p.rcol, r->pcol);     /* modify */
                multcolor(p.rcol, trans);
                addcolor(r->rcol, p.rcol);
                transtest *= bright(p.rcol);
                transdist = r->rot + p.rt;
        }

        if (r->crtype & SHADOW) {               /* skip reflected ray */
                r->rt = transdist;
                return(1);
        }
                                                /* compute reflectance */
        for (i = 0; i < 3; i++) {
                d = colval(mcolor, i);
                d *= d;
                colval(refl,i) = .5*r1e*(1.0+(1.0-2.0*r1e)*d)/(1.0-r1e*r1e*d);
                colval(refl,i) += .5*r1m*(1.0+(1.0-2.0*r1m)*d)/(1.0-r1m*r1m*d);
        }
                                                /* reflected ray */
        if (rayorigin(&p, r, REFLECTED, bright(refl)) == 0) {
                for (i = 0; i < 3; i++)
                        p.rdir[i] = r->rdir[i] + 2.0*pdot*pnorm[i];
                rayvalue(&p);
                multcolor(p.rcol, refl);
                addcolor(r->rcol, p.rcol);
                if (!hastexture && r->ro != NULL && isflat(r->ro->otype)) {
                        mirtest = 2.0*bright(p.rcol);
                        mirdist = r->rot + p.rt;
                }
        }
                                        /* check distance */
        d = bright(r->rcol);
        if (transtest > d)
                r->rt = transdist;
        else if (mirtest > d)
                r->rt = mirdist;
        return(1);
}
Revision:	2.15
Committed:	Tue Mar 30 16:13:01 2004 UTC (20 years, 1 month ago) by schorsch
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad3R6, rad3R6P1
Changes since 2.14:	+7 -5 lines
Log Message:	Continued ANSIfication. There are only bits and pieces left now.
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	schorsch	2.15	static const char RCSid[] = "$Id: glass.c,v 2.14 2003/07/27 22:12:03 schorsch Exp $";
3	greg	1.1	#endif
4			/*
5			* glass.c - simpler shading function for thin glass surfaces.
6	greg	2.10	*/
7
8	greg	2.11	#include "copyright.h"
9	greg	1.1
10			#include "ray.h"
11	greg	2.8	#include "otypes.h"
12	schorsch	2.15	#include "rtotypes.h"
13	greg	2.8
14	greg	1.1	/*
15			* This definition of glass provides for a quick calculation
16			* using a single surface where two closely spaced parallel
17			* dielectric surfaces would otherwise be used. The chief
18			* advantage to using this material is speed, since internal
19			* reflections are avoided.
20			*
21			* The specification for glass is as follows:
22			*
23			* modifier glass id
24			* 0
25			* 0
26	greg	2.9	* 3+ red grn blu [refractive_index]
27	greg	1.1	*
28			* The color is used for the transmission at normal incidence.
29	greg	2.5	* To compute transmissivity (tn) from transmittance (Tn) use:
30	greg	1.1	*
31			* tn = (sqrt(.8402528435+.0072522239TnTn)-.9166530661)/.0036261119/Tn
32			*
33	greg	2.5	* The transmissivity of standard 88% transmittance glass is 0.96.
34	greg	1.12	* A refractive index other than the default can be used by giving
35			* it as the fourth real argument. The above formula no longer applies.
36			*
37	greg	1.1	* If we appear to hit the back side of the surface, then we
38			* turn the normal around.
39			*/
40
41			#define RINDEX 1.52 /* refractive index of glass */
42
43
44	schorsch	2.15	extern int
45			m_glass( /* color a ray which hit a thin glass surface */
46			OBJREC *m,
47			register RAY *r
48			)
49	greg	1.1	{
50			COLOR mcolor;
51			double pdot;
52			FVECT pnorm;
53	greg	1.12	double rindex, cos2;
54	greg	1.1	COLOR trans, refl;
55	greg	2.8	int hastexture;
56	greg	1.11	double d, r1e, r1m;
57	greg	1.7	double transtest, transdist;
58	greg	2.8	double mirtest, mirdist;
59	greg	1.1	RAY p;
60			register int i;
61	greg	1.12	/* check arguments */
62			if (m->oargs.nfargs == 3)
63			rindex = RINDEX; /* default value of n */
64			else if (m->oargs.nfargs == 4)
65			rindex = m->oargs.farg[3]; /* use their value */
66			else
67	greg	1.1	objerror(m, USER, "bad arguments");
68
69			setcolor(mcolor, m->oargs.farg[0], m->oargs.farg[1], m->oargs.farg[2]);
70
71	greg	2.12	/* get modifiers */
72			raytexture(r, m->omod);
73	greg	1.1	if (r->rod < 0.0) /* reorient if necessary */
74			flipsurface(r);
75	greg	2.8	mirtest = transtest = 0;
76			mirdist = transdist = r->rot;
77	greg	2.12	/* perturb normal */
78	schorsch	2.14	if ( (hastexture = (DOT(r->pert,r->pert) > FTINY*FTINY)) ) {
79	greg	2.8	pdot = raynormal(pnorm, r);
80	greg	2.13	} else {
81	greg	2.8	VCOPY(pnorm, r->ron);
82			pdot = r->rod;
83			}
84	greg	1.1	/* angular transmission */
85	greg	1.12	cos2 = sqrt( (1.0-1.0/(rindex*rindex)) +
86			pdotpdot/(rindexrindex) );
87	greg	1.1	setcolor(mcolor, pow(colval(mcolor,RED), 1.0/cos2),
88			pow(colval(mcolor,GRN), 1.0/cos2),
89			pow(colval(mcolor,BLU), 1.0/cos2));
90
91			/* compute reflection */
92	greg	1.12	r1e = (pdot - rindexcos2) / (pdot + rindexcos2);
93	greg	1.11	r1e *= r1e;
94	greg	1.12	r1m = (1.0/pdot - rindex/cos2) / (1.0/pdot + rindex/cos2);
95	greg	1.11	r1m *= r1m;
96	greg	1.1	/* compute transmittance */
97			for (i = 0; i < 3; i++) {
98			d = colval(mcolor, i);
99	greg	1.11	colval(trans,i) = .5(1.0-r1e)(1.0-r1e)d/(1.0-r1er1edd);
100			colval(trans,i) += .5(1.0-r1m)(1.0-r1m)d/(1.0-r1mr1mdd);
101	greg	1.1	}
102			/* transmitted ray */
103	greg	1.2	if (rayorigin(&p, r, TRANS, bright(trans)) == 0) {
104	greg	2.8	if (!(r->crtype & SHADOW) && hastexture) {
105	greg	1.7	for (i = 0; i < 3; i++) /* perturb direction */
106	greg	2.2	p.rdir[i] = r->rdir[i] +
107			2.(1.-rindex)r->pert[i];
108	greg	2.4	if (normalize(p.rdir) == 0.0) {
109			objerror(m, WARNING, "bad perturbation");
110			VCOPY(p.rdir, r->rdir);
111			}
112	greg	1.8	} else {
113			VCOPY(p.rdir, r->rdir);
114	greg	1.7	transtest = 2;
115	greg	1.8	}
116	greg	1.1	rayvalue(&p);
117			multcolor(p.rcol, r->pcol); /* modify */
118			multcolor(p.rcol, trans);
119			addcolor(r->rcol, p.rcol);
120	greg	1.7	transtest *= bright(p.rcol);
121			transdist = r->rot + p.rt;
122	greg	1.1	}
123	greg	1.3
124	greg	2.8	if (r->crtype & SHADOW) { /* skip reflected ray */
125			r->rt = transdist;
126	greg	2.7	return(1);
127	greg	2.8	}
128	greg	1.1	/* compute reflectance */
129			for (i = 0; i < 3; i++) {
130			d = colval(mcolor, i);
131			d *= d;
132	greg	1.11	colval(refl,i) = .5r1e(1.0+(1.0-2.0r1e)d)/(1.0-r1er1ed);
133			colval(refl,i) += .5r1m(1.0+(1.0-2.0r1m)d)/(1.0-r1mr1md);
134	greg	1.1	}
135			/* reflected ray */
136	greg	1.2	if (rayorigin(&p, r, REFLECTED, bright(refl)) == 0) {
137	greg	1.1	for (i = 0; i < 3; i++)
138			p.rdir[i] = r->rdir[i] + 2.0pdotpnorm[i];
139			rayvalue(&p);
140			multcolor(p.rcol, refl);
141			addcolor(r->rcol, p.rcol);
142	greg	2.8	if (!hastexture && r->ro != NULL && isflat(r->ro->otype)) {
143			mirtest = 2.0*bright(p.rcol);
144			mirdist = r->rot + p.rt;
145			}
146	greg	1.1	}
147	greg	2.8	/* check distance */
148			d = bright(r->rcol);
149			if (transtest > d)
150	greg	1.7	r->rt = transdist;
151	greg	2.8	else if (mirtest > d)
152			r->rt = mirdist;
153	greg	2.7	return(1);
154	greg	1.1	}