--- ray/src/rt/raytrace.c	1994/12/21 09:10:23	2.17
+++ ray/src/rt/raytrace.c	2004/03/30 16:13:01	2.45
@@ -1,34 +1,25 @@
-/* Copyright (c) 1994 Regents of the University of California */
-
 #ifndef lint
-static char SCCSid[] = "$SunId$ LBL";
+static const char RCSid[] = "$Id: raytrace.c,v 2.45 2004/03/30 16:13:01 schorsch Exp $";
 #endif
-
 /*
  *  raytrace.c - routines for tracing and shading rays.
  *
- *     8/7/85
+ *  External symbols declared in ray.h
  */
 
-#include  "ray.h"
+#include "copyright.h"
 
-#include  "octree.h"
-
+#include  "ray.h"
+#include  "source.h"
 #include  "otypes.h"
-
 #include  "otspecial.h"
 
 #define  MAXCSET	((MAXSET+1)*2-1)	/* maximum check set size */
 
-extern CUBE  thescene;			/* our scene */
-extern int  maxdepth;			/* maximum recursion depth */
-extern double  minweight;		/* minimum ray weight */
-extern int  do_irrad;			/* compute irradiance? */
-
 unsigned long  raynum = 0;		/* next unique ray number */
 unsigned long  nrays = 0;		/* number of calls to localhit */
 
-static FLOAT  Lambfa[5] = {PI, PI, PI, 0.0, 0.0};
+static RREAL  Lambfa[5] = {PI, PI, PI, 0.0, 0.0};
 OBJREC  Lamb = {
 	OVOID, MAT_PLASTIC, "Lambertian",
 	{0, 5, NULL, Lambfa}, NULL,
@@ -36,18 +27,23 @@ OBJREC  Lamb = {
 
 OBJREC  Aftplane;			/* aft clipping plane object */
 
-static int  raymove(), checkset(), checkhit();
-
-#define  MAXLOOP	128		/* modifier loop detection */
-
 #define  RAYHIT		(-1)		/* return value for intercepted ray */
 
+static int raymove(FVECT  pos, OBJECT  *cxs, int  dirf, RAY  *r, CUBE  *cu);
+static int checkhit(RAY  *r, CUBE  *cu, OBJECT  *cxs);
+static void checkset(OBJECT  *os, OBJECT  *cs);
 
-rayorigin(r, ro, rt, rw)		/* start new ray from old one */
-register RAY  *r, *ro;
-int  rt;
-double  rw;
+
+extern int
+rayorigin(		/* start new ray from old one */
+	register RAY  *r,
+	register RAY  *ro,
+	int  rt,
+	double  rw
+)
 {
+	double	re;
+
 	if ((r->parent = ro) == NULL) {		/* primary ray */
 		r->rlvl = 0;
 		r->rweight = rw;
@@ -55,84 +51,101 @@ double  rw;
 		r->rsrc = -1;
 		r->clipset = NULL;
 		r->revf = raytrace;
+		copycolor(r->cext, cextinction);
+		copycolor(r->albedo, salbedo);
+		r->gecc = seccg;
+		r->slights = NULL;
 	} else {				/* spawned ray */
 		r->rlvl = ro->rlvl;
 		if (rt & RAYREFL) {
 			r->rlvl++;
 			r->rsrc = -1;
 			r->clipset = ro->clipset;
+			r->rmax = 0.0;
 		} else {
 			r->rsrc = ro->rsrc;
 			r->clipset = ro->newcset;
+			r->rmax = ro->rmax <= FTINY ? 0.0 : ro->rmax - ro->rot;
 		}
 		r->revf = ro->revf;
-		r->rweight = ro->rweight * rw;
+		copycolor(r->cext, ro->cext);
+		copycolor(r->albedo, ro->albedo);
+		r->gecc = ro->gecc;
+		r->slights = ro->slights;
 		r->crtype = ro->crtype | (r->rtype = rt);
 		VCOPY(r->rorg, ro->rop);
-		r->rmax = 0.0;
+		r->rweight = ro->rweight * rw;
+						/* estimate absorption */
+		re = colval(ro->cext,RED) < colval(ro->cext,GRN) ?
+				colval(ro->cext,RED) : colval(ro->cext,GRN);
+		if (colval(ro->cext,BLU) < re) re = colval(ro->cext,BLU);
+		if (re > 0.)
+			r->rweight *= exp(-re*ro->rot);
 	}
 	rayclear(r);
 	return(r->rlvl <= maxdepth && r->rweight >= minweight ? 0 : -1);
 }
 
 
-rayclear(r)			/* clear a ray for (re)evaluation */
-register RAY  *r;
+extern void
+rayclear(			/* clear a ray for (re)evaluation */
+	register RAY  *r
+)
 {
 	r->rno = raynum++;
 	r->newcset = r->clipset;
+	r->hitf = rayhit;
+	r->robj = OVOID;
 	r->ro = NULL;
-	r->rot = FHUGE;
+	r->rox = NULL;
+	r->rt = r->rot = FHUGE;
 	r->pert[0] = r->pert[1] = r->pert[2] = 0.0;
+	r->uv[0] = r->uv[1] = 0.0;
 	setcolor(r->pcol, 1.0, 1.0, 1.0);
 	setcolor(r->rcol, 0.0, 0.0, 0.0);
-	r->rt = 0.0;
 }
 
 
-raytrace(r)			/* trace a ray and compute its value */
-RAY  *r;
+extern void
+raytrace(			/* trace a ray and compute its value */
+	RAY  *r
+)
 {
-	extern int  (*trace)();
-	int  gotmat;
-
 	if (localhit(r, &thescene))
-		gotmat = raycont(r);
+		raycont(r);		/* hit local surface, evaluate */
 	else if (r->ro == &Aftplane) {
-		r->ro = NULL;
+		r->ro = NULL;		/* hit aft clipping plane */
 		r->rot = FHUGE;
 	} else if (sourcehit(r))
-		gotmat = rayshade(r, r->ro->omod);
+		rayshade(r, r->ro->omod);	/* distant source */
 
-	if (r->ro != NULL && !gotmat)
-		objerror(r->ro, USER, "material not found");
+	rayparticipate(r);		/* for participating medium */
 
 	if (trace != NULL)
 		(*trace)(r);		/* trace execution */
 }
 
 
-raycont(r)			/* check for clipped object and continue */
-register RAY  *r;
+extern void
+raycont(			/* check for clipped object and continue */
+	register RAY  *r
+)
 {
 	if ((r->clipset != NULL && inset(r->clipset, r->ro->omod)) ||
-			r->ro->omod == OVOID) {
+			!rayshade(r, r->ro->omod))
 		raytrans(r);
-		return(1);
-	}
-	return(rayshade(r, r->ro->omod));
 }
 
 
-raytrans(r)			/* transmit ray as is */
-register RAY  *r;
+extern void
+raytrans(			/* transmit ray as is */
+	register RAY  *r
+)
 {
 	RAY  tr;
 
 	if (rayorigin(&tr, r, TRANS, 1.0) == 0) {
 		VCOPY(tr.rdir, r->rdir);
-		if (r->rmax > FTINY)
-			tr.rmax = r->rmax - r->rot;
 		rayvalue(&tr);
 		copycolor(r->rcol, tr.rcol);
 		r->rt = r->rot + tr.rt;
@@ -140,16 +153,14 @@ register RAY  *r;
 }
 
 
-rayshade(r, mod)		/* shade ray r with material mod */
-register RAY  *r;
-int  mod;
+extern int
+rayshade(		/* shade ray r with material mod */
+	register RAY  *r,
+	int  mod
+)
 {
-	static int  depth = 0;
 	int  gotmat;
 	register OBJREC  *m;
-					/* check for infinite loop */
-	if (depth++ >= MAXLOOP)
-		objerror(r->ro, USER, "possible modifier loop");
 	r->rt = r->rot;			/* set effective ray length */
 	for (gotmat = 0; !gotmat && mod != OVOID; mod = m->omod) {
 		m = objptr(mod);
@@ -160,9 +171,10 @@ int  mod;
 		}
 		******/
 					/* hack for irradiance calculation */
-		if (do_irrad && !(r->crtype & ~(PRIMARY|TRANS))) {
+		if (do_irrad && !(r->crtype & ~(PRIMARY|TRANS)) &&
+				m->otype != MAT_CLIP &&
+				(ofun[m->otype].flags & (T_M|T_X))) {
 			if (irr_ignore(m->otype)) {
-				depth--;
 				raytrans(r);
 				return(1);
 			}
@@ -172,20 +184,50 @@ int  mod;
 					/* materials call raytexture */
 		gotmat = (*ofun[m->otype].funp)(m, r);
 	}
-	depth--;
 	return(gotmat);
 }
 
 
-raytexture(r, mod)			/* get material modifiers */
-RAY  *r;
-int  mod;
+extern void
+rayparticipate(			/* compute ray medium participation */
+	register RAY  *r
+)
 {
-	static int  depth = 0;
+	COLOR	ce, ca;
+	double	re, ge, be;
+
+	if (intens(r->cext) <= 1./FHUGE)
+		return;				/* no medium */
+	re = r->rot*colval(r->cext,RED);
+	ge = r->rot*colval(r->cext,GRN);
+	be = r->rot*colval(r->cext,BLU);
+	if (r->crtype & SHADOW) {		/* no scattering for sources */
+		re *= 1. - colval(r->albedo,RED);
+		ge *= 1. - colval(r->albedo,GRN);
+		be *= 1. - colval(r->albedo,BLU);
+	}
+	setcolor(ce,	re<=0. ? 1. : re>92. ? 0. : exp(-re),
+			ge<=0. ? 1. : ge>92. ? 0. : exp(-ge),
+			be<=0. ? 1. : be>92. ? 0. : exp(-be));
+	multcolor(r->rcol, ce);			/* path absorption */
+	if (r->crtype & SHADOW || intens(r->albedo) <= FTINY)
+		return;				/* no scattering */
+	setcolor(ca,
+		colval(r->albedo,RED)*colval(ambval,RED)*(1.-colval(ce,RED)),
+		colval(r->albedo,GRN)*colval(ambval,GRN)*(1.-colval(ce,GRN)),
+		colval(r->albedo,BLU)*colval(ambval,BLU)*(1.-colval(ce,BLU)));
+	addcolor(r->rcol, ca);			/* ambient in scattering */
+	srcscatter(r);				/* source in scattering */
+}
+
+
+extern void
+raytexture(			/* get material modifiers */
+	RAY  *r,
+	OBJECT  mod
+)
+{
 	register OBJREC  *m;
-					/* check for infinite loop */
-	if (depth++ >= MAXLOOP)
-		objerror(r->ro, USER, "modifier loop");
 					/* execute textures and patterns */
 	for ( ; mod != OVOID; mod = m->omod) {
 		m = objptr(mod);
@@ -195,46 +237,48 @@ int  mod;
 			error(USER, errmsg);
 		}
 		******/
-		if ((*ofun[m->otype].funp)(m, r))
-			objerror(r->ro, USER, "conflicting materials");
+		if ((*ofun[m->otype].funp)(m, r)) {
+			sprintf(errmsg, "conflicting material \"%s\"",
+					m->oname);
+			objerror(r->ro, USER, errmsg);
+		}
 	}
-	depth--;			/* end here */
 }
 
 
-raymixture(r, fore, back, coef)		/* mix modifiers */
-register RAY  *r;
-OBJECT  fore, back;
-double  coef;
+extern int
+raymixture(		/* mix modifiers */
+	register RAY  *r,
+	OBJECT  fore,
+	OBJECT  back,
+	double  coef
+)
 {
 	RAY  fr, br;
 	int  foremat, backmat;
 	register int  i;
-					/* clip coefficient */
+					/* bound coefficient */
 	if (coef > 1.0)
 		coef = 1.0;
 	else if (coef < 0.0)
 		coef = 0.0;
 					/* compute foreground and background */
-	foremat = backmat = -1;
+	foremat = backmat = 0;
 					/* foreground */
-	copystruct(&fr, r);
-	if (fore != OVOID && coef > FTINY)
+	fr = *r;
+	if (coef > FTINY)
 		foremat = rayshade(&fr, fore);
 					/* background */
-	copystruct(&br, r);
-	if (back != OVOID && coef < 1.0-FTINY)
+	br = *r;
+	if (coef < 1.0-FTINY)
 		backmat = rayshade(&br, back);
-					/* check */
-	if (foremat < 0)
-		if (backmat < 0)
-			foremat = backmat = 0;
-		else
-			foremat = backmat;
-	else if (backmat < 0)
-		backmat = foremat;
-	if ((foremat==0) != (backmat==0))
-		objerror(r->ro, USER, "mixing material with non-material");
+					/* check for transparency */
+	if (backmat ^ foremat) {
+		if (backmat && coef > FTINY)
+			raytrans(&fr);
+		else if (foremat && coef < 1.0-FTINY)
+			raytrans(&br);
+	}
 					/* mix perturbations */
 	for (i = 0; i < 3; i++)
 		r->pert[i] = coef*fr.pert[i] + (1.0-coef)*br.pert[i];
@@ -243,23 +287,40 @@ double  coef;
 	scalecolor(br.pcol, 1.0-coef);
 	copycolor(r->pcol, fr.pcol);
 	addcolor(r->pcol, br.pcol);
+					/* return value tells if material */
+	if (!foremat & !backmat)
+		return(0);
 					/* mix returned ray values */
-	if (foremat) {
-		scalecolor(fr.rcol, coef);
-		scalecolor(br.rcol, 1.0-coef);
-		copycolor(r->rcol, fr.rcol);
-		addcolor(r->rcol, br.rcol);
-		r->rt = bright(fr.rcol) > bright(br.rcol) ? fr.rt : br.rt;
+	scalecolor(fr.rcol, coef);
+	scalecolor(br.rcol, 1.0-coef);
+	copycolor(r->rcol, fr.rcol);
+	addcolor(r->rcol, br.rcol);
+	r->rt = bright(fr.rcol) > bright(br.rcol) ? fr.rt : br.rt;
+	return(1);
+}
+
+
+extern double
+raydist(		/* compute (cumulative) ray distance */
+	register RAY  *r,
+	register int  flags
+)
+{
+	double  sum = 0.0;
+
+	while (r != NULL && r->crtype&flags) {
+		sum += r->rot;
+		r = r->parent;
 	}
-					/* return value tells if material */
-	return(foremat);
+	return(sum);
 }
 
 
-double
-raynormal(norm, r)		/* compute perturbed normal for ray */
-FVECT  norm;
-register RAY  *r;
+extern double
+raynormal(		/* compute perturbed normal for ray */
+	FVECT  norm,
+	register RAY  *r
+)
 {
 	double  newdot;
 	register int  i;
@@ -291,8 +352,10 @@ register RAY  *r;
 }
 
 
-newrayxf(r)			/* get new tranformation matrix for ray */
-RAY  *r;
+extern void
+newrayxf(			/* get new tranformation matrix for ray */
+	RAY  *r
+)
 {
 	static struct xfn {
 		struct xfn  *next;
@@ -310,7 +373,7 @@ RAY  *r;
 		if (rp->rox == &xp->xf) {		/* xp in use */
 			xp = xp->next;			/* move to next */
 			if (xp == xflast) {		/* need new one */
-				xp = (struct xfn *)bmalloc(sizeof(struct xfn));
+				xp = (struct xfn *)malloc(sizeof(struct xfn));
 				if (xp == NULL)
 					error(SYSTEM,
 						"out of memory in newrayxf");
@@ -327,8 +390,10 @@ RAY  *r;
 }
 
 
-flipsurface(r)			/* reverse surface orientation */
-register RAY  *r;
+extern void
+flipsurface(			/* reverse surface orientation */
+	register RAY  *r
+)
 {
 	r->rod = -r->rod;
 	r->ron[0] = -r->ron[0];
@@ -340,10 +405,29 @@ register RAY  *r;
 }
 
 
-localhit(r, scene)		/* check for hit in the octree */
-register RAY  *r;
-register CUBE  *scene;
+extern void
+rayhit(			/* standard ray hit test */
+	OBJECT  *oset,
+	RAY  *r
+)
 {
+	OBJREC  *o;
+	int	i;
+
+	for (i = oset[0]; i > 0; i--) {
+		o = objptr(oset[i]);
+		if ((*ofun[o->otype].funp)(o, r))
+			r->robj = oset[i];
+	}
+}
+
+
+extern int
+localhit(		/* check for hit in the octree */
+	register RAY  *r,
+	register CUBE  *scene
+)
+{
 	OBJECT  cxset[MAXCSET+1];	/* set of checked objects */
 	FVECT  curpos;			/* current cube position */
 	int  sflags;			/* sign flags */
@@ -396,18 +480,19 @@ register CUBE  *scene;
 			return(0);
 	}
 	cxset[0] = 0;
-	return(raymove(curpos, cxset, sflags, r, scene) == RAYHIT &&
-			r->ro != &Aftplane);
+	raymove(curpos, cxset, sflags, r, scene);
+	return((r->ro != NULL) & (r->ro != &Aftplane));
 }
 
 
 static int
-raymove(pos, cxs, dirf, r, cu)		/* check for hit as we move */
-FVECT  pos;			/* current position, modified herein */
-OBJECT  *cxs;			/* checked objects, modified by checkhit */
-int  dirf;			/* direction indicators to speed tests */
-register RAY  *r;
-register CUBE  *cu;
+raymove(		/* check for hit as we move */
+	FVECT  pos,			/* current position, modified herein */
+	OBJECT  *cxs,			/* checked objects, modified by checkhit */
+	int  dirf,			/* direction indicators to speed tests */
+	register RAY  *r,
+	register CUBE  *cu
+)
 {
 	int  ax;
 	double  dt, t;
@@ -452,7 +537,10 @@ register CUBE  *cu;
 		}
 		/*NOTREACHED*/
 	}
-	if (isfull(cu->cutree) && checkhit(r, cu, cxs))
+	if (isfull(cu->cutree)) {
+		if (checkhit(r, cu, cxs))
+			return(RAYHIT);
+	} else if (r->ro == &Aftplane && incube(cu, r->rop))
 		return(RAYHIT);
 					/* advance to next cube */
 	if (dirf&0x11) {
@@ -484,33 +572,32 @@ register CUBE  *cu;
 }
 
 
-static
-checkhit(r, cu, cxs)		/* check for hit in full cube */
-register RAY  *r;
-CUBE  *cu;
-OBJECT  *cxs;
+static int
+checkhit(		/* check for hit in full cube */
+	register RAY  *r,
+	CUBE  *cu,
+	OBJECT  *cxs
+)
 {
 	OBJECT  oset[MAXSET+1];
-	register OBJREC  *o;
-	register int  i;
 
 	objset(oset, cu->cutree);
-	checkset(oset, cxs);			/* eliminate double-checking */
-	for (i = oset[0]; i > 0; i--) {
-		o = objptr(oset[i]);
-		(*ofun[o->otype].funp)(o, r);
-	}
-	if (r->ro == NULL)
+	checkset(oset, cxs);			/* avoid double-checking */
+
+	(*r->hitf)(oset, r);			/* test for hit in set */
+
+	if (r->robj == OVOID)
 		return(0);			/* no scores yet */
 
 	return(incube(cu, r->rop));		/* hit OK if in current cube */
 }
 
 
-static
-checkset(os, cs)		/* modify checked set and set to check */
-register OBJECT  *os;			/* os' = os - cs */
-register OBJECT  *cs;			/* cs' = cs + os */
+static void
+checkset(		/* modify checked set and set to check */
+	register OBJECT  *os,			/* os' = os - cs */
+	register OBJECT  *cs			/* cs' = cs + os */
+)
 {
 	OBJECT  cset[MAXCSET+MAXSET+1];
 	register int  i, j;