src/rt/glass.c

#ifndef lint
static const char RCSid[] = "$Id: glass.c,v 2.28 2019/04/19 19:01:32 greg Exp $";
#endif
/*
 *  glass.c - simpler shading function for thin glass surfaces.
 */

#include "copyright.h"

#include  "ray.h"
#include  "otypes.h"
#include  "rtotypes.h"
#include  "pmapmat.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 */


int
m_glass(                /* color a ray which hit a thin glass surface */
        OBJREC  *m,
        RAY  *r
)
{
        COLOR  mcolor;
        SCOLOR  scoef;
        double  ctemp[3];
        double  pdot;
        FVECT  pnorm;
        double  rindex=0, cos2;
        int  hastexture, hastrans;
        double  d, r1e, r1m;
        RAY  p;
        int  i;

        /* PMAP: skip refracted shadow or ambient ray if accounted for in 
           photon map */
        if (shadowRayInPmap(r) || ambRayInPmap(r))
                return(1);
                                                /* 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");
                                                /* check back face visibility */
        if (!backvis && r->rod <= 0.0) {
                raytrans(r);
                return(1);
        }
                                                /* check transmission */
        setcolor(mcolor, m->oargs.farg[0], m->oargs.farg[1], m->oargs.farg[2]);
        if ((hastrans = (intens(mcolor) > 1e-15))) {
                for (i = 0; i < 3; i++)
                        if (colval(mcolor,i) < 1e-15)
                                colval(mcolor,i) = 1e-15;
        } else if (r->crtype & SHADOW)
                return(1);
                                                /* get modifiers */
        raytexture(r, m->omod);
        if (r->rod < 0.0)                       /* reorient if necessary */
                flipsurface(r);
                                                /* perturb normal */
        hastexture = (DOT(r->pert,r->pert) > FTINY*FTINY);
        if (hastexture) {
                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) );
        if (hastrans)
                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 transmission */
        if (hastrans) {
                for (i = 0; i < 3; i++) {
                        d = colval(mcolor, i);
                        ctemp[i] = .5*(1.0-r1e)*(1.0-r1e)*d /
                                                        (1.0-r1e*r1e*d*d) +
                                        .5*(1.0-r1m)*(1.0-r1m)*d /
                                                        (1.0-r1m*r1m*d*d);
                }
                setscolor(scoef, ctemp[RED], ctemp[GRN], ctemp[BLU]);
                smultscolor(scoef, r->pcol);    /* modify by pattern */
                                                /* transmitted ray */
                if (rayorigin(&p, TRANS, r, scoef) == 0) {
                        if (!(r->crtype & (SHADOW|AMBIENT)) && hastexture) {
                                VSUM(p.rdir, r->rdir, r->pert, 2.*(1.-rindex));
                                if (normalize(p.rdir) == 0.0) {
                                        objerror(m, WARNING, "bad perturbation");
                                        VCOPY(p.rdir, r->rdir);
                                }
                        } else {
                                VCOPY(p.rdir, r->rdir);
                        }
                        rayvalue(&p);
                        smultscolor(p.rcol, p.rcoef);
                        saddscolor(r->rcol, p.rcol);
                        if (!hastexture || r->crtype & (SHADOW|AMBIENT))
                                r->rxt = r->rot + raydistance(&p);
                }
        }
        if (r->crtype & SHADOW)                 /* skip reflected ray */
                return(1);
                                                /* compute reflectance */
        for (i = 0; i < 3; i++) {
                d = colval(mcolor, i);
                d *= d;
                ctemp[i] = .5*r1e*(1.0+(1.0-2.0*r1e)*d)/(1.0-r1e*r1e*d) +
                                .5*r1m*(1.0+(1.0-2.0*r1m)*d)/(1.0-r1m*r1m*d);
        }
        setscolor(scoef, ctemp[RED], ctemp[GRN], ctemp[BLU]);
                                                /* reflected ray */
        if (rayorigin(&p, REFLECTED, r, scoef) == 0) {
                VSUM(p.rdir, r->rdir, pnorm, 2.*pdot);
                checknorm(p.rdir);
                rayvalue(&p);
                smultscolor(p.rcol, p.rcoef);
                copyscolor(r->mcol, p.rcol);
                saddscolor(r->rcol, p.rcol);
                r->rmt = r->rot;
                if (r->ro != NULL && isflat(r->ro->otype) &&
                                !hastexture | (r->crtype & AMBIENT))
                        r->rmt += raydistance(&p);
        }
        return(1);
}
Revision:	2.29
Committed:	Wed Nov 15 18:02:52 2023 UTC (6 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 2.28:	+20 -16 lines
Log Message:	feat(rpict,rtrace,rcontrib,rtpict): Hyperspectral rendering (except photon map)
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.29	static const char RCSid[] = "$Id: glass.c,v 2.28 2019/04/19 19:01:32 greg 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.23	#include "pmapmat.h"
14	greg	2.8
15	greg	1.1	/*
16			* This definition of glass provides for a quick calculation
17			* using a single surface where two closely spaced parallel
18			* dielectric surfaces would otherwise be used. The chief
19			* advantage to using this material is speed, since internal
20			* reflections are avoided.
21			*
22			* The specification for glass is as follows:
23			*
24			* modifier glass id
25			* 0
26			* 0
27	greg	2.9	* 3+ red grn blu [refractive_index]
28	greg	1.1	*
29			* The color is used for the transmission at normal incidence.
30	greg	2.5	* To compute transmissivity (tn) from transmittance (Tn) use:
31	greg	1.1	*
32			* tn = (sqrt(.8402528435+.0072522239TnTn)-.9166530661)/.0036261119/Tn
33			*
34	greg	2.5	* The transmissivity of standard 88% transmittance glass is 0.96.
35	greg	1.12	* A refractive index other than the default can be used by giving
36			* it as the fourth real argument. The above formula no longer applies.
37			*
38	greg	1.1	* If we appear to hit the back side of the surface, then we
39			* turn the normal around.
40			*/
41
42			#define RINDEX 1.52 /* refractive index of glass */
43
44
45	greg	2.22	int
46	schorsch	2.15	m_glass( /* color a ray which hit a thin glass surface */
47			OBJREC *m,
48	greg	2.22	RAY *r
49	schorsch	2.15	)
50	greg	1.1	{
51			COLOR mcolor;
52	greg	2.29	SCOLOR scoef;
53			double ctemp[3];
54	greg	1.1	double pdot;
55			FVECT pnorm;
56	greg	2.20	double rindex=0, cos2;
57	greg	2.17	int hastexture, hastrans;
58	greg	1.11	double d, r1e, r1m;
59	greg	1.1	RAY p;
60	greg	2.22	int i;
61	greg	2.23
62	rschregle	2.24	/* PMAP: skip refracted shadow or ambient ray if accounted for in
63			photon map */
64	greg	2.26	if (shadowRayInPmap(r) \|\| ambRayInPmap(r))
65	greg	2.23	return(1);
66	greg	1.12	/* check arguments */
67			if (m->oargs.nfargs == 3)
68			rindex = RINDEX; /* default value of n */
69			else if (m->oargs.nfargs == 4)
70			rindex = m->oargs.farg[3]; /* use their value */
71			else
72	greg	1.1	objerror(m, USER, "bad arguments");
73	greg	2.21	/* check back face visibility */
74			if (!backvis && r->rod <= 0.0) {
75			raytrans(r);
76			return(1);
77			}
78	greg	2.17	/* check transmission */
79	greg	1.1	setcolor(mcolor, m->oargs.farg[0], m->oargs.farg[1], m->oargs.farg[2]);
80	greg	2.17	if ((hastrans = (intens(mcolor) > 1e-15))) {
81			for (i = 0; i < 3; i++)
82			if (colval(mcolor,i) < 1e-15)
83			colval(mcolor,i) = 1e-15;
84			} else if (r->crtype & SHADOW)
85			return(1);
86	greg	2.12	/* get modifiers */
87			raytexture(r, m->omod);
88	greg	1.1	if (r->rod < 0.0) /* reorient if necessary */
89			flipsurface(r);
90	greg	2.12	/* perturb normal */
91	greg	2.29	hastexture = (DOT(r->pert,r->pert) > FTINY*FTINY);
92			if (hastexture) {
93	greg	2.8	pdot = raynormal(pnorm, r);
94	greg	2.13	} else {
95	greg	2.8	VCOPY(pnorm, r->ron);
96			pdot = r->rod;
97			}
98	greg	1.1	/* angular transmission */
99	greg	1.12	cos2 = sqrt( (1.0-1.0/(rindex*rindex)) +
100			pdotpdot/(rindexrindex) );
101	greg	2.17	if (hastrans)
102			setcolor(mcolor, pow(colval(mcolor,RED), 1.0/cos2),
103			pow(colval(mcolor,GRN), 1.0/cos2),
104			pow(colval(mcolor,BLU), 1.0/cos2));
105	greg	1.1
106			/* compute reflection */
107	greg	1.12	r1e = (pdot - rindexcos2) / (pdot + rindexcos2);
108	greg	1.11	r1e *= r1e;
109	greg	1.12	r1m = (1.0/pdot - rindex/cos2) / (1.0/pdot + rindex/cos2);
110	greg	1.11	r1m *= r1m;
111	greg	2.17	/* compute transmission */
112			if (hastrans) {
113			for (i = 0; i < 3; i++) {
114			d = colval(mcolor, i);
115	greg	2.29	ctemp[i] = .5(1.0-r1e)(1.0-r1e)*d /
116			(1.0-r1er1ed*d) +
117			.5(1.0-r1m)(1.0-r1m)*d /
118	greg	2.17	(1.0-r1mr1md*d);
119			}
120	greg	2.29	setscolor(scoef, ctemp[RED], ctemp[GRN], ctemp[BLU]);
121			smultscolor(scoef, r->pcol); /* modify by pattern */
122	greg	1.1	/* transmitted ray */
123	greg	2.29	if (rayorigin(&p, TRANS, r, scoef) == 0) {
124	greg	2.22	if (!(r->crtype & (SHADOW\|AMBIENT)) && hastexture) {
125	greg	2.19	VSUM(p.rdir, r->rdir, r->pert, 2.*(1.-rindex));
126	greg	2.17	if (normalize(p.rdir) == 0.0) {
127			objerror(m, WARNING, "bad perturbation");
128			VCOPY(p.rdir, r->rdir);
129			}
130			} else {
131	greg	2.4	VCOPY(p.rdir, r->rdir);
132			}
133	greg	2.17	rayvalue(&p);
134	greg	2.29	smultscolor(p.rcol, p.rcoef);
135			saddscolor(r->rcol, p.rcol);
136	greg	2.27	if (!hastexture \|\| r->crtype & (SHADOW\|AMBIENT))
137			r->rxt = r->rot + raydistance(&p);
138	greg	1.8	}
139	greg	1.1	}
140	greg	2.27	if (r->crtype & SHADOW) /* skip reflected ray */
141	greg	2.7	return(1);
142	greg	1.1	/* compute reflectance */
143			for (i = 0; i < 3; i++) {
144			d = colval(mcolor, i);
145			d *= d;
146	greg	2.29	ctemp[i] = .5r1e(1.0+(1.0-2.0r1e)d)/(1.0-r1er1ed) +
147			.5r1m(1.0+(1.0-2.0r1m)d)/(1.0-r1mr1md);
148	greg	1.1	}
149	greg	2.29	setscolor(scoef, ctemp[RED], ctemp[GRN], ctemp[BLU]);
150	greg	1.1	/* reflected ray */
151	greg	2.29	if (rayorigin(&p, REFLECTED, r, scoef) == 0) {
152	greg	2.19	VSUM(p.rdir, r->rdir, pnorm, 2.*pdot);
153	greg	2.18	checknorm(p.rdir);
154	greg	1.1	rayvalue(&p);
155	greg	2.29	smultscolor(p.rcol, p.rcoef);
156			copyscolor(r->mcol, p.rcol);
157			saddscolor(r->rcol, p.rcol);
158	greg	2.28	r->rmt = r->rot;
159	greg	2.22	if (r->ro != NULL && isflat(r->ro->otype) &&
160	greg	2.27	!hastexture \| (r->crtype & AMBIENT))
161	greg	2.28	r->rmt += raydistance(&p);
162	greg	1.1	}
163	greg	2.7	return(1);
164	greg	1.1	}