--- ray/src/rt/rtrace.c	2006/02/22 17:05:36	2.52
+++ ray/src/rt/rtrace.c	2011/04/06 00:14:26	2.65
@@ -1,5 +1,5 @@
 #ifndef lint
-static const char	RCSid[] = "$Id: rtrace.c,v 2.52 2006/02/22 17:05:36 greg Exp $";
+static const char	RCSid[] = "$Id: rtrace.c,v 2.65 2011/04/06 00:14:26 greg Exp $";
 #endif
 /*
  *  rtrace.c - program and variables for individual ray tracing.
@@ -31,73 +31,29 @@ static const char	RCSid[] = "$Id: rtrace.c,v 2.52 2006
 #include  "resolu.h"
 #include  "random.h"
 
-CUBE  thescene;				/* our scene */
-OBJECT	nsceneobjs;			/* number of objects in our scene */
+extern int  inform;			/* input format */
+extern int  outform;			/* output format */
+extern char  *outvals;			/* output values */
 
-int  dimlist[MAXDIM];			/* sampling dimensions */
-int  ndims = 0;				/* number of sampling dimensions */
-int  samplendx = 0;			/* index for this sample */
+extern int  imm_irrad;			/* compute immediate irradiance? */
+extern int  lim_dist;			/* limit distance? */
 
-int  imm_irrad = 0;			/* compute immediate irradiance? */
-int  lim_dist = 0;			/* limit distance? */
+extern char  *tralist[];		/* list of modifers to trace (or no) */
+extern int  traincl;			/* include == 1, exclude == 0 */
 
-int  inform = 'a';			/* input format */
-int  outform = 'a';			/* output format */
-char  *outvals = "v";			/* output specification */
+extern int  hresolu;			/* horizontal resolution */
+extern int  vresolu;			/* vertical resolution */
 
-int  do_irrad = 0;			/* compute irradiance? */
+static int  castonly = 0;
 
-int  rand_samp = 0;			/* pure Monte Carlo sampling? */
-
-void  (*trace)() = NULL;		/* trace call */
-
-char  *tralist[128];			/* list of modifers to trace (or no) */
-int  traincl = -1;			/* include == 1, exclude == 0 */
 #ifndef  MAXTSET
-#define	 MAXTSET	8192		/* maximum number in trace set */
+#define	 MAXTSET	8191		/* maximum number in trace set */
 #endif
 OBJECT	traset[MAXTSET+1]={0};		/* trace include/exclude set */
 
-int  hresolu = 0;			/* horizontal (scan) size */
-int  vresolu = 0;			/* vertical resolution */
-
-double  dstrsrc = 0.0;			/* square source distribution */
-double  shadthresh = .03;		/* shadow threshold */
-double  shadcert = .75;			/* shadow certainty */
-int  directrelay = 2;			/* number of source relays */
-int  vspretest = 512;			/* virtual source pretest density */
-int  directvis = 1;			/* sources visible? */
-double  srcsizerat = .2;		/* maximum ratio source size/dist. */
-
-COLOR  cextinction = BLKCOLOR;		/* global extinction coefficient */
-COLOR  salbedo = BLKCOLOR;		/* global scattering albedo */
-double  seccg = 0.;			/* global scattering eccentricity */
-double  ssampdist = 0.;			/* scatter sampling distance */
-
-double  specthresh = .15;		/* specular sampling threshold */
-double  specjitter = 1.;		/* specular sampling jitter */
-
-int  backvis = 1;			/* back face visibility */
-
-int  maxdepth = -10;			/* maximum recursion depth */
-double  minweight = 2e-3;		/* minimum ray weight */
-
-char  *ambfile = NULL;			/* ambient file name */
-COLOR  ambval = BLKCOLOR;		/* ambient value */
-int  ambvwt = 0;			/* initial weight for ambient value */
-double  ambacc = 0.15;			/* ambient accuracy */
-int  ambres = 256;			/* ambient resolution */
-int  ambdiv = 1024;			/* ambient divisions */
-int  ambssamp = 512;			/* ambient super-samples */
-int  ambounce = 0;			/* ambient bounces */
-char  *amblist[AMBLLEN];		/* ambient include/exclude list */
-int  ambincl = -1;			/* include == 1, exclude == 0 */
-
-static int  castonly = 0;
-
 static RAY  thisray;			/* for our convenience */
 
-typedef void putf_t(double v);
+typedef void putf_t(RREAL *v, int n);
 static putf_t puta, putd, putf;
 
 typedef void oputf_t(RAY *r);
@@ -105,35 +61,38 @@ static oputf_t  oputo, oputd, oputv, oputV, oputl, opu
 		oputn, oputN, oputs, oputw, oputW, oputm, oputM, oputtilde;
 
 static void setoutput(char *vs);
-static void tranotify(OBJECT obj);
+extern void tranotify(OBJECT obj);
 static void bogusray(void);
-static void rad(FVECT  org, FVECT  dir, double	dmax);
-static void irrad(FVECT  org, FVECT  dir);
-static void printvals(RAY  *r);
-static int getvec(FVECT  vec, int  fmt, FILE  *fp);
-static void tabin(RAY  *r);
-static void ourtrace(RAY  *r);
+static void raycast(RAY *r);
+static void rayirrad(RAY *r);
+static void rtcompute(FVECT org, FVECT dir, double dmax);
+static int printvals(RAY *r);
+static int getvec(FVECT vec, int fmt, FILE *fp);
+static void tabin(RAY *r);
+static void ourtrace(RAY *r);
 
 static oputf_t *ray_out[16], *every_out[16];
 static putf_t *putreal;
 
-void  (*addobjnotify[])() = {ambnotify, tranotify, NULL};
 
-
 void
 quit(			/* quit program */
 	int  code
 )
 {
-#ifndef  NON_POSIX /* XXX we don't clean up elsewhere? */
-	headclean();		/* delete header file */
-	pfclean();		/* clean up persist files */
+	if (ray_pnprocs > 0)	/* close children if any */
+		ray_pclose(0);		
+#ifndef  NON_POSIX
+	else if (!ray_pnprocs) {
+		headclean();	/* delete header file */
+		pfclean();	/* clean up persist files */
+	}
 #endif
 	exit(code);
 }
 
 
-extern char *
+char *
 formstr(				/* return format identifier */
 	int  f
 )
@@ -150,12 +109,13 @@ formstr(				/* return format identifier */
 
 extern void
 rtrace(				/* trace rays from file */
-	char  *fname
+	char  *fname,
+	int  nproc
 )
 {
 	unsigned long  vcount = (hresolu > 1) ? (unsigned long)hresolu*vresolu
 					      : vresolu;
-	long  nextflush = hresolu;
+	long  nextflush = (vresolu > 0) & (hresolu > 1) ? 0 : hresolu;
 	FILE  *fp;
 	double	d;
 	FVECT  orig, direc;
@@ -170,6 +130,10 @@ rtrace(				/* trace rays from file */
 		SET_FILE_BINARY(fp);
 					/* set up output */
 	setoutput(outvals);
+	if (imm_irrad)
+		castonly = 0;
+	else if (castonly)
+		nproc = 1;		/* don't bother multiprocessing */
 	switch (outform) {
 	case 'a': putreal = puta; break;
 	case 'f': putreal = putf; break;
@@ -181,6 +145,10 @@ rtrace(				/* trace rays from file */
 	default:
 		error(CONSISTENCY, "botched output format");
 	}
+	if (nproc > 1) {		/* start multiprocessing */
+		ray_popen(nproc);
+		ray_fifo_out = printvals;
+	}
 	if (hresolu > 0) {
 		if (vresolu > 0)
 			fprtresolu(hresolu, vresolu, stdout);
@@ -192,20 +160,21 @@ rtrace(				/* trace rays from file */
 
 		d = normalize(direc);
 		if (d == 0.0) {				/* zero ==> flush */
-			bogusray();
 			if (--nextflush <= 0 || !vcount) {
+				if (nproc > 1 && ray_fifo_flush() < 0)
+					error(USER, "lost children");
+				bogusray();
 				fflush(stdout);
-				nextflush = hresolu;
-			}
-		} else {
-			samplendx = rand_samp ? random() : samplendx+1;
-							/* compute and print */
-			if (imm_irrad)
-				irrad(orig, direc);
-			else
-				rad(orig, direc, lim_dist ? d : 0.0);
+				nextflush = (vresolu > 0) & (hresolu > 1) ? 0 :
+								hresolu;
+			} else
+				bogusray();
+		} else {				/* compute and print */
+			rtcompute(orig, direc, lim_dist ? d : 0.0);
 							/* flush if time */
 			if (!--nextflush) {
+				if (nproc > 1 && ray_fifo_flush() < 0)
+					error(USER, "lost children");
 				fflush(stdout);
 				nextflush = hresolu;
 			}
@@ -215,6 +184,11 @@ rtrace(				/* trace rays from file */
 		if (vcount && !--vcount)		/* check for end */
 			break;
 	}
+	if (nproc > 1) {				/* clean up children */
+		if (ray_fifo_flush() < 0)
+			error(USER, "unable to complete processing");
+		ray_pclose(0);
+	}
 	if (fflush(stdout) < 0)
 		error(SYSTEM, "write error");
 	if (vcount)
@@ -236,10 +210,10 @@ trace_sources(void)			/* trace rays to light sources, 
 
 static void
 setoutput(				/* set up output tables */
-	register char  *vs
+	char  *vs
 )
 {
-	register oputf_t **table = ray_out;
+	oputf_t **table = ray_out;
 
 	castonly = 1;
 	while (*vs)
@@ -329,75 +303,94 @@ bogusray(void)			/* print out empty record */
 
 
 static void
-rad(		/* compute and print ray value(s) */
-	FVECT  org,
-	FVECT  dir,
-	double	dmax
+raycast(			/* compute first ray intersection only */
+	RAY *r
 )
 {
-	VCOPY(thisray.rorg, org);
-	VCOPY(thisray.rdir, dir);
-	thisray.rmax = dmax;
-	rayorigin(&thisray, PRIMARY, NULL, NULL);
-	if (castonly) {
-		if (!localhit(&thisray, &thescene)) {
-			if (thisray.ro == &Aftplane) {	/* clipped */
-				thisray.ro = NULL;
-				thisray.rot = FHUGE;
-			} else
-				sourcehit(&thisray);
-		}
-	} else
-		rayvalue(&thisray);
-	printvals(&thisray);
+	if (!localhit(r, &thescene)) {
+		if (r->ro == &Aftplane) {	/* clipped */
+			r->ro = NULL;
+			r->rot = FHUGE;
+		} else
+			sourcehit(r);
+	}
 }
 
 
 static void
-irrad(			/* compute immediate irradiance value */
-	FVECT  org,
-	FVECT  dir
+rayirrad(			/* compute irradiance rather than radiance */
+	RAY *r
 )
 {
-	register int  i;
+	void	(*old_revf)(RAY *) = r->revf;
 
-	for (i = 0; i < 3; i++) {
-		thisray.rorg[i] = org[i] + dir[i];
-		thisray.rdir[i] = -dir[i];
-	}
-	thisray.rmax = 0.0;
+	r->rot = 1e-5;			/* pretend we hit surface */
+	VSUM(r->rop, r->rorg, r->rdir, r->rot);
+	r->ron[0] = -r->rdir[0];
+	r->ron[1] = -r->rdir[1];
+	r->ron[2] = -r->rdir[2];
+	r->rod = 1.0;
+					/* compute result */
+	r->revf = raytrace;
+	(*ofun[Lamb.otype].funp)(&Lamb, r);
+	r->revf = old_revf;
+}
+
+
+static void
+rtcompute(			/* compute and print ray value(s) */
+	FVECT  org,
+	FVECT  dir,
+	double	dmax
+)
+{
+					/* set up ray */
 	rayorigin(&thisray, PRIMARY, NULL, NULL);
-					/* pretend we hit surface */
-	thisray.rot = 1.0-1e-4;
-	thisray.rod = 1.0;
-	VCOPY(thisray.ron, dir);
-	for (i = 0; i < 3; i++)		/* fudge factor */
-		thisray.rop[i] = org[i] + 1e-4*dir[i];
-					/* compute and print */
-	(*ofun[Lamb.otype].funp)(&Lamb, &thisray);
+	if (imm_irrad) {
+		VSUM(thisray.rorg, org, dir, 1.1e-4);
+		thisray.rdir[0] = -dir[0];
+		thisray.rdir[1] = -dir[1];
+		thisray.rdir[2] = -dir[2];
+		thisray.rmax = 0.0;
+		thisray.revf = rayirrad;
+	} else {
+		VCOPY(thisray.rorg, org);
+		VCOPY(thisray.rdir, dir);
+		thisray.rmax = dmax;
+		if (castonly)
+			thisray.revf = raycast;
+	}
+	if (ray_pnprocs > 1) {		/* multiprocessing FIFO? */
+		if (ray_fifo_in(&thisray) < 0)
+			error(USER, "lost children");
+		return;
+	}
+	samplendx++;			/* else do it ourselves */
+	rayvalue(&thisray);
 	printvals(&thisray);
 }
 
 
-static void
+static int
 printvals(			/* print requested ray values */
 	RAY  *r
 )
 {
-	register oputf_t **tp;
+	oputf_t **tp;
 
 	if (ray_out[0] == NULL)
-		return;
+		return(0);
 	for (tp = ray_out; *tp != NULL; tp++)
 		(**tp)(r);
 	if (outform == 'a')
 		putchar('\n');
+	return(1);
 }
 
 
 static int
 getvec(		/* get a vector from fp */
-	register FVECT  vec,
+	FVECT  vec,
 	int  fmt,
 	FILE  *fp
 )
@@ -405,7 +398,7 @@ getvec(		/* get a vector from fp */
 	static float  vf[3];
 	static double  vd[3];
 	char  buf[32];
-	register int  i;
+	int  i;
 
 	switch (fmt) {
 	case 'a':					/* ascii */
@@ -419,12 +412,12 @@ getvec(		/* get a vector from fp */
 	case 'f':					/* binary float */
 		if (fread((char *)vf, sizeof(float), 3, fp) != 3)
 			return(-1);
-		vec[0] = vf[0]; vec[1] = vf[1]; vec[2] = vf[2];
+		VCOPY(vec, vf);
 		break;
 	case 'd':					/* binary double */
 		if (fread((char *)vd, sizeof(double), 3, fp) != 3)
 			return(-1);
-		vec[0] = vd[0]; vec[1] = vd[1]; vec[2] = vd[2];
+		VCOPY(vec, vd);
 		break;
 	default:
 		error(CONSISTENCY, "botched input format");
@@ -433,14 +426,14 @@ getvec(		/* get a vector from fp */
 }
 
 
-static void
+void
 tranotify(			/* record new modifier */
 	OBJECT	obj
 )
 {
 	static int  hitlimit = 0;
-	register OBJREC	 *o = objptr(obj);
-	register char  **tralp;
+	OBJREC	 *o = objptr(obj);
+	char  **tralp;
 
 	if (obj == OVOID) {		/* starting over */
 		traset[0] = 0;
@@ -467,7 +460,7 @@ ourtrace(				/* print ray values */
 	RAY  *r
 )
 {
-	register oputf_t **tp;
+	oputf_t **tp;
 
 	if (every_out[0] == NULL)
 		return;
@@ -501,9 +494,7 @@ oputo(				/* print origin */
 	RAY  *r
 )
 {
-	(*putreal)(r->rorg[0]);
-	(*putreal)(r->rorg[1]);
-	(*putreal)(r->rorg[2]);
+	(*putreal)(r->rorg, 3);
 }
 
 
@@ -512,9 +503,7 @@ oputd(				/* print direction */
 	RAY  *r
 )
 {
-	(*putreal)(r->rdir[0]);
-	(*putreal)(r->rdir[1]);
-	(*putreal)(r->rdir[2]);
+	(*putreal)(r->rdir, 3);
 }
 
 
@@ -523,17 +512,20 @@ oputv(				/* print value */
 	RAY  *r
 )
 {
+	RREAL	cval[3];
+
 	if (outform == 'c') {
 		COLR  cout;
 		setcolr(cout,	colval(r->rcol,RED),
 				colval(r->rcol,GRN),
 				colval(r->rcol,BLU));
-		fwrite((char *)cout, sizeof(cout), 1, stdout);
+		fwrite(cout, sizeof(cout), 1, stdout);
 		return;
 	}
-	(*putreal)(colval(r->rcol,RED));
-	(*putreal)(colval(r->rcol,GRN));
-	(*putreal)(colval(r->rcol,BLU));
+	cval[0] = colval(r->rcol,RED);
+	cval[1] = colval(r->rcol,GRN);
+	cval[2] = colval(r->rcol,BLU);
+	(*putreal)(cval, 3);
 }
 
 
@@ -542,13 +534,11 @@ oputV(				/* print value contribution */
 	RAY *r
 )
 {
-	double	contr[3];
+	RREAL	contr[3];
 
 	raycontrib(contr, r, PRIMARY);
 	multcolor(contr, r->rcol);
-	(*putreal)(contr[RED]);
-	(*putreal)(contr[GRN]);
-	(*putreal)(contr[BLU]);
+	(*putreal)(contr, 3);
 }
 
 
@@ -557,7 +547,7 @@ oputl(				/* print effective distance */
 	RAY  *r
 )
 {
-	(*putreal)(r->rt);
+	(*putreal)(&r->rt, 1);
 }
 
 
@@ -566,7 +556,7 @@ oputL(				/* print single ray length */
 	RAY  *r
 )
 {
-	(*putreal)(r->rot);
+	(*putreal)(&r->rot, 1);
 }
 
 
@@ -575,25 +565,22 @@ oputc(				/* print local coordinates */
 	RAY  *r
 )
 {
-	(*putreal)(r->uv[0]);
-	(*putreal)(r->uv[1]);
+	(*putreal)(r->uv, 2);
 }
 
 
+static RREAL	vdummy[3] = {0.0, 0.0, 0.0};
+
+
 static void
 oputp(				/* print point */
 	RAY  *r
 )
 {
-	if (r->rot < FHUGE) {
-		(*putreal)(r->rop[0]);
-		(*putreal)(r->rop[1]);
-		(*putreal)(r->rop[2]);
-	} else {
-		(*putreal)(0.0);
-		(*putreal)(0.0);
-		(*putreal)(0.0);
-	}
+	if (r->rot < FHUGE)
+		(*putreal)(r->rop, 3);
+	else
+		(*putreal)(vdummy, 3);
 }
 
 
@@ -602,15 +589,10 @@ oputN(				/* print unperturbed normal */
 	RAY  *r
 )
 {
-	if (r->rot < FHUGE) {
-		(*putreal)(r->ron[0]);
-		(*putreal)(r->ron[1]);
-		(*putreal)(r->ron[2]);
-	} else {
-		(*putreal)(0.0);
-		(*putreal)(0.0);
-		(*putreal)(0.0);
-	}
+	if (r->rot < FHUGE)
+		(*putreal)(r->ron, 3);
+	else
+		(*putreal)(vdummy, 3);
 }
 
 
@@ -622,15 +604,11 @@ oputn(				/* print perturbed normal */
 	FVECT  pnorm;
 
 	if (r->rot >= FHUGE) {
-		(*putreal)(0.0);
-		(*putreal)(0.0);
-		(*putreal)(0.0);
+		(*putreal)(vdummy, 3);
 		return;
 	}
 	raynormal(pnorm, r);
-	(*putreal)(pnorm[0]);
-	(*putreal)(pnorm[1]);
-	(*putreal)(pnorm[2]);
+	(*putreal)(pnorm, 3);
 }
 
 
@@ -652,7 +630,9 @@ oputw(				/* print weight */
 	RAY  *r
 )
 {
-	(*putreal)(r->rweight);
+	RREAL	rwt = r->rweight;
+	
+	(*putreal)(&rwt, 1);
 }
 
 
@@ -661,12 +641,10 @@ oputW(				/* print coefficient */
 	RAY  *r
 )
 {
-	double	contr[3];
+	RREAL	contr[3];
 
 	raycontrib(contr, r, PRIMARY);
-	(*putreal)(contr[RED]);
-	(*putreal)(contr[GRN]);
-	(*putreal)(contr[BLU]);
+	(*putreal)(contr, 3);
 }
 
 
@@ -714,27 +692,37 @@ oputtilde(			/* output tilde (spacer) */
 
 
 static void
-puta(				/* print ascii value */
-	double  v
+puta(				/* print ascii value(s) */
+	RREAL *v, int n
 )
 {
-	printf("%e\t", v);
+	if (n == 3) {
+		printf("%e\t%e\t%e\t", v[0], v[1], v[2]);
+		return;
+	}
+	while (n--)
+		printf("%e\t", *v++);
 }
 
 
 static void
-putd(v)				/* print binary double */
-double  v;
+putd(RREAL *v, int n)		/* print binary double(s) */
 {
-	fwrite((char *)&v, sizeof(v), 1, stdout);
+	if (sizeof(RREAL) != sizeof(double))
+		error(INTERNAL, "code error in putd()");
+	fwrite(v, sizeof(RREAL), n, stdout);
 }
 
 
 static void
-putf(v)				/* print binary float */
-double  v;
+putf(RREAL *v, int n)		/* print binary float(s) */
 {
-	float f = v;
+	float	fa[3];
+	int	i;
 
-	fwrite((char *)&f, sizeof(f), 1, stdout);
+	if (n > 3)
+		error(INTERNAL, "code error in putf()");
+	for (i = n; i--; )
+		fa[i] = v[i];
+	fwrite(fa, sizeof(float), n, stdout);
 }