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.8 by greg, Sat Nov 14 13:58:23 1992 UTC vs.
Revision 2.17 by greg, Thu Nov 2 17:37:58 1995 UTC

#	Line 1 | Line 1
1	<	/* Copyright (c) 1992 Regents of the University of California */
1	>	/* Copyright (c) 1995 Regents of the University of California */
2
3		#ifndef lint
4		static char SCCSid[] = "$SunId$ LBL";
#	Line 68 | Line 68 | marksources()                  /* find and mark source objects */
68		o->otype != OBJ_SOURCE &&
69		m->oargs.farg[3] <= FTINY)
70		continue;                       /* don't bother */
71	+	if (m->oargs.farg[0] <= FTINY && m->oargs.farg[1] <= FTINY &&
72	+	m->oargs.farg[2] <= FTINY)
73	+	continue;                       /* don't bother */
74
75		if (sfun[o->otype].of == NULL ||
76		sfun[o->otype].of->setsrc == NULL)
#	Line 152 | Line 155 | SRCINDEX  *si;                 /* source sample index */
155
156
157		srcvalue(r)                     /* punch ray to source and compute value */
158	<	RAY  *r;
158	>	register RAY  *r;
159		{
160		register SRCREC  *sp;
161
#	Line 161 | Line 164 | RAY  *r;
164		/* check intersection */
165		if (!(*ofun[sp->so->otype].funp)(sp->so, r))
166		return;
167	<	raycont(r);             /* compute contribution */
167	>	if (!rayshade(r, r->ro->omod))  /* compute contribution */
168	>	goto nomat;
169		return;
170		}
171		/* compute intersection */
#	Line 169 | Line 173 | RAY  *r;
173		(*ofun[sp->so->otype].funp)(sp->so, r)) {
174		if (sp->sa.success >= 0)
175		sp->sa.success++;
176	<	raycont(r);             /* compute contribution */
176	>	if (!rayshade(r, r->ro->omod))  /* compute contribution */
177	>	goto nomat;
178		return;
179		}
180	+	/* we missed our mark! */
181		if (sp->sa.success < 0)
182		return;                 /* bitched already */
183		sp->sa.success -= AIMREQT;
#	Line 180 | Line 186 | RAY  *r;
186		sprintf(errmsg, "aiming failure for light source \"%s\"",
187		sp->so->oname);
188		error(WARNING, errmsg);         /* issue warning */
189	+	return;
190	+	nomat:
191	+	objerror(r->ro, USER, "material not found");
192		}
193
194
#	Line 299 | Line 308 | char  *p;                      /* data for f */
308		/* modify threshold */
309		ourthresh = shadthresh / r->rweight;
310		/* test for shadows */
311	<	nhits = 0;
312	<	for (sn = 0; sn < ncnts; sn++) {
311	>	for (nhits = 0, hwt = 0.0, sn = 0; sn < ncnts;
312	>	hwt += (double)source[scp->sno].nhits /
313	>	(double)source[scp->sno].ntests,
314	>	sn++) {
315		/* check threshold */
316		if ((sn+nshadcheck>=ncnts ? cntord[sn].brt :
317		cntord[sn].brt-cntord[sn+nshadcheck].brt)
#	Line 316 | Line 327 | char  *p;                      /* data for f */
327		( sr.ro != source[scp->sno].so ||
328		source[scp->sno].sflags & SFOLLOW )) {
329		/* follow entire path */
330	<	raycont(&sr);
330	>	if (!raycont(&sr))
331	>	objerror(sr.ro, USER, "material not found");
332		if (trace != NULL)
333		(*trace)(&sr);  /* trace execution */
334		if (bright(sr.rcol) <= FTINY)
#	Line 329 | Line 341 | char  *p;                      /* data for f */
341		nhits++;
342		source[scp->sno].nhits++;
343		}
344	<	/* surface hit rate */
345	<	if (sn > 0)
346	<	hwt = (double)nhits / (double)sn;
344	>	/* source hit rate */
345	>	if (hwt > FTINY)
346	>	hwt = (double)nhits / hwt;
347		else
348		hwt = 0.5;
349		#ifdef DEBUG
350	<	sprintf(errmsg, "%d tested, %d untested, %f hit rate\n",
350	>	sprintf(errmsg, "%d tested, %d untested, %f conditional hit rate\n",
351		sn, ncnts-sn, hwt);
352		eputs(errmsg);
353		#endif
#	Line 344 | Line 356 | char  *p;                      /* data for f */
356		scp = srccnt + cntord[sn].sndx;
357		prob = hwt * (double)source[scp->sno].nhits /
358		(double)source[scp->sno].ntests;
359	+	if (prob > 1.0)
360	+	prob = 1.0;
361		scalecolor(scp->val, prob);
362		addcolor(r->rcol, scp->val);
363		}
#	Line 355 | Line 369 | char  *p;                      /* data for f */
369		* because they are very nasty and difficult to understand.
370		*/
371
372	<	/* wrongillum *
372	>	/* illumblock *
373		*
374		* We cannot allow an illum to pass to another illum, because that
375		* would almost certainly constitute overcounting.
376		* However, we do allow an illum to pass to another illum
377		* that is actually going to relay to a virtual light source.
378	+	* We also prevent an illum from passing to a glow; this provides a
379	+	* convenient mechanism for defining detailed light source
380	+	* geometry behind (or inside) an effective radiator.
381		*/
382
383	<	#define  wrongillum(m, r)       (!(source[r->rsrc].sflags&SVIRTUAL) && \
384	<	objptr(source[r->rsrc].so->omod)->otype==MAT_ILLUM)
383	>	static int weaksrcmod(obj) int obj;     /* efficiency booster function */
384	>	{register OBJREC *o = objptr(obj);
385	>	return(o->otype==MAT_ILLUM|o->otype==MAT_GLOW);}
386
387	+	#define  illumblock(m, r)       (!(source[r->rsrc].sflags&SVIRTUAL) && \
388	+	r->rod > 0.0 && \
389	+	weaksrcmod(source[r->rsrc].so->omod))
390	+
391		/* wrongsource *
392		*
393		* This source is the wrong source (ie. overcounted) if we are
394		* aimed to a different source than the one we hit and the one
395	<	* we hit is not an illum which should be passed.
395	>	* we hit is not an illum that should be passed.
396		*/
397
398		#define  wrongsource(m, r)      (r->rsrc>=0 && source[r->rsrc].so!=r->ro && \
399	<	(m->otype!=MAT_ILLUM || wrongillum(m,r)))
399	>	(m->otype!=MAT_ILLUM || illumblock(m,r)))
400
401		/* distglow *
402		*
403		* A distant glow is an object that sometimes acts as a light source,
404		* but is too far away from the test point to be one in this case.
405	+	* (Glows with negative radii should NEVER participate in illumination.)
406		*/
407
408	<	#define  distglow(m, r)         (m->otype==MAT_GLOW && \
409	<	r->rot > m->oargs.farg[3])
408	>	#define  distglow(m, r, d)      (m->otype==MAT_GLOW && \
409	>	m->oargs.farg[3] >= -FTINY && \
410	>	d > m->oargs.farg[3])
411
412		/* badcomponent *
413		*
#	Line 396 | Line 420 | char  *p;                      /* data for f */
420
421		#define  badcomponent(m, r)     (r->crtype&(AMBIENT|SPECULAR) && \
422		!(r->crtype&SHADOW || r->rod < 0.0 || \
423	<	distglow(m, r)))
423	>	/* not 100% correct */  distglow(m, r, r->rot)))
424
401	–	/* overcount *
402	–	*
403	–	* All overcounting possibilities are contained here.
404	–	*/
405	–
406	–	#define  overcount(m, r)        (badcomponent(m,r) || wrongsource(m,r))
407	–
425		/* passillum *
426		*
427		* An illum passes to another material type when we didn't hit it
#	Line 418 | Line 435 | char  *p;                      /* data for f */
435
436		/* srcignore *
437		*
438	<	* The -di flag renders light sources invisible, and here is the test.
438	>	* The -dv flag is normally on for sources to be visible.
439		*/
440
441	<	#define  srcignore(m, r)        (directinvis && !(r->crtype&SHADOW) && \
442	<	!distglow(m, r))
441	>	#define  srcignore(m, r)        !(directvis || r->crtype&SHADOW || \
442	>	distglow(m, r, raydist(r,PRIMARY)))
443
444
445		m_light(m, r)                   /* ray hit a light source */
#	Line 430 | Line 447 | register OBJREC  *m;
447		register RAY  *r;
448		{
449		/* check for over-counting */
450	<	if (overcount(m, r))
451	<	return;
450	>	if (badcomponent(m, r))
451	>	return(1);
452	>	if (wrongsource(m, r))
453	>	return(1);
454		/* check for passed illum */
455		if (passillum(m, r)) {
456	<	if (m->oargs.nsargs < 1 || !strcmp(m->oargs.sarg[0], VOIDID))
457	<	raytrans(r);
458	<	else
459	<	rayshade(r, modifier(m->oargs.sarg[0]));
441	<	return;
456	>	if (m->oargs.nsargs && strcmp(m->oargs.sarg[0], VOIDID))
457	>	return(rayshade(r, modifier(m->oargs.sarg[0])));
458	>	raytrans(r);
459	>	return(1);
460		}
461		/* otherwise treat as source */
462		/* check for behind */
463		if (r->rod < 0.0)
464	<	return;
464	>	return(1);
465		/* check for invisibility */
466		if (srcignore(m, r))
467	<	return;
467	>	return(1);
468		/* check for outside spot */
469		if (m->otype==MAT_SPOT && spotout(r, makespot(m), r->rot>=FHUGE))
470	<	return;
470	>	return(1);
471		/* get distribution pattern */
472		raytexture(r, m->omod);
473		/* get source color */
#	Line 458 | Line 476 | register RAY  *r;
476		m->oargs.farg[2]);
477		/* modify value */
478		multcolor(r->rcol, r->pcol);
479	+	return(1);
480		}

Diff Legend

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