ViewVC Help

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

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

Comparing ray/src/rt/srcsupp.c (file contents):
Revision 2.3 by greg, Wed Jan 15 16:54:50 1992 UTC vs.
Revision 2.6 by greg, Fri Aug 28 15:10:47 1992 UTC

#	Line 239 | Line 239 | register OBJREC  *m;
239		{
240		register SPOT  *ns;
241
242	+	if ((ns = (SPOT *)m->os) != NULL)
243	+	return(ns);
244		if ((ns = (SPOT *)malloc(sizeof(SPOT))) == NULL)
245		return(NULL);
246		ns->siz = 2.0*PI * (1.0 - cos(PI/180.0/2.0 * m->oargs.farg[3]));
247		VCOPY(ns->aim, m->oargs.farg+4);
248		if ((ns->flen = normalize(ns->aim)) == 0.0)
249		objerror(m, USER, "zero focus vector");
250	+	m->os = (char *)ns;
251		return(ns);
252		}
253
254
255	+	spotout(r, s, dist)             /* check if we're outside spot region */
256	+	register RAY  *r;
257	+	register SPOT  *s;
258	+	int  dist;
259	+	{
260	+	double  d;
261	+	FVECT  vd;
262	+
263	+	if (s == NULL)
264	+	return(0);
265	+	if (dist) {                     /* distant source */
266	+	vd[0] = s->aim[0] - r->rorg[0];
267	+	vd[1] = s->aim[1] - r->rorg[1];
268	+	vd[2] = s->aim[2] - r->rorg[2];
269	+	d = DOT(r->rdir,vd);
270	+	/*                      wrong side?
271	+	if (d <= FTINY)
272	+	return(1);      */
273	+	d = DOT(vd,vd) - d*d;
274	+	if (PI*d > s->siz)
275	+	return(1);      /* out */
276	+	return(0);      /* OK */
277	+	}
278	+	/* local source */
279	+	if (s->siz < 2.0*PI * (1.0 + DOT(s->aim,r->rdir)))
280	+	return(1);      /* out */
281	+	return(0);      /* OK */
282	+	}
283	+
284	+
285		double
286		fgetmaxdisk(ocent, op)          /* get center and squared radius of face */
287		FVECT  ocent;
#	Line 462 | Line 495 | double  r1s, r2s;              /* radii squared */
495		for (i = 0; i < 3; i++)
496		cc[i] = c1[i] + l*disp[i];
497		return(a2);
465	–	}
466	–
467	–
468	–	sourcehit(r)                    /* check to see if ray hit distant source */
469	–	register RAY  *r;
470	–	{
471	–	int  first, last;
472	–	register int  i;
473	–
474	–	if (r->rsrc >= 0) {             /* check only one if aimed */
475	–	first = last = r->rsrc;
476	–	} else {                        /* otherwise check all */
477	–	first = 0; last = nsources-1;
478	–	}
479	–	for (i = first; i <= last; i++)
480	–	if ((source[i].sflags & (SDISTANT|SVIRTUAL)) == SDISTANT)
481	–	/*
482	–	* Check to see if ray is within
483	–	* solid angle of source.
484	–	*/
485	–	if (2.0*PI * (1.0 - DOT(source[i].sloc,r->rdir))
486	–	<= source[i].ss2) {
487	–	r->ro = source[i].so;
488	–	if (!(source[i].sflags & SSKIP))
489	–	break;
490	–	}
491	–
492	–	if (r->ro != NULL) {
493	–	for (i = 0; i < 3; i++)
494	–	r->ron[i] = -r->rdir[i];
495	–	r->rod = 1.0;
496	–	r->rox = NULL;
497	–	return(1);
498	–	}
499	–	return(0);
500	–	}
501	–
502	–
503	–	/****************************************************************
504	–	* The following macros were separated from the m_light() routine
505	–	* because they are very nasty and difficult to understand.
506	–	*/
507	–
508	–	/* wrongillum *
509	–	*
510	–	* We cannot allow an illum to pass to another illum, because that
511	–	* would almost certainly constitute overcounting.
512	–	* However, we do allow an illum to pass to another illum
513	–	* that is actually going to relay to a virtual light source.
514	–	*/
515	–
516	–	#define  wrongillum(m, r)       (!(source[r->rsrc].sflags&SVIRTUAL) && \
517	–	objptr(source[r->rsrc].so->omod)->otype==MAT_ILLUM)
518	–
519	–	/* wrongsource *
520	–	*
521	–	* This source is the wrong source (ie. overcounted) if we are
522	–	* aimed to a different source than the one we hit and the one
523	–	* we hit is not an illum which should be passed.
524	–	*/
525	–
526	–	#define  wrongsource(m, r)      (r->rsrc>=0 && source[r->rsrc].so!=r->ro && \
527	–	(m->otype!=MAT_ILLUM || wrongillum(m,r)))
528	–
529	–	/* distglow *
530	–	*
531	–	* A distant glow is an object that sometimes acts as a light source,
532	–	* but is too far away from the test point to be one in this case.
533	–	*/
534	–
535	–	#define  distglow(m, r)         (m->otype==MAT_GLOW && \
536	–	r->rot > m->oargs.farg[3])
537	–
538	–	/* badcomponent *
539	–	*
540	–	* We must avoid counting light sources in the ambient calculation,
541	–	* since the direct component is handled separately.  Therefore, any
542	–	* ambient ray which hits an active light source must be discarded.
543	–	* The same is true for stray specular samples, since the specular
544	–	* contribution from light sources is calculated separately.
545	–	*/
546	–
547	–	#define  badcomponent(m, r)     (r->crtype&(AMBIENT|SPECULAR) && \
548	–	!(r->crtype&SHADOW || distglow(m, r)))
549	–
550	–	/* overcount *
551	–	*
552	–	* All overcounting possibilities are contained here.
553	–	*/
554	–
555	–	#define  overcount(m, r)        (badcomponent(m,r) || wrongsource(m,r))
556	–
557	–	/* passillum *
558	–	*
559	–	* An illum passes to another material type when we didn't hit it
560	–	* on purpose (as part of a direct calculation), or it is relaying
561	–	* a virtual light source.
562	–	*/
563	–
564	–	#define  passillum(m, r)        (m->otype==MAT_ILLUM && \
565	–	(r->rsrc<0 || source[r->rsrc].so!=r->ro || \
566	–	source[r->rsrc].sflags&SVIRTUAL))
567	–
568	–	/* srcignore *
569	–	*
570	–	* The -di flag renders light sources invisible, and here is the test.
571	–	*/
572	–
573	–	#define  srcignore(m, r)        (directinvis && !(r->crtype&SHADOW) && \
574	–	!distglow(m, r))
575	–
576	–
577	–	m_light(m, r)                   /* ray hit a light source */
578	–	register OBJREC  *m;
579	–	register RAY  *r;
580	–	{
581	–	/* check for over-counting */
582	–	if (overcount(m, r))
583	–	return;
584	–	/* check for passed illum */
585	–	if (passillum(m, r)) {
586	–	if (m->oargs.nsargs < 1 || !strcmp(m->oargs.sarg[0], VOIDID))
587	–	raytrans(r);
588	–	else
589	–	rayshade(r, modifier(m->oargs.sarg[0]));
590	–	return;
591	–	}
592	–	/* otherwise treat as source */
593	–	/* check for behind */
594	–	if (r->rod < 0.0)
595	–	return;
596	–	/* check for invisibility */
597	–	if (srcignore(m, r))
598	–	return;
599	–	/* get distribution pattern */
600	–	raytexture(r, m->omod);
601	–	/* get source color */
602	–	setcolor(r->rcol, m->oargs.farg[0],
603	–	m->oargs.farg[1],
604	–	m->oargs.farg[2]);
605	–	/* modify value */
606	–	multcolor(r->rcol, r->pcol);
498		}

Diff Legend

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