--- ray/src/rt/srcsupp.c	1991/06/25 15:34:17	1.7
+++ ray/src/rt/srcsupp.c	1992/08/28 15:10:47	2.6
@@ -1,4 +1,4 @@
-/* Copyright (c) 1991 Regents of the University of California */
+/* Copyright (c) 1992 Regents of the University of California */
 
 #ifndef lint
 static char SCCSid[] = "$SunId$ LBL";
@@ -18,6 +18,7 @@ static char SCCSid[] = "$SunId$ LBL";
 
 #include  "face.h"
 
+#define SRCINC		4		/* realloc increment for array */
 
 SRCREC  *source = NULL;			/* our list of sources */
 int  nsources = 0;			/* the number of sources */
@@ -27,19 +28,24 @@ SRCFUNC  sfun[NUMOTYPE];		/* source dispatch table */
 
 initstypes()			/* initialize source dispatch table */
 {
-	extern VSMATERIAL  mirror_vs;
-	extern int  fsetsrc(), ssetsrc(), sphsetsrc(), rsetsrc();
+	extern VSMATERIAL  mirror_vs, direct1_vs, direct2_vs;
+	extern int  fsetsrc(), ssetsrc(), sphsetsrc(), cylsetsrc(), rsetsrc();
+	extern int  nopart(), flatpart(), cylpart();
 	extern double  fgetplaneq(), rgetplaneq();
 	extern double  fgetmaxdisk(), rgetmaxdisk();
-	static SOBJECT  fsobj = {fsetsrc, fgetplaneq, fgetmaxdisk};
-	static SOBJECT  ssobj = {ssetsrc};
-	static SOBJECT  sphsobj = {sphsetsrc};
-	static SOBJECT  rsobj = {rsetsrc, rgetplaneq, rgetmaxdisk};
+	static SOBJECT  fsobj = {fsetsrc, flatpart, fgetplaneq, fgetmaxdisk};
+	static SOBJECT  ssobj = {ssetsrc, nopart};
+	static SOBJECT  sphsobj = {sphsetsrc, nopart};
+	static SOBJECT  cylsobj = {cylsetsrc, cylpart};
+	static SOBJECT  rsobj = {rsetsrc, flatpart, rgetplaneq, rgetmaxdisk};
 
 	sfun[MAT_MIRROR].mf = &mirror_vs;
+	sfun[MAT_DIRECT1].mf = &direct1_vs;
+	sfun[MAT_DIRECT2].mf = &direct2_vs;
 	sfun[OBJ_FACE].of = &fsobj;
 	sfun[OBJ_SOURCE].of = &ssobj;
 	sfun[OBJ_SPHERE].of = &sphsobj;
+	sfun[OBJ_CYLINDER].of = &cylsobj;
 	sfun[OBJ_RING].of = &rsobj;
 }
 
@@ -48,10 +54,10 @@ int
 newsource()			/* allocate new source in our array */
 {
 	if (nsources == 0)
-		source = (SRCREC *)malloc(sizeof(SRCREC));
-	else
+		source = (SRCREC *)malloc(SRCINC*sizeof(SRCREC));
+	else if (nsources%SRCINC == 0)
 		source = (SRCREC *)realloc((char *)source,
-				(unsigned)(nsources+1)*sizeof(SRCREC));
+				(unsigned)(nsources+SRCINC)*sizeof(SRCREC));
 	if (source == NULL)
 		return(-1);
 	source[nsources].sflags = 0;
@@ -61,12 +67,32 @@ newsource()			/* allocate new source in our array */
 }
 
 
+setflatss(src)				/* set sampling for a flat source */
+register SRCREC  *src;
+{
+	double  mult;
+	register int  i;
+
+	src->ss[SV][0] = src->ss[SV][1] = src->ss[SV][2] = 0.0;
+	for (i = 0; i < 3; i++)
+		if (src->snorm[i] < 0.6 && src->snorm[i] > -0.6)
+			break;
+	src->ss[SV][i] = 1.0;
+	fcross(src->ss[SU], src->ss[SV], src->snorm);
+	mult = .5 * sqrt( src->ss2 / DOT(src->ss[SU],src->ss[SU]) );
+	for (i = 0; i < 3; i++)
+		src->ss[SU][i] *= mult;
+	fcross(src->ss[SV], src->snorm, src->ss[SU]);
+}
+
+
 fsetsrc(src, so)			/* set a face as a source */
 register SRCREC  *src;
 OBJREC  *so;
 {
 	register FACE  *f;
 	register int  i, j;
+	double  d;
 	
 	src->sa.success = 2*AIMREQT-1;		/* bitch on second failure */
 	src->so = so;
@@ -83,8 +109,24 @@ OBJREC  *so;
 		objerror(so, USER, "cannot hit center");
 	src->sflags |= SFLAT;
 	VCOPY(src->snorm, f->norm);
-	src->ss = sqrt(f->area / PI);
 	src->ss2 = f->area;
+						/* find maximum radius */
+	src->srad = 0.;
+	for (i = 0; i < f->nv; i++) {
+		d = dist2(VERTEX(f,i), src->sloc);
+		if (d > src->srad)
+			src->srad = d;
+	}
+	src->srad = sqrt(src->srad);
+						/* compute size vectors */
+	if (f->nv == 4 || (f->nv == 5 &&	/* parallelogram case */
+			dist2(VERTEX(f,0),VERTEX(f,4)) <= FTINY*FTINY))
+		for (j = 0; j < 3; j++) {
+			src->ss[SU][j] = .5*(VERTEX(f,1)[j]-VERTEX(f,0)[j]);
+			src->ss[SV][j] = .5*(VERTEX(f,3)[j]-VERTEX(f,0)[j]);
+		}
+	else
+		setflatss(src);
 }
 
 
@@ -105,8 +147,12 @@ register OBJREC  *so;
 	theta = PI/180.0/2.0 * so->oargs.farg[3];
 	if (theta <= FTINY)
 		objerror(so, USER, "zero size");
-	src->ss = theta >= PI/4.0 ? 1.0 : tan(theta);
 	src->ss2 = 2.0*PI * (1.0 - cos(theta));
+					/* the following is approximate */
+	src->srad = sqrt(src->ss2/PI);
+	VCOPY(src->snorm, src->sloc);
+	setflatss(src);			/* hey, whatever works */
+	src->ss[SW][0] = src->ss[SW][1] = src->ss[SW][2] = 0.0;
 }
 
 
@@ -114,6 +160,8 @@ sphsetsrc(src, so)			/* set a sphere as a source */
 register SRCREC  *src;
 register OBJREC  *so;
 {
+	register int  i;
+
 	src->sa.success = 2*AIMREQT-1;		/* bitch on second failure */
 	src->so = so;
 	if (so->oargs.nfargs != 4)
@@ -121,8 +169,12 @@ register OBJREC  *so;
 	if (so->oargs.farg[3] <= FTINY)
 		objerror(so, USER, "illegal radius");
 	VCOPY(src->sloc, so->oargs.farg);
-	src->ss = so->oargs.farg[3];
-	src->ss2 = PI * src->ss * src->ss;
+	src->srad = so->oargs.farg[3];
+	src->ss2 = PI * src->srad * src->srad;
+	for (i = 0; i < 3; i++)
+		src->ss[SU][i] = src->ss[SV][i] = src->ss[SW][i] = 0.0;
+	for (i = 0; i < 3; i++)
+		src->ss[i][i] = .7236 * so->oargs.farg[3];
 }
 
 
@@ -141,27 +193,95 @@ OBJREC  *so;
 		objerror(so, USER, "cannot hit center");
 	src->sflags |= SFLAT;
 	VCOPY(src->snorm, co->ad);
-	src->ss = CO_R1(co);
-	src->ss2 = PI * src->ss * src->ss;
+	src->srad = CO_R1(co);
+	src->ss2 = PI * src->srad * src->srad;
+	setflatss(src);
 }
 
 
+cylsetsrc(src, so)			/* set a cylinder as a source */
+register SRCREC  *src;
+OBJREC  *so;
+{
+	register CONE  *co;
+	register int  i;
+	
+	src->sa.success = 4*AIMREQT-1;		/* bitch on fourth failure */
+	src->so = so;
+						/* get the cylinder */
+	co = getcone(so, 0);
+	if (CO_R0(co) > .2*co->al)		/* heuristic constraint */
+		objerror(so, WARNING, "source aspect too small");
+	src->sflags |= SCYL;
+	for (i = 0; i < 3; i++)
+		src->sloc[i] = .5 * (CO_P1(co)[i] + CO_P0(co)[i]);
+	src->srad = .5*co->al;
+	src->ss2 = 2.*CO_R0(co)*co->al;
+						/* set sampling vectors */
+	for (i = 0; i < 3; i++)
+		src->ss[SU][i] = .5 * co->al * co->ad[i];
+	src->ss[SV][0] = src->ss[SV][1] = src->ss[SV][2] = 0.0;
+	for (i = 0; i < 3; i++)
+		if (co->ad[i] < 0.6 && co->ad[i] > -0.6)
+			break;
+	src->ss[SV][i] = 1.0;
+	fcross(src->ss[SW], src->ss[SV], co->ad);
+	normalize(src->ss[SW]);
+	for (i = 0; i < 3; i++)
+		src->ss[SW][i] *= .8559 * CO_R0(co);
+	fcross(src->ss[SV], src->ss[SW], co->ad);
+}
+
+
 SPOT *
 makespot(m)			/* make a spotlight */
 register OBJREC  *m;
 {
 	register SPOT  *ns;
 
+	if ((ns = (SPOT *)m->os) != NULL)
+		return(ns);
 	if ((ns = (SPOT *)malloc(sizeof(SPOT))) == NULL)
 		return(NULL);
 	ns->siz = 2.0*PI * (1.0 - cos(PI/180.0/2.0 * m->oargs.farg[3]));
 	VCOPY(ns->aim, m->oargs.farg+4);
 	if ((ns->flen = normalize(ns->aim)) == 0.0)
 		objerror(m, USER, "zero focus vector");
+	m->os = (char *)ns;
 	return(ns);
 }
 
 
+spotout(r, s, dist)		/* check if we're outside spot region */
+register RAY  *r;
+register SPOT  *s;
+int  dist;
+{
+	double  d;
+	FVECT  vd;
+	
+	if (s == NULL)
+		return(0);
+	if (dist) {			/* distant source */
+		vd[0] = s->aim[0] - r->rorg[0];
+		vd[1] = s->aim[1] - r->rorg[1];
+		vd[2] = s->aim[2] - r->rorg[2];
+		d = DOT(r->rdir,vd);
+		/*			wrong side?
+		if (d <= FTINY)
+			return(1);	*/
+		d = DOT(vd,vd) - d*d;
+		if (PI*d > s->siz)
+			return(1);	/* out */
+		return(0);	/* OK */
+	}
+					/* local source */
+	if (s->siz < 2.0*PI * (1.0 + DOT(s->aim,r->rdir)))
+		return(1);	/* out */
+	return(0);	/* OK */
+}
+
+
 double
 fgetmaxdisk(ocent, op)		/* get center and squared radius of face */
 FVECT  ocent;
@@ -288,10 +408,10 @@ FVECT  nrm;		/* source surface normal */
 
 	d = DOT(sp->aim, nrm);
 	if (d > FTINY)			/* center in front? */
-		return(0);
+		return(1);
 					/* else check horizon */
 	d1 = 1. - sp->siz/(2.*PI);
-	return(1.-FTINY-d*d > d1*d1);
+	return(1.-FTINY-d*d < d1*d1);
 }
 
 
@@ -375,82 +495,4 @@ double  r1s, r2s;		/* radii squared */
 	for (i = 0; i < 3; i++)
 		cc[i] = c1[i] + l*disp[i];
 	return(a2);
-}
-
-
-sourcehit(r)			/* check to see if ray hit distant source */
-register RAY  *r;
-{
-	int  first, last;
-	register int  i;
-
-	if (r->rsrc >= 0) {		/* check only one if aimed */
-		first = last = r->rsrc;
-	} else {			/* otherwise check all */
-		first = 0; last = nsources-1;
-	}
-	for (i = first; i <= last; i++)
-		if (source[i].sflags & SDISTANT)
-			/*
-			 * Check to see if ray is within
-			 * solid angle of source.
-			 */
-			if (2.0*PI * (1.0 - DOT(source[i].sloc,r->rdir))
-					<= source[i].ss2) {
-				r->ro = source[i].so;
-				if (!(source[i].sflags & SSKIP))
-					break;
-			}
-
-	if (r->ro != NULL) {
-		for (i = 0; i < 3; i++)
-			r->ron[i] = -r->rdir[i];
-		r->rod = 1.0;
-		r->rox = NULL;
-		return(1);
-	}
-	return(0);
-}
-
-
-#define  wrongsource(m, r)	(m->otype!=MAT_ILLUM && \
-				r->rsrc>=0 && \
-				source[r->rsrc].so!=r->ro)
-
-#define  badambient(m, r)	((r->crtype&(AMBIENT|SHADOW))==AMBIENT && \
-				!(m->otype==MAT_GLOW&&r->rot>m->oargs.farg[3]))
-
-#define  passillum(m, r)	(m->otype==MAT_ILLUM && \
-				!(r->rsrc>=0&&source[r->rsrc].so==r->ro))
-
-
-m_light(m, r)			/* ray hit a light source */
-register OBJREC  *m;
-register RAY  *r;
-{
-						/* check for over-counting */
-	if (wrongsource(m, r) || badambient(m, r))
-		return;
-						/* check for passed illum */
-	if (passillum(m, r)) {
-
-		if (m->oargs.nsargs < 1 || !strcmp(m->oargs.sarg[0], VOIDID))
-			raytrans(r);
-		else
-			rayshade(r, modifier(m->oargs.sarg[0]));
-
-						/* otherwise treat as source */
-	} else {
-						/* check for behind */
-		if (r->rod < 0.0)
-			return;
-						/* get distribution pattern */
-		raytexture(r, m->omod);
-						/* get source color */
-		setcolor(r->rcol, m->oargs.farg[0],
-				  m->oargs.farg[1],
-				  m->oargs.farg[2]);
-						/* modify value */
-		multcolor(r->rcol, r->pcol);
-	}
 }