--- ray/src/rt/source.c	1992/11/14 13:58:23	2.8
+++ ray/src/rt/source.c	1993/12/21 15:46:19	2.13
@@ -1,4 +1,4 @@
-/* Copyright (c) 1992 Regents of the University of California */
+/* Copyright (c) 1993 Regents of the University of California */
 
 #ifndef lint
 static char SCCSid[] = "$SunId$ LBL";
@@ -299,8 +299,10 @@ char  *p;			/* data for f */
 						/* modify threshold */
 	ourthresh = shadthresh / r->rweight;
 						/* test for shadows */
-	nhits = 0;
-	for (sn = 0; sn < ncnts; sn++) {
+	for (nhits = 0, hwt = 0.0, sn = 0; sn < ncnts;
+			hwt += (double)source[scp->sno].nhits /
+				(double)source[scp->sno].ntests,
+			sn++) {
 						/* check threshold */
 		if ((sn+nshadcheck>=ncnts ? cntord[sn].brt :
 				cntord[sn].brt-cntord[sn+nshadcheck].brt)
@@ -329,13 +331,13 @@ char  *p;			/* data for f */
 		nhits++;
 		source[scp->sno].nhits++;
 	}
-					/* surface hit rate */
-	if (sn > 0)
-		hwt = (double)nhits / (double)sn;
+					/* source hit rate */
+	if (hwt > FTINY)
+		hwt = (double)nhits / hwt;
 	else
 		hwt = 0.5;
 #ifdef DEBUG
-	sprintf(errmsg, "%d tested, %d untested, %f hit rate\n",
+	sprintf(errmsg, "%d tested, %d untested, %f conditional hit rate\n",
 			sn, ncnts-sn, hwt);
 	eputs(errmsg);
 #endif
@@ -344,6 +346,8 @@ char  *p;			/* data for f */
 		scp = srccnt + cntord[sn].sndx;
 		prob = hwt * (double)source[scp->sno].nhits /
 				(double)source[scp->sno].ntests;
+		if (prob > 1.0)
+			prob = 1.0;
 		scalecolor(scp->val, prob);
 		addcolor(r->rcol, scp->val);
 	}
@@ -355,34 +359,44 @@ char  *p;			/* data for f */
  * because they are very nasty and difficult to understand.
  */
 
-/* wrongillum *
+/* illumblock *
  *
  * We cannot allow an illum to pass to another illum, because that
  * would almost certainly constitute overcounting.
  * However, we do allow an illum to pass to another illum
  * that is actually going to relay to a virtual light source.
+ * We also prevent an illum from passing to a glow; this provides a
+ * convenient mechanism for defining detailed light source
+ * geometry behind (or inside) an effective radiator.
  */
 
-#define  wrongillum(m, r)	(!(source[r->rsrc].sflags&SVIRTUAL) && \
-			objptr(source[r->rsrc].so->omod)->otype==MAT_ILLUM)
+static int weaksrcmod(obj) int obj;	/* efficiency booster function */
+{register OBJREC *o = objptr(obj);
+return(o->otype==MAT_ILLUM|o->otype==MAT_GLOW);}
 
+#define  illumblock(m, r)	(!(source[r->rsrc].sflags&SVIRTUAL) && \
+				r->rod > 0.0 && \
+				weaksrcmod(source[r->rsrc].so->omod))
+
 /* wrongsource *
  *
  * This source is the wrong source (ie. overcounted) if we are
  * aimed to a different source than the one we hit and the one
- * we hit is not an illum which should be passed.
+ * we hit is not an illum that should be passed.
  */
 
 #define  wrongsource(m, r)	(r->rsrc>=0 && source[r->rsrc].so!=r->ro && \
-				(m->otype!=MAT_ILLUM || wrongillum(m,r)))
+				(m->otype!=MAT_ILLUM || illumblock(m,r)))
 
 /* distglow *
  *
  * A distant glow is an object that sometimes acts as a light source,
  * but is too far away from the test point to be one in this case.
+ * (Glows with negative radii should NEVER participate in illumination.)
  */
 
 #define  distglow(m, r)		(m->otype==MAT_GLOW && \
+				m->oargs.farg[3] >= -FTINY && \
 				r->rot > m->oargs.farg[3])
 
 /* badcomponent *
@@ -398,13 +412,6 @@ char  *p;			/* data for f */
 				!(r->crtype&SHADOW || r->rod < 0.0 || \
 					distglow(m, r)))
 
-/* overcount *
- *
- * All overcounting possibilities are contained here.
- */
-
-#define  overcount(m, r)	(badcomponent(m,r) || wrongsource(m,r))
-
 /* passillum *
  *
  * An illum passes to another material type when we didn't hit it
@@ -418,10 +425,10 @@ char  *p;			/* data for f */
 
 /* srcignore *
  *
- * The -di flag renders light sources invisible, and here is the test.
+ * The -dv flag is normally on for sources to be visible.
  */
 
-#define  srcignore(m, r)	(directinvis && !(r->crtype&SHADOW) && \
+#define  srcignore(m, r)	(!directvis && !(r->crtype&SHADOW) && \
 				!distglow(m, r))
 
 
@@ -430,7 +437,9 @@ register OBJREC  *m;
 register RAY  *r;
 {
 						/* check for over-counting */
-	if (overcount(m, r))
+	if (badcomponent(m, r))
+		return;
+	if (wrongsource(m,r))
 		return;
 						/* check for passed illum */
 	if (passillum(m, r)) {