ViewVC Help

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

root/Development/ray/src/rt/source.c

Comparing ray/src/rt/source.c (file contents):
Revision 2.6 by greg, Fri Oct 2 16:20:09 1992 UTC vs.
Revision 2.13 by greg, Tue Dec 21 15:46:19 1993 UTC

#	Line 1 | Line 1
1	<	/* Copyright (c) 1992 Regents of the University of California */
1	>	/* Copyright (c) 1993 Regents of the University of California */
2
3		#ifndef lint
4		static char SCCSid[] = "$SunId$ LBL";
#	Line 81 | Line 81 | marksources()                  /* find and mark source objects */
81		if (m->otype == MAT_GLOW) {
82		source[ns].sflags |= SPROX;
83		source[ns].sl.prox = m->oargs.farg[3];
84	<	if (o->otype == OBJ_SOURCE)
84	>	if (source[ns].sflags & SDISTANT)
85		source[ns].sflags |= SSKIP;
86		} else if (m->otype == MAT_SPOT) {
87		source[ns].sflags |= SSPOT;
#	Line 237 | Line 237 | char  *p;                      /* data for f */
237		{
238		extern int  (*trace)();
239		register int  sn;
240	+	register CONTRIB  *scp;
241		SRCINDEX  si;
242		int  nshadcheck, ncnts;
243		int  nhits;
#	Line 258 | Line 259 | char  *p;                      /* data for f */
259		error(SYSTEM, "out of memory in direct");
260		}
261		cntord[sn].sndx = sn;
262	<	srccnt[sn].sno = sr.rsrc;
262	>	scp = srccnt + sn;
263	>	scp->sno = sr.rsrc;
264		/* compute coefficient */
265	<	(*f)(srccnt[sn].coef, p, sr.rdir, si.dom);
266	<	cntord[sn].brt = bright(srccnt[sn].coef);
265	>	(*f)(scp->coef, p, sr.rdir, si.dom);
266	>	cntord[sn].brt = bright(scp->coef);
267		if (cntord[sn].brt <= 0.0)
268		continue;
269	<	VCOPY(srccnt[sn].dir, sr.rdir);
269	>	VCOPY(scp->dir, sr.rdir);
270		/* compute potential */
271		sr.revf = srcvalue;
272		rayvalue(&sr);
273	<	copycolor(srccnt[sn].val, sr.rcol);
274	<	multcolor(srccnt[sn].val, srccnt[sn].coef);
275	<	cntord[sn].brt = bright(srccnt[sn].val);
273	>	copycolor(scp->val, sr.rcol);
274	>	multcolor(scp->val, scp->coef);
275	>	cntord[sn].brt = bright(scp->val);
276		}
277		/* sort contributions */
278		qsort(cntord, sn, sizeof(CNTPTR), cntcmp);
#	Line 297 | Line 299 | char  *p;                      /* data for f */
299		/* modify threshold */
300		ourthresh = shadthresh / r->rweight;
301		/* test for shadows */
302	<	nhits = 0;
303	<	for (sn = 0; sn < ncnts; sn++) {
302	>	for (nhits = 0, hwt = 0.0, sn = 0; sn < ncnts;
303	>	hwt += (double)source[scp->sno].nhits /
304	>	(double)source[scp->sno].ntests,
305	>	sn++) {
306		/* check threshold */
307		if ((sn+nshadcheck>=ncnts ? cntord[sn].brt :
308		cntord[sn].brt-cntord[sn+nshadcheck].brt)
309		< ourthresh*bright(r->rcol))
310		break;
311	+	scp = srccnt + cntord[sn].sndx;
312		/* test for hit */
313		rayorigin(&sr, r, SHADOW, 1.0);
314	<	VCOPY(sr.rdir, srccnt[cntord[sn].sndx].dir);
315	<	sr.rsrc = srccnt[cntord[sn].sndx].sno;
316	<	source[sr.rsrc].ntests++;       /* keep statistics */
314	>	VCOPY(sr.rdir, scp->dir);
315	>	sr.rsrc = scp->sno;
316	>	source[scp->sno].ntests++;      /* keep statistics */
317		if (localhit(&sr, &thescene) &&
318	<	( sr.ro != source[sr.rsrc].so ||
319	<	source[sr.rsrc].sflags & SFOLLOW )) {
318	>	( sr.ro != source[scp->sno].so ||
319	>	source[scp->sno].sflags & SFOLLOW )) {
320		/* follow entire path */
321		raycont(&sr);
322		if (trace != NULL)
323		(*trace)(&sr);  /* trace execution */
324		if (bright(sr.rcol) <= FTINY)
325		continue;       /* missed! */
326	<	copycolor(srccnt[cntord[sn].sndx].val, sr.rcol);
327	<	multcolor(srccnt[cntord[sn].sndx].val,
323	<	srccnt[cntord[sn].sndx].coef);
326	>	copycolor(scp->val, sr.rcol);
327	>	multcolor(scp->val, scp->coef);
328		}
329		/* add contribution if hit */
330	<	addcolor(r->rcol, srccnt[cntord[sn].sndx].val);
330	>	addcolor(r->rcol, scp->val);
331		nhits++;
332	<	source[sr.rsrc].nhits++;
332	>	source[scp->sno].nhits++;
333		}
334	<	/* surface hit rate */
335	<	if (sn > 0)
336	<	hwt = (double)nhits / (double)sn;
334	>	/* source hit rate */
335	>	if (hwt > FTINY)
336	>	hwt = (double)nhits / hwt;
337		else
338		hwt = 0.5;
339		#ifdef DEBUG
340	<	sprintf(errmsg, "%d tested, %d untested, %f hit rate\n",
340	>	sprintf(errmsg, "%d tested, %d untested, %f conditional hit rate\n",
341		sn, ncnts-sn, hwt);
342		eputs(errmsg);
343		#endif
344		/* add in untested sources */
345		for ( ; sn < ncnts; sn++) {
346	<	sr.rsrc = srccnt[cntord[sn].sndx].sno;
347	<	prob = hwt * (double)source[sr.rsrc].nhits /
348	<	(double)source[sr.rsrc].ntests;
349	<	scalecolor(srccnt[cntord[sn].sndx].val, prob);
350	<	addcolor(r->rcol, srccnt[cntord[sn].sndx].val);
346	>	scp = srccnt + cntord[sn].sndx;
347	>	prob = hwt * (double)source[scp->sno].nhits /
348	>	(double)source[scp->sno].ntests;
349	>	if (prob > 1.0)
350	>	prob = 1.0;
351	>	scalecolor(scp->val, prob);
352	>	addcolor(r->rcol, scp->val);
353		}
354		}
355
#	Line 353 | Line 359 | char  *p;                      /* data for f */
359		* because they are very nasty and difficult to understand.
360		*/
361
362	<	/* wrongillum *
362	>	/* illumblock *
363		*
364		* We cannot allow an illum to pass to another illum, because that
365		* would almost certainly constitute overcounting.
366		* However, we do allow an illum to pass to another illum
367		* that is actually going to relay to a virtual light source.
368	+	* We also prevent an illum from passing to a glow; this provides a
369	+	* convenient mechanism for defining detailed light source
370	+	* geometry behind (or inside) an effective radiator.
371		*/
372
373	<	#define  wrongillum(m, r)       (!(source[r->rsrc].sflags&SVIRTUAL) && \
374	<	objptr(source[r->rsrc].so->omod)->otype==MAT_ILLUM)
373	>	static int weaksrcmod(obj) int obj;     /* efficiency booster function */
374	>	{register OBJREC *o = objptr(obj);
375	>	return(o->otype==MAT_ILLUM|o->otype==MAT_GLOW);}
376
377	+	#define  illumblock(m, r)       (!(source[r->rsrc].sflags&SVIRTUAL) && \
378	+	r->rod > 0.0 && \
379	+	weaksrcmod(source[r->rsrc].so->omod))
380	+
381		/* wrongsource *
382		*
383		* This source is the wrong source (ie. overcounted) if we are
384		* aimed to a different source than the one we hit and the one
385	<	* we hit is not an illum which should be passed.
385	>	* we hit is not an illum that should be passed.
386		*/
387
388		#define  wrongsource(m, r)      (r->rsrc>=0 && source[r->rsrc].so!=r->ro && \
389	<	(m->otype!=MAT_ILLUM || wrongillum(m,r)))
389	>	(m->otype!=MAT_ILLUM || illumblock(m,r)))
390
391		/* distglow *
392		*
393		* A distant glow is an object that sometimes acts as a light source,
394		* but is too far away from the test point to be one in this case.
395	+	* (Glows with negative radii should NEVER participate in illumination.)
396		*/
397
398		#define  distglow(m, r)         (m->otype==MAT_GLOW && \
399	+	m->oargs.farg[3] >= -FTINY && \
400		r->rot > m->oargs.farg[3])
401
402		/* badcomponent *
#	Line 396 | Line 412 | char  *p;                      /* data for f */
412		!(r->crtype&SHADOW || r->rod < 0.0 || \
413		distglow(m, r)))
414
399	–	/* overcount *
400	–	*
401	–	* All overcounting possibilities are contained here.
402	–	*/
403	–
404	–	#define  overcount(m, r)        (badcomponent(m,r) || wrongsource(m,r))
405	–
415		/* passillum *
416		*
417		* An illum passes to another material type when we didn't hit it
#	Line 416 | Line 425 | char  *p;                      /* data for f */
425
426		/* srcignore *
427		*
428	<	* The -di flag renders light sources invisible, and here is the test.
428	>	* The -dv flag is normally on for sources to be visible.
429		*/
430
431	<	#define  srcignore(m, r)        (directinvis && !(r->crtype&SHADOW) && \
431	>	#define  srcignore(m, r)        (!directvis && !(r->crtype&SHADOW) && \
432		!distglow(m, r))
433
434
#	Line 428 | Line 437 | register OBJREC  *m;
437		register RAY  *r;
438		{
439		/* check for over-counting */
440	<	if (overcount(m, r))
440	>	if (badcomponent(m, r))
441		return;
442	+	if (wrongsource(m,r))
443	+	return;
444		/* check for passed illum */
445		if (passillum(m, r)) {
446		if (m->oargs.nsargs < 1 || !strcmp(m->oargs.sarg[0], VOIDID))
#	Line 446 | Line 457 | register RAY  *r;
457		if (srcignore(m, r))
458		return;
459		/* check for outside spot */
460	<	if (m->otype==MAT_SPOT && spotout(r, (SPOT *)m->os, r->rot>=FHUGE))
460	>	if (m->otype==MAT_SPOT && spotout(r, makespot(m), r->rot>=FHUGE))
461		return;
462		/* get distribution pattern */
463		raytexture(r, m->omod);

Diff Legend

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