ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/gen/mkillum2.c

Comparing ray/src/gen/mkillum2.c (file contents):
Revision 2.23 by greg, Mon Nov 5 23:40:26 2007 UTC vs.
Revision 2.28 by greg, Thu Dec 13 07:03:37 2007 UTC

#	Line 10 | Line 10 | static const char      RCSid[] = "$Id$";
10		#include  "mkillum.h"
11		#include  "face.h"
12		#include  "cone.h"
13	<	#include  "random.h"
13	>	#include  "source.h"
14
15
16		COLORV *        distarr = NULL;         /* distribution array */
#	Line 22 | Line 22 | newdist(                       /* allocate & clear distribution array */
22		int siz
23		)
24		{
25	<	if (siz == 0) {
25	>	if (siz <= 0) {
26		if (distsiz > 0)
27		free((void *)distarr);
28		distarr = NULL;
#	Line 42 | Line 42 | newdist(                       /* allocate & clear distribution array */
42
43
44		int
45	<	process_ray(RAY *r, int rv)
45	>	process_ray(                    /* process a ray result or report error */
46	>	RAY *r,
47	>	int rv
48	>	)
49		{
50		COLORV  *colp;
51
52	<	if (rv == 0)
52	>	if (rv == 0)                    /* no result ready */
53		return(0);
54		if (rv < 0)
55		error(USER, "ray tracing process died");
56		if (r->rno >= distsiz)
57		error(INTERNAL, "bad returned index in process_ray");
58	+	multcolor(r->rcol, r->rcoef);   /* in case it's a source ray */
59		colp = &distarr[r->rno * 3];
60		addcolor(colp, r->rcol);
61		return(1);
#	Line 59 | Line 63 | process_ray(RAY *r, int rv)
63
64
65		void
66	<	raysamp(        /* queue a ray sample */
66	>	raysamp(                        /* queue a ray sample */
67		int  ndx,
68		FVECT  org,
69		FVECT  dir
#	Line 81 | Line 85 | raysamp(       /* queue a ray sample */
85
86
87		void
88	+	srcsamps(                       /* sample sources from this surface position */
89	+	struct illum_args *il,
90	+	FVECT org,
91	+	FVECT nrm,
92	+	MAT4 ixfm
93	+	)
94	+	{
95	+	int  nalt, nazi;
96	+	SRCINDEX  si;
97	+	RAY  sr;
98	+	FVECT   v;
99	+	double  d;
100	+	int  i, j;
101	+	/* get sampling density */
102	+	if (il->sampdens <= 0) {
103	+	nalt = nazi = 1;
104	+	} else {
105	+	i = PI * il->sampdens;
106	+	nalt = sqrt(i/PI) + .5;
107	+	nazi = PI*nalt + .5;
108	+	}
109	+	initsrcindex(&si);                      /* loop over (sub)sources */
110	+	for ( ; ; ) {
111	+	VCOPY(sr.rorg, org);            /* pick side to shoot from */
112	+	if (il->sd != NULL) {
113	+	int  sn = si.sn;
114	+	if (si.sp+1 >= si.np) ++sn;
115	+	if (sn >= nsources) break;
116	+	if (source[sn].sflags & SDISTANT)
117	+	d = DOT(source[sn].sloc, nrm);
118	+	else {
119	+	VSUB(v, source[sn].sloc, org);
120	+	d = DOT(v, nrm);
121	+	}
122	+	} else
123	+	d = 1.0;                /* only transmission */
124	+	if (d < 0.0)
125	+	d = -1.0001*il->thick - 5.*FTINY;
126	+	else
127	+	d = 5.*FTINY;
128	+	for (i = 3; i--; )
129	+	sr.rorg[i] += d*nrm[i];
130	+	if (!srcray(&sr, NULL, &si))
131	+	break;                  /* end of sources */
132	+	/* index direction */
133	+	if (ixfm != NULL)
134	+	multv3(v, sr.rdir, ixfm);
135	+	else
136	+	VCOPY(v, sr.rdir);
137	+	if (il->sd != NULL) {
138	+	i = getBSDF_incndx(il->sd, v);
139	+	if (i < 0)
140	+	continue;       /* must not be important */
141	+	sr.rno = i;
142	+	d = 1.0/getBSDF_incohm(il->sd, i);
143	+	} else {
144	+	if (v[2] >= -FTINY)
145	+	continue;       /* only sample transmission */
146	+	d = 1.0 - v[2]*v[2];
147	+	i = d*nalt;
148	+	d = atan2(-v[1], -v[0])/(2.*PI);
149	+	if (d < 0.0) d += 1.0;
150	+	j = d*nazi + 0.5;
151	+	if (j >= nazi) j = 0;
152	+	sr.rno = i*nazi + j;
153	+	d = nalt*nazi/PI * -v[2];
154	+	}
155	+	d *= si.dom;                    /* solid angle correction */
156	+	scalecolor(sr.rcoef, d);
157	+	process_ray(&sr, ray_pqueue(&sr));
158	+	}
159	+	}
160	+
161	+
162	+	void
163		rayclean()                      /* finish all pending rays */
164		{
165		RAY     myRay;
#	Line 127 | Line 206 | rounddir(              /* compute uniform spherical direction */
206		}
207
208
209	<	static void
209	>	void
210		flatdir(                /* compute uniform hemispherical direction */
211	<	register FVECT  dv,
211	>	FVECT  dv,
212		double  alt,
213		double  azi
214		)
#	Line 166 | Line 245 | my_face(               /* make an illum face */
245		char  *nm
246		)
247		{
169	–	#define MAXMISS         (5*n*il->nsamps)
248		int  dim[2];
249	<	int  n, nalt, nazi, h, alti;
249	>	int  n, nalt, nazi, alti;
250		double  sp[2], r1, r2;
251	+	int  h;
252		FVECT  dn, org, dir;
253		FVECT  u, v;
254		double  ur[2], vr[2];
255		MAT4  xfm;
256	<	int  nmisses;
256	>	int  nallow;
257		FACE  *fa;
258	<	register int  i, j;
258	>	int  i, j;
259		/* get/check arguments */
260		fa = getface(ob);
261		if (fa->area == 0.0) {
#	Line 229 | Line 308 | my_face(               /* make an illum face */
308		}
309		dim[0] = random();
310		/* sample polygon */
311	<	nmisses = 0;
311	>	nallow = 5*n*il->nsamps;
312		for (dim[1] = 0; dim[1] < n; dim[1]++)
313		for (i = 0; i < il->nsamps; i++) {
314		/* randomize direction */
#	Line 248 | Line 327 | my_face(               /* make an illum face */
327		}
328		/* randomize location */
329		do {
330	<	multisamp(sp, 2, urand(h+4862+nmisses));
330	>	multisamp(sp, 2, urand(h+4862+nallow));
331		r1 = ur[0] + (ur[1]-ur[0]) * sp[0];
332		r2 = vr[0] + (vr[1]-vr[0]) * sp[1];
333		for (j = 0; j < 3; j++)
334		org[j] = r1*u[j] + r2*v[j]
335		+ fa->offset*fa->norm[j];
336	<	} while (!inface(org, fa) && nmisses++ < MAXMISS);
337	<	if (nmisses > MAXMISS) {
336	>	} while (!inface(org, fa) && nallow-- > 0);
337	>	if (nallow < 0) {
338		objerror(ob, WARNING, "bad aspect");
339		rayclean();
340		freeface(ob);
341		return(my_default(ob, il, nm));
342		}
343		if (il->sd != NULL && DOT(dir, fa->norm) < -FTINY)
344	<	r1 = -1.0001*il->thick - .0001;
344	>	r1 = -1.0001*il->thick - 5.*FTINY;
345		else
346	<	r1 = .0001;
346	>	r1 = 5.*FTINY;
347		for (j = 0; j < 3; j++)
348		org[j] += r1*fa->norm[j];
349		/* send sample */
350		raysamp(dim[1], org, dir);
351		}
352	+	/* add in direct component? */
353	+	if (!directvis && il->flags & IL_LIGHT) {
354	+	MAT4    ixfm;
355	+	if (il->sd == NULL) {
356	+	for (i = 3; i--; ) {
357	+	ixfm[i][0] = u[i];
358	+	ixfm[i][1] = v[i];
359	+	ixfm[i][2] = fa->norm[i];
360	+	ixfm[i][3] = 0.;
361	+	}
362	+	ixfm[3][0] = ixfm[3][1] = ixfm[3][2] = 0.;
363	+	ixfm[3][3] = 1.;
364	+	} else if (!invmat4(ixfm, xfm))
365	+	objerror(ob, INTERNAL, "cannot invert BSDF transform");
366	+	dim[0] = random();
367	+	nallow = 10*il->nsamps;
368	+	for (i = 0; i < il->nsamps; i++) {
369	+	/* randomize location */
370	+	h = dim[0] + samplendx++;
371	+	do {
372	+	multisamp(sp, 2, urand(h+nallow));
373	+	r1 = ur[0] + (ur[1]-ur[0]) * sp[0];
374	+	r2 = vr[0] + (vr[1]-vr[0]) * sp[1];
375	+	for (j = 0; j < 3; j++)
376	+	org[j] = r1*u[j] + r2*v[j]
377	+	+ fa->offset*fa->norm[j];
378	+	} while (!inface(org, fa) && nallow-- > 0);
379	+	if (nallow < 0) {
380	+	objerror(ob, WARNING, "bad aspect");
381	+	rayclean();
382	+	freeface(ob);
383	+	return(my_default(ob, il, nm));
384	+	}
385	+	/* sample source rays */
386	+	srcsamps(il, org, fa->norm, ixfm);
387	+	}
388	+	}
389	+	/* wait for all rays to finish */
390		rayclean();
391		if (il->sd != NULL) {   /* run distribution through BSDF */
392		nalt = sqrt(il->sd->nout/PI) + .5;
393		nazi = PI*nalt + .5;
394		redistribute(il->sd, nalt, nazi, u, v, fa->norm, xfm);
395	+	if (!il->sampdens)
396	+	il->sampdens = nalt*nazi/PI + .999;
397		}
398		/* write out the face and its distribution */
399		if (average(il, distarr, n)) {
#	Line 286 | Line 405 | my_face(               /* make an illum face */
405		/* clean up */
406		freeface(ob);
407		return(0);
289	–	#undef MAXMISS
408		}
409
410
#	Line 344 | Line 462 | my_sphere(     /* make an illum sphere */
462		/* send sample */
463		raysamp(dim[1]*nazi+dim[2], org, dir);
464		}
465	+	/* wait for all rays to finish */
466		rayclean();
467		/* write out the sphere and its distribution */
468		if (average(il, distarr, n)) {
#	Line 374 | Line 493 | my_ring(               /* make an illum ring */
493		FVECT  u, v;
494		MAT4  xfm;
495		CONE  *co;
496	<	register int  i, j;
496	>	int  i, j;
497		/* get/check arguments */
498		co = getcone(ob, 0);
499		/* set up sampling */
#	Line 413 | Line 532 | my_ring(               /* make an illum ring */
532		r2 = (dim[1] - alti*nazi + sp[1] - .5)/nazi;
533		flatdir(dn, r1, r2);
534		for (j = 0; j < 3; j++)
535	<	dir[j] = -dn[0]*u[j] - dn[1]*v[j] - dn[2]*co->ad[j];
535	>	dir[j] = -dn[0]*u[j] - dn[1]*v[j] - dn[2]*co->ad[j];
536		}
537		/* randomize location */
538		multisamp(sp, 2, urand(h+8371));
#	Line 423 | Line 542 | my_ring(               /* make an illum ring */
542		r1 = r3*cos(r2);
543		r2 = r3*sin(r2);
544		if (il->sd != NULL && DOT(dir, co->ad) < -FTINY)
545	<	r3 = -1.0001*il->thick - .0001;
545	>	r3 = -1.0001*il->thick - 5.*FTINY;
546		else
547	<	r3 = .0001;
547	>	r3 = 5.*FTINY;
548		for (j = 0; j < 3; j++)
549		org[j] = CO_P0(co)[j] + r1*u[j] + r2*v[j] +
550		r3*co->ad[j];
551		/* send sample */
552		raysamp(dim[1], org, dir);
553		}
554	+	/* add in direct component? */
555	+	if (!directvis && il->flags & IL_LIGHT) {
556	+	MAT4    ixfm;
557	+	if (il->sd == NULL) {
558	+	for (i = 3; i--; ) {
559	+	ixfm[i][0] = u[i];
560	+	ixfm[i][1] = v[i];
561	+	ixfm[i][2] = co->ad[i];
562	+	ixfm[i][3] = 0.;
563	+	}
564	+	ixfm[3][0] = ixfm[3][1] = ixfm[3][2] = 0.;
565	+	ixfm[3][3] = 1.;
566	+	} else if (!invmat4(ixfm, xfm))
567	+	objerror(ob, INTERNAL, "cannot invert BSDF transform");
568	+	dim[0] = random();
569	+	for (i = 0; i < il->nsamps; i++) {
570	+	/* randomize location */
571	+	h = dim[0] + samplendx++;
572	+	multisamp(sp, 2, urand(h));
573	+	r3 = sqrt(CO_R0(co)*CO_R0(co) +
574	+	sp[0]*(CO_R1(co)*CO_R1(co) - CO_R0(co)*CO_R0(co)));
575	+	r2 = 2.*PI*sp[1];
576	+	r1 = r3*cos(r2);
577	+	r2 = r3*sin(r2);
578	+	for (j = 0; j < 3; j++)
579	+	org[j] = CO_P0(co)[j] + r1*u[j] + r2*v[j];
580	+	/* sample source rays */
581	+	srcsamps(il, org, co->ad, ixfm);
582	+	}
583	+	}
584	+	/* wait for all rays to finish */
585		rayclean();
586		if (il->sd != NULL) {   /* run distribution through BSDF */
587		nalt = sqrt(il->sd->nout/PI) + .5;
588		nazi = PI*nalt + .5;
589		redistribute(il->sd, nalt, nazi, u, v, co->ad, xfm);
590	+	if (!il->sampdens)
591	+	il->sampdens = nalt*nazi/PI + .999;
592		}
593		/* write out the ring and its distribution */
594		if (average(il, distarr, n)) {

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)