--- ray/src/rt/rtrace.c	2009/12/12 23:08:13	2.58
+++ ray/src/rt/rtrace.c	2020/06/15 20:27:42	2.97
@@ -1,5 +1,5 @@
 #ifndef lint
-static const char	RCSid[] = "$Id: rtrace.c,v 2.58 2009/12/12 23:08:13 greg Exp $";
+static const char	RCSid[] = "$Id: rtrace.c,v 2.97 2020/06/15 20:27:42 greg Exp $";
 #endif
 /*
  *  rtrace.c - program and variables for individual ray tracing.
@@ -28,6 +28,7 @@ static const char	RCSid[] = "$Id: rtrace.c,v 2.58 2009
 #include  "ambient.h"
 #include  "source.h"
 #include  "otypes.h"
+#include  "otspecial.h"
 #include  "resolu.h"
 #include  "random.h"
 
@@ -44,7 +45,7 @@ extern int  traincl;			/* include == 1, exclude == 0 *
 extern int  hresolu;			/* horizontal resolution */
 extern int  vresolu;			/* vertical resolution */
 
-static int  castonly = 0;
+int  castonly = 0;			/* only doing ray-casting? */
 
 #ifndef  MAXTSET
 #define	 MAXTSET	8191		/* maximum number in trace set */
@@ -53,24 +54,34 @@ OBJECT	traset[MAXTSET+1]={0};		/* trace include/exclud
 
 static RAY  thisray;			/* for our convenience */
 
-typedef void putf_t(double v);
-static putf_t puta, putd, putf;
+static FILE  *inpfp = NULL;		/* input stream pointer */
 
+static FVECT	*inp_queue = NULL;	/* ray input queue if flushing */
+static int	inp_qpos = 0;		/* next ray to return */
+static int	inp_qend = 0;		/* number of rays in this work group */
+
+typedef void putf_t(RREAL *v, int n);
+static putf_t puta, putd, putf, putrgbe;
+
 typedef void oputf_t(RAY *r);
 static oputf_t  oputo, oputd, oputv, oputV, oputl, oputL, oputc, oputp,
-		oputn, oputN, oputs, oputw, oputW, oputm, oputM, oputtilde;
+		oputr, oputR, oputx, oputX, oputn, oputN, oputs,
+		oputw, oputW, oputm, oputM, oputtilde;
 
-static void setoutput(char *vs);
 extern void tranotify(OBJECT obj);
+static int is_fifo(FILE *fp);
 static void bogusray(void);
-static void rad(FVECT org, FVECT dir, double dmax);
-static void irrad(FVECT org, FVECT dir);
+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 int iszerovec(const FVECT vec);
+static double nextray(FVECT org, FVECT dir);
 static void tabin(RAY *r);
 static void ourtrace(RAY *r);
 
-static oputf_t *ray_out[16], *every_out[16];
+static oputf_t *ray_out[32], *every_out[32];
 static putf_t *putreal;
 
 
@@ -106,85 +117,102 @@ formstr(				/* return format identifier */
 }
 
 
-extern void
+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;
+					      : (unsigned long)vresolu;
+	long  nextflush = (!vresolu | (hresolu <= 1)) * hresolu;
+	int  something2flush = 0;
 	FILE  *fp;
 	double	d;
 	FVECT  orig, direc;
 					/* set up input */
 	if (fname == NULL)
-		fp = stdin;
-	else if ((fp = fopen(fname, "r")) == NULL) {
+		inpfp = stdin;
+	else if ((inpfp = fopen(fname, "r")) == NULL) {
 		sprintf(errmsg, "cannot open input file \"%s\"", fname);
 		error(SYSTEM, errmsg);
 	}
+#ifdef getc_unlocked
+	flockfile(inpfp);		/* avoid lock/unlock overhead */
+	flockfile(stdout);
+#endif
 	if (inform != 'a')
-		SET_FILE_BINARY(fp);
+		SET_FILE_BINARY(inpfp);
 					/* set up output */
-	setoutput(outvals);
+	if (castonly || every_out[0] != NULL)
+		nproc = 1;		/* don't bother multiprocessing */
+	if ((nextflush > 0) & (nproc > nextflush)) {
+		error(WARNING, "reducing number of processes to match flush interval");
+		nproc = nextflush;
+	}
 	switch (outform) {
 	case 'a': putreal = puta; break;
 	case 'f': putreal = putf; break;
 	case 'd': putreal = putd; break;
 	case 'c': 
-		if (strcmp(outvals, "v"))
-			error(USER, "color format with value output only");
-		break;
+		if (outvals[1] || !strchr("vrx", outvals[0]))
+			error(USER, "color format only with -ov, -or, -ox");
+		putreal = putrgbe; break;
 	default:
 		error(CONSISTENCY, "botched output format");
 	}
-	if (ray_pnprocs > 1)
+	if (nproc > 1) {		/* start multiprocessing */
+		ray_popen(nproc);
 		ray_fifo_out = printvals;
+		ray_pnbatch = !nextflush;
+	}
 	if (hresolu > 0) {
 		if (vresolu > 0)
 			fprtresolu(hresolu, vresolu, stdout);
-		fflush(stdout);
+		else
+			fflush(stdout);
 	}
-					/* process file */
-	while (getvec(orig, inform, fp) == 0 &&
-			getvec(direc, inform, fp) == 0) {
-
-		d = normalize(direc);
-		if (d == 0.0) {				/* zero ==> flush */
-			if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
-				error(USER, "lost children");
-			bogusray();
-			if (--nextflush <= 0 || !vcount) {
+					/* process input rays */
+	while ((d = nextray(orig, direc)) >= 0.0) {
+		if (d == 0.0) {				/* flush request? */
+			if (something2flush) {
+				if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
+					error(USER, "child(ren) died");
+				bogusray();
 				fflush(stdout);
-				nextflush = hresolu;
-			}
+				nextflush = (!vresolu | (hresolu <= 1)) * hresolu;
+				something2flush = 0;
+			} else
+				bogusray();
 		} else {				/* compute and print */
-			if (imm_irrad)
-				irrad(orig, direc);
-			else
-				rad(orig, direc, lim_dist ? d : 0.0);
-							/* flush if time */
-			if (!--nextflush) {
+			rtcompute(orig, direc, lim_dist ? d : 0.0);
+			if (!--nextflush) {		/* flush if time */
 				if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
-					error(USER, "lost children");
+					error(USER, "child(ren) died");
 				fflush(stdout);
 				nextflush = hresolu;
-			}
+			} else
+				something2flush = 1;
 		}
 		if (ferror(stdout))
 			error(SYSTEM, "write error");
 		if (vcount && !--vcount)		/* check for end */
 			break;
 	}
-	if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
-		error(USER, "unable to complete processing");
+	if (ray_pnprocs > 1) {				/* clean up children */
+		if (ray_fifo_flush() < 0)
+			error(USER, "unable to complete processing");
+		ray_pclose(0);
+	}
+	if (vcount)
+		error(WARNING, "unexpected EOF on input");
 	if (fflush(stdout) < 0)
 		error(SYSTEM, "write error");
-	if (vcount)
-		error(USER, "unexpected EOF on input");
-	if (fname != NULL)
-		fclose(fp);
+	if (fname != NULL) {
+		fclose(inpfp);
+		inpfp = NULL;
+	}
+	nextray(NULL, NULL);
 }
 
 
@@ -198,22 +226,25 @@ trace_sources(void)			/* trace rays to light sources, 
 }
 
 
-static void
-setoutput(				/* set up output tables */
-	char  *vs
-)
+int
+setrtoutput(void)			/* set up output tables, return #comp */
 {
+	char  *vs = outvals;
 	oputf_t **table = ray_out;
+	int  ncomp = 0;
 
-	castonly = 1;
-	while (*vs)
-		switch (*vs++) {
+	if (!*vs)
+		error(USER, "empty output specification");
+
+	castonly = 1;			/* sets castonly as side-effect */
+	do
+		switch (*vs) {
 		case 'T':				/* trace sources */
-			if (!*vs) break;
+			if (!vs[1]) break;
 			trace_sources();
 			/* fall through */
 		case 't':				/* trace */
-			if (!*vs) break;
+			if (!vs[1]) break;
 			*table = NULL;
 			table = every_out;
 			trace = ourtrace;
@@ -221,126 +252,195 @@ setoutput(				/* set up output tables */
 			break;
 		case 'o':				/* origin */
 			*table++ = oputo;
+			ncomp += 3;
 			break;
 		case 'd':				/* direction */
 			*table++ = oputd;
+			ncomp += 3;
 			break;
+		case 'r':				/* reflected contrib. */
+			*table++ = oputr;
+			ncomp += 3;
+			castonly = 0;
+			break;
+		case 'R':				/* reflected distance */
+			*table++ = oputR;
+			ncomp++;
+			castonly = 0;
+			break;
+		case 'x':				/* xmit contrib. */
+			*table++ = oputx;
+			ncomp += 3;
+			castonly = 0;
+			break;
+		case 'X':				/* xmit distance */
+			*table++ = oputX;
+			ncomp++;
+			castonly = 0;
+			break;
 		case 'v':				/* value */
 			*table++ = oputv;
+			ncomp += 3;
 			castonly = 0;
 			break;
 		case 'V':				/* contribution */
 			*table++ = oputV;
+			ncomp += 3;
+			castonly = 0;
 			if (ambounce > 0 && (ambacc > FTINY || ambssamp > 0))
 				error(WARNING,
 					"-otV accuracy depends on -aa 0 -as 0");
 			break;
 		case 'l':				/* effective distance */
 			*table++ = oputl;
+			ncomp++;
 			castonly = 0;
 			break;
 		case 'c':				/* local coordinates */
 			*table++ = oputc;
+			ncomp += 2;
 			break;
 		case 'L':				/* single ray length */
 			*table++ = oputL;
+			ncomp++;
 			break;
 		case 'p':				/* point */
 			*table++ = oputp;
+			ncomp += 3;
 			break;
 		case 'n':				/* perturbed normal */
 			*table++ = oputn;
+			ncomp += 3;
 			castonly = 0;
 			break;
 		case 'N':				/* unperturbed normal */
 			*table++ = oputN;
+			ncomp += 3;
 			break;
 		case 's':				/* surface */
 			*table++ = oputs;
+			ncomp++;
 			break;
 		case 'w':				/* weight */
 			*table++ = oputw;
+			ncomp++;
 			break;
 		case 'W':				/* coefficient */
 			*table++ = oputW;
-			if (ambounce > 0 && (ambacc > FTINY || ambssamp > 0))
+			ncomp += 3;
+			castonly = 0;
+			if (ambounce > 0 && (ambacc > FTINY) | (ambssamp > 0))
 				error(WARNING,
 					"-otW accuracy depends on -aa 0 -as 0");
 			break;
 		case 'm':				/* modifier */
 			*table++ = oputm;
+			ncomp++;
 			break;
 		case 'M':				/* material */
 			*table++ = oputM;
+			ncomp++;
 			break;
 		case '~':				/* tilde */
 			*table++ = oputtilde;
 			break;
+		default:
+			sprintf(errmsg, "unrecognized output option '%c'", *vs);
+			error(USER, errmsg);
 		}
+	while (*++vs);
+
 	*table = NULL;
+	if (*every_out != NULL)
+		ncomp = 0;
+							/* compatibility */
+	if ((do_irrad | imm_irrad) && castonly)
+		error(USER, "-I+ and -i+ options require some value output");
+	for (table = ray_out; *table != NULL; table++) {
+		if ((*table == oputV) | (*table == oputW))
+			error(WARNING, "-oVW options require trace mode");
+		if ((do_irrad | imm_irrad) &&
+				(*table == oputr) | (*table == oputR) |
+				(*table == oputx) | (*table == oputX))
+			error(WARNING, "-orRxX options incompatible with -I+ and -i+");
+	}
+	return(ncomp);
 }
 
 
 static void
 bogusray(void)			/* print out empty record */
 {
-	thisray.rorg[0] = thisray.rorg[1] = thisray.rorg[2] =
-	thisray.rdir[0] = thisray.rdir[1] = thisray.rdir[2] = 0.0;
-	thisray.rmax = 0.0;
 	rayorigin(&thisray, PRIMARY, NULL, NULL);
 	printvals(&thisray);
 }
 
 
 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;
-	if (!castonly && ray_pnprocs > 1) {
-		if (ray_fifo_in(&thisray) < 0)
-			error(USER, "lost children");
-		return;
+	if (!localhit(r, &thescene)) {
+		if (r->ro == &Aftplane) {	/* clipped */
+			r->ro = NULL;
+			r->rot = FHUGE;
+		} else
+			sourcehit(r);
 	}
-	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
-		ray_trace(&thisray);
-	printvals(&thisray);
 }
 
 
 static void
-irrad(			/* compute immediate irradiance value */
+rayirrad(			/* compute irradiance rather than radiance */
+	RAY *r
+)
+{
+	void	(*old_revf)(RAY *) = r->revf;
+					/* pretend we hit surface */
+	r->rxt = r->rot = 1e-5;
+	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
+	FVECT  dir,
+	double	dmax
 )
 {
-	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;
+					/* set up ray */
 	rayorigin(&thisray, PRIMARY, NULL, NULL);
-					/* pretend we hit surface */
-	thisray.rot = 1e-5;
-	thisray.rod = 1.0;
-	VCOPY(thisray.ron, dir);
-	VSUM(thisray.rop, org, dir, 1e-4);
-					/* 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);
 }
 
@@ -363,7 +463,24 @@ printvals(			/* print requested ray values */
 
 
 static int
-getvec(		/* get a vector from fp */
+is_fifo(		/* check if file pointer connected to pipe */
+	FILE *fp
+)
+{
+#ifdef S_ISFIFO
+	struct stat  sbuf;
+
+	if (fstat(fileno(fp), &sbuf) < 0)
+		error(SYSTEM, "fstat() failed on input stream");
+	return(S_ISFIFO(sbuf.st_mode));
+#else
+	return (fp == stdin);		/* just a guess, really */
+#endif
+}
+
+
+static int
+getvec(			/* get a vector from fp */
 	FVECT  vec,
 	int  fmt,
 	FILE  *fp
@@ -384,12 +501,12 @@ getvec(		/* get a vector from fp */
 		}
 		break;
 	case 'f':					/* binary float */
-		if (fread((char *)vf, sizeof(float), 3, fp) != 3)
+		if (getbinary(vf, sizeof(float), 3, fp) != 3)
 			return(-1);
 		VCOPY(vec, vf);
 		break;
 	case 'd':					/* binary double */
-		if (fread((char *)vd, sizeof(double), 3, fp) != 3)
+		if (getbinary(vd, sizeof(double), 3, fp) != 3)
 			return(-1);
 		VCOPY(vec, vd);
 		break;
@@ -400,6 +517,65 @@ getvec(		/* get a vector from fp */
 }
 
 
+static int
+iszerovec(const FVECT vec)
+{
+	return (vec[0] == 0.0) & (vec[1] == 0.0) & (vec[2] == 0.0);
+}
+
+
+static double
+nextray(		/* return next ray in work group (-1.0 if EOF) */
+	FVECT org,
+	FVECT dir
+)
+{
+	const size_t	qlength = !vresolu * hresolu;
+
+	if ((org == NULL) | (dir == NULL)) {
+		if (inp_queue != NULL)	/* asking to free queue */
+			free(inp_queue);
+		inp_queue = NULL;
+		inp_qpos = inp_qend = 0;
+		return(-1.);
+	}
+	if (!inp_qend) {		/* initialize FIFO queue */
+		int	rsiz = 6*20;	/* conservative ascii ray size */
+		if (inform == 'f') rsiz = 6*sizeof(float);
+		else if (inform == 'd') rsiz = 6*sizeof(double);
+					/* check against pipe limit */
+		if (qlength*rsiz > 512 && is_fifo(inpfp))
+			inp_queue = (FVECT *)malloc(sizeof(FVECT)*2*qlength);
+		inp_qend = -(inp_queue == NULL);	/* flag for no queue */
+	}
+	if (inp_qend < 0) {		/* not queuing? */
+		if (getvec(org, inform, inpfp) < 0 ||
+				getvec(dir, inform, inpfp) < 0)
+			return(-1.);
+		return normalize(dir);
+	}
+	if (inp_qpos >= inp_qend) {	/* need to refill input queue? */
+		for (inp_qend = 0; inp_qend < qlength; inp_qend++) {
+			if (getvec(inp_queue[2*inp_qend], inform, inpfp) < 0
+					|| getvec(inp_queue[2*inp_qend+1],
+							inform, inpfp) < 0)
+				break;		/* hit EOF */
+			if (iszerovec(inp_queue[2*inp_qend+1])) {
+				++inp_qend;	/* flush request */
+				break;
+			}
+		}
+		inp_qpos = 0;
+	}
+	if (inp_qpos >= inp_qend)	/* unexpected EOF? */
+		return(-1.);
+	VCOPY(org, inp_queue[2*inp_qpos]);
+	VCOPY(dir, inp_queue[2*inp_qpos+1]);
+	++inp_qpos;
+	return normalize(dir);
+}
+
+
 void
 tranotify(			/* record new modifier */
 	OBJECT	obj
@@ -468,9 +644,7 @@ oputo(				/* print origin */
 	RAY  *r
 )
 {
-	(*putreal)(r->rorg[0]);
-	(*putreal)(r->rorg[1]);
-	(*putreal)(r->rorg[2]);
+	(*putreal)(r->rorg, 3);
 }
 
 
@@ -479,28 +653,68 @@ oputd(				/* print direction */
 	RAY  *r
 )
 {
-	(*putreal)(r->rdir[0]);
-	(*putreal)(r->rdir[1]);
-	(*putreal)(r->rdir[2]);
+	(*putreal)(r->rdir, 3);
 }
 
 
 static void
+oputr(				/* print mirrored contribution */
+	RAY  *r
+)
+{
+	RREAL	cval[3];
+
+	cval[0] = colval(r->mcol,RED);
+	cval[1] = colval(r->mcol,GRN);
+	cval[2] = colval(r->mcol,BLU);
+	(*putreal)(cval, 3);
+}
+
+
+
+static void
+oputR(				/* print mirrored distance */
+	RAY  *r
+)
+{
+	(*putreal)(&r->rmt, 1);
+}
+
+
+static void
+oputx(				/* print unmirrored contribution */
+	RAY  *r
+)
+{
+	RREAL	cval[3];
+
+	cval[0] = colval(r->rcol,RED) - colval(r->mcol,RED);
+	cval[1] = colval(r->rcol,GRN) - colval(r->mcol,GRN);
+	cval[2] = colval(r->rcol,BLU) - colval(r->mcol,BLU);
+	(*putreal)(cval, 3);
+}
+
+
+static void
+oputX(				/* print unmirrored distance */
+	RAY  *r
+)
+{
+	(*putreal)(&r->rxt, 1);
+}
+
+
+static void
 oputv(				/* print value */
 	RAY  *r
 )
 {
-	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);
-		return;
-	}
-	(*putreal)(colval(r->rcol,RED));
-	(*putreal)(colval(r->rcol,GRN));
-	(*putreal)(colval(r->rcol,BLU));
+	RREAL	cval[3];
+
+	cval[0] = colval(r->rcol,RED);
+	cval[1] = colval(r->rcol,GRN);
+	cval[2] = colval(r->rcol,BLU);
+	(*putreal)(cval, 3);
 }
 
 
@@ -509,13 +723,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);
 }
 
 
@@ -524,7 +736,9 @@ oputl(				/* print effective distance */
 	RAY  *r
 )
 {
-	(*putreal)(r->rt);
+	RREAL	d = raydistance(r);
+
+	(*putreal)(&d, 1);
 }
 
 
@@ -533,7 +747,7 @@ oputL(				/* print single ray length */
 	RAY  *r
 )
 {
-	(*putreal)(r->rot);
+	(*putreal)(&r->rot, 1);
 }
 
 
@@ -542,25 +756,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*.99)
+		(*putreal)(r->rop, 3);
+	else
+		(*putreal)(vdummy, 3);
 }
 
 
@@ -569,15 +780,17 @@ 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*.99) {
+		if (r->rflips & 1) {	/* undo any flippin' flips */
+			FVECT	unrm;
+			unrm[0] = -r->ron[0];
+			unrm[1] = -r->ron[1];
+			unrm[2] = -r->ron[2];
+			(*putreal)(unrm, 3);
+		} else
+			(*putreal)(r->ron, 3);
+	} else
+		(*putreal)(vdummy, 3);
 }
 
 
@@ -588,16 +801,12 @@ oputn(				/* print perturbed normal */
 {
 	FVECT  pnorm;
 
-	if (r->rot >= FHUGE) {
-		(*putreal)(0.0);
-		(*putreal)(0.0);
-		(*putreal)(0.0);
+	if (r->rot >= FHUGE*.99) {
+		(*putreal)(vdummy, 3);
 		return;
 	}
 	raynormal(pnorm, r);
-	(*putreal)(pnorm[0]);
-	(*putreal)(pnorm[1]);
-	(*putreal)(pnorm[2]);
+	(*putreal)(pnorm, 3);
 }
 
 
@@ -619,7 +828,9 @@ oputw(				/* print weight */
 	RAY  *r
 )
 {
-	(*putreal)(r->rweight);
+	RREAL	rwt = r->rweight;
+	
+	(*putreal)(&rwt, 1);
 }
 
 
@@ -628,12 +839,14 @@ oputW(				/* print coefficient */
 	RAY  *r
 )
 {
-	double	contr[3];
+	RREAL	contr[3];
+				/* shadow ray not on source? */
+	if (r->rsrc >= 0 && source[r->rsrc].so != r->ro)
+		setcolor(contr, 0.0, 0.0, 0.0);
+	else
+		raycontrib(contr, r, PRIMARY);
 
-	raycontrib(contr, r, PRIMARY);
-	(*putreal)(contr[RED]);
-	(*putreal)(contr[GRN]);
-	(*putreal)(contr[BLU]);
+	(*putreal)(contr, 3);
 }
 
 
@@ -681,27 +894,62 @@ 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)		/* output binary double(s) */
 {
-	fwrite((char *)&v, sizeof(v), 1, stdout);
+#ifdef	SMLFLT
+	double	da[3];
+	int	i;
+
+	if (n > 3)
+		error(INTERNAL, "code error in putd()");
+	for (i = n; i--; )
+		da[i] = v[i];
+	putbinary(da, sizeof(double), n, stdout);
+#else
+	putbinary(v, sizeof(RREAL), n, stdout);
+#endif
 }
 
 
 static void
-putf(v)				/* print binary float */
-double  v;
+putf(RREAL *v, int n)		/* output binary float(s) */
 {
-	float f = v;
+#ifndef	SMLFLT
+	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];
+	putbinary(fa, sizeof(float), n, stdout);
+#else
+	putbinary(v, sizeof(RREAL), n, stdout);
+#endif
+}
+
+
+static void
+putrgbe(RREAL *v, int n)	/* output RGBE color */
+{
+	COLR  cout;
+
+	if (n != 3)
+		error(INTERNAL, "putrgbe() not called with 3 components");
+	setcolr(cout, v[0], v[1], v[2]);
+	putbinary(cout, sizeof(cout), 1, stdout);
 }