src/rt/virtuals.c

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

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

/*
 * Routines for simulating virtual light sources
 *      Thus far, we only support planar mirrors.
 */

#include  "ray.h"

#include  "octree.h"

#include  "otypes.h"

#include  "source.h"

#include  "random.h"

#define  MINSAMPLES     16              /* minimum number of pretest samples */
#define  STESTMAX       32              /* maximum seeks per sample */


double  getdisk();

static OBJECT  *vobject;                /* virtual source objects */
static int  nvobjects = 0;              /* number of virtual source objects */


markvirtuals()                  /* find and mark virtual sources */
{
        register OBJREC  *o;
        register int  i;
                                        /* check number of direct relays */
        if (directrelay <= 0)
                return;
                                        /* find virtual source objects */
        for (i = 0; i < nobjects; i++) {
                o = objptr(i);
                if (!issurface(o->otype) || o->omod == OVOID)
                        continue;
                if (!isvlight(vsmaterial(o)->otype))
                        continue;
                if (sfun[o->otype].of == NULL ||
                                sfun[o->otype].of->getpleq == NULL) {
                        objerror(o,WARNING,"secondary sources not supported");
                        continue;
                }
                if (nvobjects == 0)
                        vobject = (OBJECT *)malloc(sizeof(OBJECT));
                else
                        vobject = (OBJECT *)realloc((char *)vobject,
                                (unsigned)(nvobjects+1)*sizeof(OBJECT));
                if (vobject == NULL)
                        error(SYSTEM, "out of memory in addvirtuals");
                vobject[nvobjects++] = i;
        }
        if (nvobjects == 0)
                return;
#ifdef DEBUG
        fprintf(stderr, "found %d virtual source objects\n", nvobjects);
#endif
                                        /* append virtual sources */
        for (i = nsources; i-- > 0; )
                addvirtuals(i, directrelay);
                                        /* done with our object list */
        free((char *)vobject);
        nvobjects = 0;
}


addvirtuals(sn, nr)             /* add virtuals associated with source */
int  sn;
int  nr;
{
        register int  i;
                                /* check relay limit first */
        if (nr <= 0)
                return;
        if (source[sn].sflags & SSKIP)
                return;
                                /* check each virtual object for projection */
        for (i = 0; i < nvobjects; i++)
                                        /* vproject() calls us recursively */
                vproject(objptr(vobject[i]), sn, nr-1);
}


vproject(o, sn, n)              /* create projected source(s) if they exist */
OBJREC  *o;
int  sn;
int  n;
{
        register int  i;
        register VSMATERIAL  *vsmat;
        MAT4  proj;
        int  ns;

        if (o == source[sn].so) /* objects cannot project themselves */
                return;
                                /* get virtual source material */
        vsmat = sfun[vsmaterial(o)->otype].mf;
                                /* project virtual sources */
        for (i = 0; i < vsmat->nproj; i++)
                if ((*vsmat->vproj)(proj, o, &source[sn], i))
                        if ((ns = makevsrc(o, sn, proj)) >= 0) {
                                source[ns].sa.sv.pn = i;
#ifdef DEBUG
                                virtverb(ns, stderr);
#endif
                                addvirtuals(ns, n);
                        }
}


OBJREC *
vsmaterial(o)                   /* get virtual source material pointer */
OBJREC  *o;
{
        register int  i;
        register OBJREC  *m;

        i = o->omod;
        m = objptr(i);
        if (m->otype != MAT_ILLUM || m->oargs.nsargs < 1 ||
                        !strcmp(m->oargs.sarg[0], VOIDID) ||
                        (i = modifier(m->oargs.sarg[0])) == OVOID)
                return(m);              /* direct modifier */
        return(objptr(i));              /* illum alternate */
}


int
makevsrc(op, sn, pm)            /* make virtual source if reasonable */
OBJREC  *op;
register int  sn;
MAT4  pm;
{
        FVECT  nsloc, nsnorm, ocent, v;
        double  maxrad2, d;
        int  nsflags;
        SPOT  theirspot, ourspot;
        register int  i;

        nsflags = source[sn].sflags | (SVIRTUAL|SSPOT|SFOLLOW);
                                        /* get object center and max. radius */
        maxrad2 = getdisk(ocent, op, sn);
        if (maxrad2 <= FTINY)                   /* too small? */
                return(-1);
                                        /* get location and spot */
        if (source[sn].sflags & SDISTANT) {             /* distant source */
                if (source[sn].sflags & SPROX)
                        return(-1);             /* should never get here! */
                multv3(nsloc, source[sn].sloc, pm);
                normalize(nsloc);
                VCOPY(ourspot.aim, ocent);
                ourspot.siz = PI*maxrad2;
                ourspot.flen = 0.;
                if (source[sn].sflags & SSPOT) {
                        multp3(theirspot.aim, source[sn].sl.s->aim, pm);
                                                /* adjust for source size */
                        d = sqrt(dist2(ourspot.aim, theirspot.aim));
                        d = sqrt(source[sn].sl.s->siz/PI) + d*source[sn].srad;
                        theirspot.siz = PI*d*d;
                        ourspot.flen = theirspot.flen = source[sn].sl.s->flen;
                        d = ourspot.siz;
                        if (!commonbeam(&ourspot, &theirspot, nsloc))
                                return(-1);     /* no overlap */
                        if (ourspot.siz < d-FTINY) {    /* it shrunk */
                                d = beamdisk(v, op, &ourspot, nsloc);
                                if (d <= FTINY)
                                        return(-1);
                                if (d < maxrad2) {
                                        maxrad2 = d;
                                        VCOPY(ocent, v);
                                }
                        }
                }
        } else {                                /* local source */
                multp3(nsloc, source[sn].sloc, pm);
                for (i = 0; i < 3; i++)
                        ourspot.aim[i] = ocent[i] - nsloc[i];
                if ((d = normalize(ourspot.aim)) == 0.)
                        return(-1);             /* at source!! */
                if (source[sn].sflags & SPROX && d > source[sn].sl.prox)
                        return(-1);             /* too far away */
                ourspot.flen = 0.;
                                                /* adjust for source size */
                d = (sqrt(maxrad2) + source[sn].srad) / d;
                if (d < 1.-FTINY)
                        ourspot.siz = 2.*PI*(1. - sqrt(1.-d*d));
                else
                        nsflags &= ~SSPOT;
                if (source[sn].sflags & SSPOT) {
                        copystruct(&theirspot, source[sn].sl.s);
                        multv3(theirspot.aim, source[sn].sl.s->aim, pm);
                        normalize(theirspot.aim);
                        if (nsflags & SSPOT) {
                                ourspot.flen = theirspot.flen;
                                d = ourspot.siz;
                                if (!commonspot(&ourspot, &theirspot, nsloc))
                                        return(-1);     /* no overlap */
                        } else {
                                nsflags |= SSPOT;
                                copystruct(&ourspot, &theirspot);
                                d = 2.*ourspot.siz;
                        }
                        if (ourspot.siz < d-FTINY) {    /* it shrunk */
                                d = spotdisk(v, op, &ourspot, nsloc);
                                if (d <= FTINY)
                                        return(-1);
                                if (d < maxrad2) {
                                        maxrad2 = d;
                                        VCOPY(ocent, v);
                                }
                        }
                }
                if (source[sn].sflags & SFLAT) {        /* behind source? */
                        multv3(nsnorm, source[sn].snorm, pm);
                        normalize(nsnorm);
                        if (nsflags & SSPOT && !checkspot(&ourspot, nsnorm))
                                return(-1);
                }
        }
                                        /* pretest visibility */
        nsflags = vstestvis(nsflags, op, ocent, maxrad2, sn);
        if (nsflags & SSKIP)
                return(-1);     /* obstructed */
                                        /* it all checks out, so make it */
        if ((i = newsource()) < 0)
                goto memerr;
        source[i].sflags = nsflags;
        VCOPY(source[i].sloc, nsloc);
        multv3(source[i].ss[SU], source[sn].ss[SU], pm);
        multv3(source[i].ss[SV], source[sn].ss[SV], pm);
        if (nsflags & SFLAT)
                VCOPY(source[i].snorm, nsnorm);
        else
                multv3(source[i].ss[SW], source[sn].ss[SW], pm);
        source[i].srad = source[sn].srad;
        source[i].ss2 = source[sn].ss2;
        if (nsflags & SSPOT) {
                if ((source[i].sl.s = (SPOT *)malloc(sizeof(SPOT))) == NULL)
                        goto memerr;
                copystruct(source[i].sl.s, &ourspot);
        }
        if (nsflags & SPROX)
                source[i].sl.prox = source[sn].sl.prox;
        source[i].sa.sv.sn = sn;
        source[i].so = op;
        return(i);
memerr:
        error(SYSTEM, "out of memory in makevsrc");
}


double
getdisk(oc, op, sn)             /* get visible object disk */
FVECT  oc;
OBJREC  *op;
register int  sn;
{
        double  rad2, roffs, offs, d, rd, rdoto;
        FVECT  rnrm, nrm;
                                /* first, use object getdisk function */
        rad2 = getmaxdisk(oc, op);
        if (!(source[sn].sflags & SVIRTUAL))
                return(rad2);           /* all done for normal source */
                                /* check for correct side of relay surface */
        roffs = getplaneq(rnrm, source[sn].so);
        rd = DOT(rnrm, source[sn].sloc);        /* source projection */
        if (!(source[sn].sflags & SDISTANT))
                rd -= roffs;
        d = DOT(rnrm, oc) - roffs;      /* disk distance to relay plane */
        if ((d > 0.) ^ (rd > 0.))
                return(rad2);           /* OK if opposite sides */
        if (d*d >= rad2)
                return(0.);             /* no relay is possible */
                                /* we need a closer look */
        offs = getplaneq(nrm, op);
        rdoto = DOT(rnrm, nrm);
        if (d*d >= rad2*(1.-rdoto*rdoto))
                return(0.);             /* disk entirely on projection side */
                                /* should shrink disk but I'm lazy */
        return(rad2);
}


int
vstestvis(f, o, oc, or2, sn)            /* pretest source visibility */
int  f;                 /* virtual source flags */
OBJREC  *o;             /* relay object */
FVECT  oc;              /* relay object center */
double  or2;            /* relay object radius squared */
register int  sn;       /* target source number */
{
        RAY  sr;
        FVECT  onorm;
        FVECT  offsdir;
        SRCINDEX  si;
        double  or, d;
        int  infront;
        int  stestlim, ssn;
        int  nhit, nok;
        register int  i, n;
                                /* return if pretesting disabled */
        if (vspretest <= 0)
                return(f);
                                /* get surface normal */
        getplaneq(onorm, o);
                                /* set number of rays to sample */
        if (source[sn].sflags & SDISTANT) {
                                        /* 32. == heuristic constant */
                n = 32.*or2/(thescene.cusize*thescene.cusize)*vspretest + .5;
                infront = DOT(onorm, source[sn].sloc) > 0.;
        } else {
                for (i = 0; i < 3; i++)
                        offsdir[i] = source[sn].sloc[i] - oc[i];
                d = DOT(offsdir,offsdir);
                if (d <= FTINY)
                        n = 2.*PI * vspretest + .5;
                else
                        n = 2.*PI * (1.-sqrt(1./(1.+or2/d)))*vspretest + .5;
                infront = DOT(onorm, offsdir) > 0.;
        }
        if (n < MINSAMPLES) n = MINSAMPLES;
#ifdef DEBUG
        fprintf(stderr, "pretesting source %d in object %s with %d rays\n",
                        sn, o->oname, n);
#endif
                                /* sample */
        or = sqrt(or2);
        stestlim = n*STESTMAX;
        ssn = 0;
        nhit = nok = 0;
        while (n-- > 0) {
                                        /* get sample point */
                do {
                        if (ssn >= stestlim) {
#ifdef DEBUG
                                fprintf(stderr, "\ttoo hard to hit\n");
#endif
                                return(f);      /* too small a target! */
                        }
                        multisamp(offsdir, 3, urand(sn*931+5827+ssn));
                        for (i = 0; i < 3; i++)
                                offsdir[i] = or*(1. - 2.*offsdir[i]);
                        ssn++;
                        for (i = 0; i < 3; i++)
                                sr.rorg[i] = oc[i] + offsdir[i];
                        d = DOT(offsdir,onorm);
                        sr.rmax = 0.0;
                        if (infront)
                                for (i = 0; i < 3; i++) {
                                        sr.rorg[i] -= (d-.0001)*onorm[i];
                                        sr.rdir[i] = -onorm[i];
                                }
                        else
                                for (i = 0; i < 3; i++) {
                                        sr.rorg[i] -= (d+.0001)*onorm[i];
                                        sr.rdir[i] = onorm[i];
                                }
                        rayorigin(&sr, NULL, PRIMARY, 1.0);
                } while (!(*ofun[o->otype].funp)(o, &sr));
                                        /* check against source */
                initsrcindex(&si);
                si.sn = sn;
                nopart(&si, &sr);
                samplendx++;
                if (!srcray(&sr, NULL, &si) || sr.rsrc != sn)
                        continue;
                sr.revf = srcvalue;
                rayvalue(&sr);
                if (bright(sr.rcol) <= FTINY)
                        continue;
                nok++;
                                        /* check against obstructions */
                rayclear(&sr);
                sr.revf = raytrace;
                rayvalue(&sr);
                if (bright(sr.rcol) > FTINY)
                        nhit++;
                if (nhit > 0 && nhit < nok) {
#ifdef DEBUG
                        fprintf(stderr, "\tpartially occluded\n");
#endif
                        return(f);              /* need to shadow test */
                }
        }
        if (nhit == 0) {
#ifdef DEBUG
                fprintf(stderr, "\t0%% hit rate\n");
#endif
                return(f | SSKIP);      /* 0% hit rate:  totally occluded */
        }
#ifdef DEBUG
        fprintf(stderr, "\t100%% hit rate\n");
#endif
        return(f & ~SFOLLOW);           /* 100% hit rate:  no occlusion */
}
        

#ifdef DEBUG
virtverb(sn, fp)        /* print verbose description of virtual source */
register int  sn;
FILE  *fp;
{
        register int  i;

        fprintf(fp, "%s virtual source %d in %s %s\n",
                        source[sn].sflags & SDISTANT ? "distant" : "local",
                        sn, ofun[source[sn].so->otype].funame,
                        source[sn].so->oname);
        fprintf(fp, "\tat (%f,%f,%f)\n",
                source[sn].sloc[0], source[sn].sloc[1], source[sn].sloc[2]);
        fprintf(fp, "\tlinked to source %d (%s)\n",
                source[sn].sa.sv.sn, source[source[sn].sa.sv.sn].so->oname);
        if (source[sn].sflags & SFOLLOW)
                fprintf(fp, "\talways followed\n");
        else
                fprintf(fp, "\tnever followed\n");
        if (!(source[sn].sflags & SSPOT))
                return;
        fprintf(fp, "\twith spot aim (%f,%f,%f) and size %f\n",
                        source[sn].sl.s->aim[0], source[sn].sl.s->aim[1],
                        source[sn].sl.s->aim[2], source[sn].sl.s->siz);
}
#endif
Revision:	2.3
Committed:	Tue Dec 20 20:18:43 1994 UTC (30 years, 10 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.2:	+2 -1 lines
Log Message:	added -vo and -va (fore and aft clipping plane) view options
#	User	Rev	Content
1	greg	2.3	/* Copyright (c) 1994 Regents of the University of California */
2	greg	1.1
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ LBL";
5			#endif
6
7			/*
8			* Routines for simulating virtual light sources
9			* Thus far, we only support planar mirrors.
10			*/
11
12			#include "ray.h"
13
14	greg	1.7	#include "octree.h"
15
16	greg	1.3	#include "otypes.h"
17
18	greg	1.1	#include "source.h"
19
20	greg	1.7	#include "random.h"
21	greg	1.1
22	greg	1.22	#define MINSAMPLES 16 /* minimum number of pretest samples */
23			#define STESTMAX 32 /* maximum seeks per sample */
24	greg	1.1
25	greg	1.13
26	greg	1.7	double getdisk();
27
28	greg	1.1	static OBJECT vobject; / virtual source objects */
29			static int nvobjects = 0; /* number of virtual source objects */
30
31
32			markvirtuals() /* find and mark virtual sources */
33			{
34			register OBJREC *o;
35			register int i;
36			/* check number of direct relays */
37			if (directrelay <= 0)
38			return;
39			/* find virtual source objects */
40			for (i = 0; i < nobjects; i++) {
41			o = objptr(i);
42	greg	1.3	if (!issurface(o->otype) \|\| o->omod == OVOID)
43	greg	1.1	continue;
44	greg	1.31	if (!isvlight(vsmaterial(o)->otype))
45	greg	1.1	continue;
46	greg	1.3	if (sfun[o->otype].of == NULL \|\|
47	greg	1.21	sfun[o->otype].of->getpleq == NULL) {
48			objerror(o,WARNING,"secondary sources not supported");
49			continue;
50			}
51	greg	1.1	if (nvobjects == 0)
52			vobject = (OBJECT *)malloc(sizeof(OBJECT));
53			else
54			vobject = (OBJECT )realloc((char )vobject,
55			(unsigned)(nvobjects+1)*sizeof(OBJECT));
56			if (vobject == NULL)
57			error(SYSTEM, "out of memory in addvirtuals");
58			vobject[nvobjects++] = i;
59			}
60			if (nvobjects == 0)
61			return;
62	greg	1.4	#ifdef DEBUG
63			fprintf(stderr, "found %d virtual source objects\n", nvobjects);
64			#endif
65	greg	1.1	/* append virtual sources */
66			for (i = nsources; i-- > 0; )
67	greg	1.7	addvirtuals(i, directrelay);
68	greg	1.1	/* done with our object list */
69			free((char *)vobject);
70			nvobjects = 0;
71			}
72
73
74	greg	1.4	addvirtuals(sn, nr) /* add virtuals associated with source */
75			int sn;
76	greg	1.1	int nr;
77			{
78			register int i;
79			/* check relay limit first */
80			if (nr <= 0)
81			return;
82	greg	1.7	if (source[sn].sflags & SSKIP)
83			return;
84	greg	1.1	/* check each virtual object for projection */
85			for (i = 0; i < nvobjects; i++)
86	greg	1.3	/* vproject() calls us recursively */
87	greg	1.4	vproject(objptr(vobject[i]), sn, nr-1);
88	greg	1.1	}
89
90
91	greg	1.4	vproject(o, sn, n) /* create projected source(s) if they exist */
92	greg	1.3	OBJREC *o;
93	greg	1.4	int sn;
94	greg	1.3	int n;
95			{
96			register int i;
97			register VSMATERIAL *vsmat;
98			MAT4 proj;
99	greg	1.4	int ns;
100
101			if (o == source[sn].so) /* objects cannot project themselves */
102			return;
103	greg	1.3	/* get virtual source material */
104	greg	1.31	vsmat = sfun[vsmaterial(o)->otype].mf;
105	greg	1.3	/* project virtual sources */
106			for (i = 0; i < vsmat->nproj; i++)
107	greg	1.4	if ((*vsmat->vproj)(proj, o, &source[sn], i))
108			if ((ns = makevsrc(o, sn, proj)) >= 0) {
109	greg	1.17	source[ns].sa.sv.pn = i;
110	greg	1.4	#ifdef DEBUG
111	greg	1.6	virtverb(ns, stderr);
112	greg	1.4	#endif
113	greg	1.3	addvirtuals(ns, n);
114	greg	1.4	}
115	greg	1.31	}
116
117
118			OBJREC *
119			vsmaterial(o) /* get virtual source material pointer */
120			OBJREC *o;
121			{
122			register int i;
123			register OBJREC *m;
124
125			i = o->omod;
126			m = objptr(i);
127			if (m->otype != MAT_ILLUM \|\| m->oargs.nsargs < 1 \|\|
128			!strcmp(m->oargs.sarg[0], VOIDID) \|\|
129	greg	2.2	(i = modifier(m->oargs.sarg[0])) == OVOID)
130	greg	1.31	return(m); /* direct modifier */
131			return(objptr(i)); /* illum alternate */
132	greg	1.3	}
133
134
135	greg	1.4	int
136			makevsrc(op, sn, pm) /* make virtual source if reasonable */
137	greg	1.1	OBJREC *op;
138	greg	1.4	register int sn;
139	greg	1.1	MAT4 pm;
140			{
141	greg	1.9	FVECT nsloc, nsnorm, ocent, v;
142			double maxrad2, d;
143	greg	1.3	int nsflags;
144	greg	1.1	SPOT theirspot, ourspot;
145			register int i;
146	greg	1.3
147	greg	1.6	nsflags = source[sn].sflags \| (SVIRTUAL\|SSPOT\|SFOLLOW);
148	greg	1.1	/* get object center and max. radius */
149	greg	1.6	maxrad2 = getdisk(ocent, op, sn);
150			if (maxrad2 <= FTINY) /* too small? */
151			return(-1);
152	greg	1.1	/* get location and spot */
153	greg	1.4	if (source[sn].sflags & SDISTANT) { /* distant source */
154			if (source[sn].sflags & SPROX)
155	greg	1.5	return(-1); /* should never get here! */
156	greg	1.4	multv3(nsloc, source[sn].sloc, pm);
157	greg	1.17	normalize(nsloc);
158	greg	1.6	VCOPY(ourspot.aim, ocent);
159			ourspot.siz = PI*maxrad2;
160			ourspot.flen = 0.;
161	greg	1.4	if (source[sn].sflags & SSPOT) {
162			multp3(theirspot.aim, source[sn].sl.s->aim, pm);
163	greg	1.29	/* adjust for source size */
164	greg	1.19	d = sqrt(dist2(ourspot.aim, theirspot.aim));
165	greg	1.28	d = sqrt(source[sn].sl.s->siz/PI) + d*source[sn].srad;
166	greg	1.19	theirspot.siz = PIdd;
167			ourspot.flen = theirspot.flen = source[sn].sl.s->flen;
168	greg	1.9	d = ourspot.siz;
169	greg	1.6	if (!commonbeam(&ourspot, &theirspot, nsloc))
170	greg	1.9	return(-1); /* no overlap */
171			if (ourspot.siz < d-FTINY) { /* it shrunk */
172			d = beamdisk(v, op, &ourspot, nsloc);
173			if (d <= FTINY)
174			return(-1);
175			if (d < maxrad2) {
176			maxrad2 = d;
177			VCOPY(ocent, v);
178			}
179			}
180	greg	1.1	}
181			} else { /* local source */
182	greg	1.4	multp3(nsloc, source[sn].sloc, pm);
183	greg	1.6	for (i = 0; i < 3; i++)
184			ourspot.aim[i] = ocent[i] - nsloc[i];
185	greg	1.9	if ((d = normalize(ourspot.aim)) == 0.)
186	greg	1.6	return(-1); /* at source!! */
187	greg	1.9	if (source[sn].sflags & SPROX && d > source[sn].sl.prox)
188	greg	1.6	return(-1); /* too far away */
189			ourspot.flen = 0.;
190	greg	1.29	/* adjust for source size */
191	greg	1.28	d = (sqrt(maxrad2) + source[sn].srad) / d;
192	greg	1.19	if (d < 1.-FTINY)
193			ourspot.siz = 2.PI(1. - sqrt(1.-d*d));
194	greg	1.14	else
195			nsflags &= ~SSPOT;
196	greg	1.4	if (source[sn].sflags & SSPOT) {
197			copystruct(&theirspot, source[sn].sl.s);
198			multv3(theirspot.aim, source[sn].sl.s->aim, pm);
199	greg	1.17	normalize(theirspot.aim);
200	greg	1.14	if (nsflags & SSPOT) {
201			ourspot.flen = theirspot.flen;
202			d = ourspot.siz;
203			if (!commonspot(&ourspot, &theirspot, nsloc))
204			return(-1); /* no overlap */
205			} else {
206			nsflags \|= SSPOT;
207			copystruct(&ourspot, &theirspot);
208			d = 2.*ourspot.siz;
209			}
210	greg	1.9	if (ourspot.siz < d-FTINY) { /* it shrunk */
211			d = spotdisk(v, op, &ourspot, nsloc);
212			if (d <= FTINY)
213			return(-1);
214			if (d < maxrad2) {
215			maxrad2 = d;
216			VCOPY(ocent, v);
217			}
218			}
219	greg	1.1	}
220	greg	1.4	if (source[sn].sflags & SFLAT) { /* behind source? */
221			multv3(nsnorm, source[sn].snorm, pm);
222	greg	1.17	normalize(nsnorm);
223	greg	1.20	if (nsflags & SSPOT && !checkspot(&ourspot, nsnorm))
224	greg	1.5	return(-1);
225	greg	1.1	}
226			}
227	greg	1.7	/* pretest visibility */
228			nsflags = vstestvis(nsflags, op, ocent, maxrad2, sn);
229			if (nsflags & SSKIP)
230			return(-1); /* obstructed */
231			/* it all checks out, so make it */
232	greg	1.6	if ((i = newsource()) < 0)
233	greg	1.1	goto memerr;
234	greg	1.6	source[i].sflags = nsflags;
235			VCOPY(source[i].sloc, nsloc);
236	greg	1.28	multv3(source[i].ss[SU], source[sn].ss[SU], pm);
237			multv3(source[i].ss[SV], source[sn].ss[SV], pm);
238	greg	1.3	if (nsflags & SFLAT)
239	greg	1.6	VCOPY(source[i].snorm, nsnorm);
240	greg	1.28	else
241			multv3(source[i].ss[SW], source[sn].ss[SW], pm);
242	greg	1.29	source[i].srad = source[sn].srad;
243	greg	1.28	source[i].ss2 = source[sn].ss2;
244	greg	1.14	if (nsflags & SSPOT) {
245			if ((source[i].sl.s = (SPOT *)malloc(sizeof(SPOT))) == NULL)
246			goto memerr;
247			copystruct(source[i].sl.s, &ourspot);
248			}
249	greg	1.3	if (nsflags & SPROX)
250	greg	1.6	source[i].sl.prox = source[sn].sl.prox;
251	greg	1.17	source[i].sa.sv.sn = sn;
252	greg	1.6	source[i].so = op;
253			return(i);
254	greg	1.1	memerr:
255			error(SYSTEM, "out of memory in makevsrc");
256			}
257
258
259	greg	1.6	double
260			getdisk(oc, op, sn) /* get visible object disk */
261			FVECT oc;
262			OBJREC *op;
263			register int sn;
264			{
265			double rad2, roffs, offs, d, rd, rdoto;
266			FVECT rnrm, nrm;
267			/* first, use object getdisk function */
268	greg	1.9	rad2 = getmaxdisk(oc, op);
269	greg	1.6	if (!(source[sn].sflags & SVIRTUAL))
270			return(rad2); /* all done for normal source */
271			/* check for correct side of relay surface */
272	greg	1.9	roffs = getplaneq(rnrm, source[sn].so);
273	greg	1.6	rd = DOT(rnrm, source[sn].sloc); /* source projection */
274			if (!(source[sn].sflags & SDISTANT))
275			rd -= roffs;
276			d = DOT(rnrm, oc) - roffs; /* disk distance to relay plane */
277			if ((d > 0.) ^ (rd > 0.))
278			return(rad2); /* OK if opposite sides */
279			if (d*d >= rad2)
280	greg	1.9	return(0.); /* no relay is possible */
281	greg	1.6	/* we need a closer look */
282	greg	1.9	offs = getplaneq(nrm, op);
283	greg	1.6	rdoto = DOT(rnrm, nrm);
284			if (dd >= rad2(1.-rdoto*rdoto))
285			return(0.); /* disk entirely on projection side */
286			/* should shrink disk but I'm lazy */
287			return(rad2);
288			}
289
290
291	greg	1.7	int
292			vstestvis(f, o, oc, or2, sn) /* pretest source visibility */
293			int f; /* virtual source flags */
294			OBJREC o; / relay object */
295			FVECT oc; /* relay object center */
296			double or2; /* relay object radius squared */
297			register int sn; /* target source number */
298	greg	1.1	{
299	greg	1.7	RAY sr;
300			FVECT onorm;
301			FVECT offsdir;
302	greg	1.28	SRCINDEX si;
303	greg	1.7	double or, d;
304	greg	1.8	int infront;
305	greg	1.16	int stestlim, ssn;
306	greg	1.11	int nhit, nok;
307	greg	1.7	register int i, n;
308			/* return if pretesting disabled */
309			if (vspretest <= 0)
310			return(f);
311			/* get surface normal */
312	greg	1.9	getplaneq(onorm, o);
313	greg	1.7	/* set number of rays to sample */
314	greg	1.8	if (source[sn].sflags & SDISTANT) {
315	greg	1.26	/* 32. == heuristic constant */
316			n = 32.or2/(thescene.cusizethescene.cusize)*vspretest + .5;
317	greg	1.8	infront = DOT(onorm, source[sn].sloc) > 0.;
318			} else {
319			for (i = 0; i < 3; i++)
320			offsdir[i] = source[sn].sloc[i] - oc[i];
321	greg	1.20	d = DOT(offsdir,offsdir);
322			if (d <= FTINY)
323			n = 2.PI vspretest + .5;
324			else
325			n = 2.PI (1.-sqrt(1./(1.+or2/d)))*vspretest + .5;
326	greg	1.8	infront = DOT(onorm, offsdir) > 0.;
327			}
328	greg	1.13	if (n < MINSAMPLES) n = MINSAMPLES;
329	greg	1.9	#ifdef DEBUG
330			fprintf(stderr, "pretesting source %d in object %s with %d rays\n",
331			sn, o->oname, n);
332			#endif
333	greg	1.7	/* sample */
334	greg	1.8	or = sqrt(or2);
335	greg	1.16	stestlim = n*STESTMAX;
336			ssn = 0;
337	greg	1.11	nhit = nok = 0;
338	greg	1.7	while (n-- > 0) {
339	greg	1.8	/* get sample point */
340			do {
341	greg	1.16	if (ssn >= stestlim) {
342	greg	1.9	#ifdef DEBUG
343			fprintf(stderr, "\ttoo hard to hit\n");
344			#endif
345	greg	1.8	return(f); /* too small a target! */
346	greg	1.9	}
347	greg	1.25	multisamp(offsdir, 3, urand(sn*931+5827+ssn));
348	greg	1.8	for (i = 0; i < 3; i++)
349	greg	1.23	offsdir[i] = or(1. - 2.offsdir[i]);
350	greg	1.16	ssn++;
351	greg	1.8	for (i = 0; i < 3; i++)
352			sr.rorg[i] = oc[i] + offsdir[i];
353			d = DOT(offsdir,onorm);
354	greg	2.3	sr.rmax = 0.0;
355	greg	1.8	if (infront)
356			for (i = 0; i < 3; i++) {
357			sr.rorg[i] -= (d-.0001)*onorm[i];
358			sr.rdir[i] = -onorm[i];
359			}
360			else
361			for (i = 0; i < 3; i++) {
362			sr.rorg[i] -= (d+.0001)*onorm[i];
363			sr.rdir[i] = onorm[i];
364			}
365			rayorigin(&sr, NULL, PRIMARY, 1.0);
366			} while (!(*ofun[o->otype].funp)(o, &sr));
367			/* check against source */
368	greg	1.28	initsrcindex(&si);
369			si.sn = sn;
370	greg	1.30	nopart(&si, &sr);
371	greg	1.7	samplendx++;
372	greg	1.28	if (!srcray(&sr, NULL, &si) \|\| sr.rsrc != sn)
373	greg	1.7	continue;
374			sr.revf = srcvalue;
375			rayvalue(&sr);
376			if (bright(sr.rcol) <= FTINY)
377			continue;
378	greg	1.11	nok++;
379	greg	1.7	/* check against obstructions */
380	greg	1.18	rayclear(&sr);
381	greg	1.27	sr.revf = raytrace;
382			rayvalue(&sr);
383			if (bright(sr.rcol) > FTINY)
384	greg	1.11	nhit++;
385			if (nhit > 0 && nhit < nok) {
386	greg	1.9	#ifdef DEBUG
387	greg	1.11	fprintf(stderr, "\tpartially occluded\n");
388	greg	1.9	#endif
389	greg	1.11	return(f); /* need to shadow test */
390			}
391	greg	1.1	}
392	greg	1.9	if (nhit == 0) {
393			#ifdef DEBUG
394			fprintf(stderr, "\t0%% hit rate\n");
395			#endif
396	greg	1.7	return(f \| SSKIP); /* 0% hit rate: totally occluded */
397	greg	1.9	}
398			#ifdef DEBUG
399			fprintf(stderr, "\t100%% hit rate\n");
400			#endif
401			return(f & ~SFOLLOW); /* 100% hit rate: no occlusion */
402	greg	1.1	}
403	greg	1.7
404	greg	1.4
405			#ifdef DEBUG
406	greg	1.6	virtverb(sn, fp) /* print verbose description of virtual source */
407			register int sn;
408	greg	1.4	FILE *fp;
409			{
410			register int i;
411
412			fprintf(fp, "%s virtual source %d in %s %s\n",
413	greg	1.6	source[sn].sflags & SDISTANT ? "distant" : "local",
414			sn, ofun[source[sn].so->otype].funame,
415			source[sn].so->oname);
416	greg	1.4	fprintf(fp, "\tat (%f,%f,%f)\n",
417	greg	1.6	source[sn].sloc[0], source[sn].sloc[1], source[sn].sloc[2]);
418	greg	1.4	fprintf(fp, "\tlinked to source %d (%s)\n",
419	greg	1.17	source[sn].sa.sv.sn, source[source[sn].sa.sv.sn].so->oname);
420	greg	1.6	if (source[sn].sflags & SFOLLOW)
421	greg	1.4	fprintf(fp, "\talways followed\n");
422			else
423			fprintf(fp, "\tnever followed\n");
424	greg	1.6	if (!(source[sn].sflags & SSPOT))
425	greg	1.4	return;
426			fprintf(fp, "\twith spot aim (%f,%f,%f) and size %f\n",
427	greg	1.6	source[sn].sl.s->aim[0], source[sn].sl.s->aim[1],
428			source[sn].sl.s->aim[2], source[sn].sl.s->siz);
429	greg	1.4	}
430			#endif