ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/rt/rxtrace.cpp

Comparing ray/src/rt/rxtrace.cpp (file contents):
Revision 2.2 by greg, Tue Mar 12 16:54:51 2024 UTC vs.
Revision 2.7 by greg, Tue Nov 19 16:29:44 2024 UTC

#	Line 39 | Line 39 | extern int  vresolu;                   /* vertical resolution */
39
40		extern int  castonly;                   /* only doing ray-casting? */
41
42	+	extern double  (*sens_curve)(SCOLOR scol);      /* spectral conversion for 1-channel */
43	+	extern double  out_scalefactor;         /* output calibration scale factor */
44	+	extern RGBPRIMP  out_prims;             /* output color primitives (NULL if spectral) */
45	+
46		#ifndef  MAXTSET
47		#define  MAXTSET        8191            /* maximum number in trace set */
48		#endif
#	Line 64 | Line 68 | static oputf_t  oputo, oputd, oputv, oputV, oputl, opu
68		extern void tranotify(OBJECT obj);
69		static void tabin(RAY *r);
70		static RayReportCall ourtrace;
67	–	static RayReportCall printvals;
71
72	+	RayReportCall printvals;                /* print selected ray values */
73	+
74	+	void  putscolor(COLORV *scol);          /* convert/print spectral color */
75	+
76		static oputf_t *ray_out[32], *every_out[32];
70	–	static putf_t *putreal;
77
78	+	putf_t *putreal;                        /* put out real vector */
79	+
80		void
81		quit(                   /* quit program */
82		int  code
83		)
84		{
85	+	if (ray_pnprocs < 0)
86	+	_exit(code);            /* avoid flush in child */
87	+
88		int     ec = myRTmanager.Cleanup();
89
90		if (ec) code = ec;
#	Line 90 | Line 101 | formstr(                               /* return format identifier */
101		case 'a': return("ascii");
102		case 'f': return("float");
103		case 'd': return("double");
104	<	case 'c': return(COLRFMT);
104	>	case 'c':
105	>	if (out_prims == NULL)
106	>	return(SPECFMT);
107	>	if (out_prims == xyzprims)
108	>	return(CIEFMT);
109	>	return(COLRFMT);
110		}
111		return("unknown");
112		}
#	Line 181 | Line 197 | rtrace(                                /* trace rays from stdin or file */
197		sprintf(errmsg, "cannot open input file \"%s\"", fname);
198		error(SYSTEM, errmsg);
199		}
184	–	#ifdef getc_unlocked
185	–	flockfile(inpfp);               /* avoid lock/unlock overhead */
186	–	#endif
200		if (inform != 'a')
201		SET_FILE_BINARY(inpfp);
202		/* set up output */
#	Line 203 | Line 216 | rtrace(                                /* trace rays from stdin or file */
216		if (every_out[0])
217		myRTmanager.SetTraceCall(ourtrace);
218		myRTmanager.rtFlags |= RTdoFIFO;
219	+	#ifdef getc_unlocked
220	+	flockfile(inpfp);               /* avoid lock/unlock overhead */
221	+	flockfile(stdout);
222	+	#endif
223		if (hresolu > 0) {              // print resolution string if appropriate
224		if (vresolu > 0)
225		fprtresolu(hresolu, vresolu, stdout);
#	Line 221 | Line 238 | rtrace(                                /* trace rays from stdin or file */
238		pending |= (n > 1);     // time to flush output?
239		bool    atZero = IsZeroVec(ivbuf[2*n-1]);
240		if (pending & (atZero | (n == flushIntvl))) {
241	<	if (!myRTmanager.FlushQueue())
241	>	if (myRTmanager.FlushQueue() <= 0)
242		error(USER, "ray flush error");
243		fflush(stdout);
244		pending = false;
#	Line 235 | Line 252 | rtrace(                                /* trace rays from stdin or file */
252		if (vcount)
253		error(WARNING, feof(inpfp) ? "unexpected EOF on input" :
254		"input read error");
255	<	if (fflush(stdout) < 0)
256	<	error(SYSTEM, "write error");
255	>	if (myRTmanager.FlushQueue() < 0 || fflush(stdout) < 0)
256	>	error(SYSTEM, "final flush error");
257		if (fname != NULL) {
258		fclose(inpfp);
259		inpfp = NULL;
#	Line 249 | Line 266 | setrtoutput(const char *outvals)       /* set up output tabl
266		{
267		const char  *vs = outvals;
268		oputf_t **table = ray_out;
269	+	const int       nco = (sens_curve != NULL) ? 1 :
270	+	(out_prims != NULL) ? 3 : NCSAMP;
271		int  ncomp = 0;
272
273		if (!*vs)
#	Line 287 | Line 306 | setrtoutput(const char *outvals)       /* set up output tabl
306		break;
307		case 'r':                               /* reflected contrib. */
308		*table++ = oputr;
309	<	ncomp += 3;
309	>	ncomp += nco;
310		castonly = 0;
311		break;
312		case 'R':                               /* reflected distance */
#	Line 297 | Line 316 | setrtoutput(const char *outvals)       /* set up output tabl
316		break;
317		case 'x':                               /* xmit contrib. */
318		*table++ = oputx;
319	<	ncomp += 3;
319	>	ncomp += nco;
320		castonly = 0;
321		break;
322		case 'X':                               /* xmit distance */
#	Line 307 | Line 326 | setrtoutput(const char *outvals)       /* set up output tabl
326		break;
327		case 'v':                               /* value */
328		*table++ = oputv;
329	<	ncomp += 3;
329	>	ncomp += nco;
330		castonly = 0;
331		break;
332		case 'V':                               /* contribution */
333		*table++ = oputV;
334	<	ncomp += 3;
334	>	ncomp += nco;
335		castonly = 0;
336		if (ambounce > 0 && (ambacc > FTINY || ambssamp > 0))
337		error(WARNING,
#	Line 354 | Line 373 | setrtoutput(const char *outvals)       /* set up output tabl
373		break;
374		case 'W':                               /* coefficient */
375		*table++ = oputW;
376	<	ncomp += 3;
376	>	ncomp += nco;
377		castonly = 0;
378		if (ambounce > 0 && (ambacc > FTINY) | (ambssamp > 0))
379		error(WARNING,
#	Line 394 | Line 413 | setrtoutput(const char *outvals)       /* set up output tabl
413		return(ncomp);
414		}
415
416	<	static void
416	>	int
417		printvals(                      /* print requested ray values */
418		RAY  *r, void *cd
419		)
#	Line 402 | Line 421 | printvals(                     /* print requested ray values */
421		oputf_t **tp;
422
423		if (ray_out[0] == NULL)
424	<	return;
406	<	#ifdef getc_unlocked
407	<	flockfile(stdout);
408	<	#endif
424	>	return 0;
425		for (tp = ray_out; *tp != NULL; tp++)
426		(**tp)(r);
427		if (outform == 'a')
428		putchar('\n');
429	<	#ifdef getc_unlocked
414	<	funlockfile(stdout);
415	<	#endif
429	>	return 1;
430		}
431
432		void
#	Line 443 | Line 457 | tranotify(                     /* record new modifier */
457		}
458		}
459
460	<	static void
460	>	static int
461		ourtrace(                               /* print ray values */
462		RAY  *r, void *cd
463		)
#	Line 451 | Line 465 | ourtrace(                              /* print ray values */
465		oputf_t **tp;
466
467		if (every_out[0] == NULL)
468	<	return;
468	>	return 0;
469		if (r->ro == NULL) {
470		if (traincl == 1)
471	<	return;
471	>	return 0;
472		} else if (traincl != -1 && traincl != inset(traset, r->ro->omod))
473	<	return;
460	<	#ifdef getc_unlocked
461	<	flockfile(stdout);
462	<	#endif
473	>	return 0;
474		tabin(r);
475		for (tp = every_out; *tp != NULL; tp++)
476		(**tp)(r);
477		if (outform == 'a')
478		putchar('\n');
479	<	#ifdef getc_unlocked
469	<	funlockfile(stdout);
470	<	#endif
479	>	return 1;
480		}
481
482		static void
#	Line 502 | Line 511 | oputr(                         /* print mirrored contribution */
511		RAY  *r
512		)
513		{
514	<	RREAL   cval[3];
506	<
507	<	cval[0] = colval(r->mcol,RED);
508	<	cval[1] = colval(r->mcol,GRN);
509	<	cval[2] = colval(r->mcol,BLU);
510	<	(*putreal)(cval, 3);
514	>	putscolor(r->mcol);
515		}
516
517		static void
#	Line 523 | Line 527 | oputx(                         /* print unmirrored contribution */
527		RAY  *r
528		)
529		{
530	<	RREAL   cval[3];
530	>	SCOLOR  cdiff;
531
532	<	cval[0] = colval(r->rcol,RED) - colval(r->mcol,RED);
533	<	cval[1] = colval(r->rcol,GRN) - colval(r->mcol,GRN);
534	<	cval[2] = colval(r->rcol,BLU) - colval(r->mcol,BLU);
535	<	(*putreal)(cval, 3);
532	>	copyscolor(cdiff, r->rcol);
533	>	sopscolor(cdiff, -=, r->mcol);
534	>
535	>	putscolor(cdiff);
536		}
537
538		static void
#	Line 544 | Line 548 | oputv(                         /* print value */
548		RAY  *r
549		)
550		{
551	<	RREAL   cval[3];
548	<
549	<	cval[0] = colval(r->rcol,RED);
550	<	cval[1] = colval(r->rcol,GRN);
551	<	cval[2] = colval(r->rcol,BLU);
552	<	(*putreal)(cval, 3);
551	>	putscolor(r->rcol);
552		}
553
554		static void
#	Line 557 | Line 556 | oputV(                         /* print value contribution */
556		RAY *r
557		)
558		{
559	<	RREAL   contr[3];
559	>	SCOLOR  contr;
560
561		raycontrib(contr, r, PRIMARY);
562	<	multcolor(contr, r->rcol);
563	<	(*putreal)(contr, 3);
562	>	smultscolor(contr, r->rcol);
563	>	putscolor(contr);
564		}
565
566		static void
#	Line 661 | Line 660 | oputW(                         /* print coefficient */
660		RAY  *r
661		)
662		{
663	<	RREAL   contr[3];
663	>	SCOLOR  contr;
664		/* shadow ray not on source? */
665		if (r->rsrc >= 0 && source[r->rsrc].so != r->ro)
666	<	setcolor(contr, 0.0, 0.0, 0.0);
666	>	scolorblack(contr);
667		else
668		raycontrib(contr, r, PRIMARY);
669
670	<	(*putreal)(contr, 3);
670	>	putscolor(contr);
671		}
672
673		static void
#	Line 767 | Line 766 | putrgbe(RREAL *v, int n)       /* output RGBE color */
766		error(INTERNAL, "putrgbe() not called with 3 components");
767		setcolr(cout, v[0], v[1], v[2]);
768		putbinary(cout, sizeof(cout), 1, stdout);
769	+	}
770	+
771	+	void
772	+	putscolor(COLORV *scol)         /* output (spectral) color */
773	+	{
774	+	static COLORMAT xyz2myrgbmat;
775	+	SCOLOR          my_scol;
776	+	COLOR           col;
777	+	/* single channel output? */
778	+	if (sens_curve != NULL) {
779	+	RREAL   v = (*sens_curve)(scol) * out_scalefactor;
780	+	(*putreal)(&v, 1);
781	+	return;
782	+	}
783	+	if (out_scalefactor != 1.) {    /* apply scalefactor if any */
784	+	copyscolor(my_scol, scol);
785	+	scalescolor(my_scol, out_scalefactor);
786	+	scol = my_scol;
787	+	}
788	+	if (out_prims == NULL) {        /* full spectral reporting */
789	+	if (outform == 'c') {
790	+	SCOLR   sclr;
791	+	scolor_scolr(sclr, scol);
792	+	putbinary(sclr, LSCOLR, 1, stdout);
793	+	} else if (sizeof(RREAL) != sizeof(COLORV)) {
794	+	RREAL   sreal[MAXCSAMP];
795	+	int     i = NCSAMP;
796	+	while (i--) sreal[i] = scol[i];
797	+	(*putreal)(sreal, NCSAMP);
798	+	} else
799	+	(*putreal)((RREAL *)scol, NCSAMP);
800	+	return;
801	+	}
802	+	if (out_prims == xyzprims) {
803	+	scolor_cie(col, scol);
804	+	} else if (out_prims == stdprims) {
805	+	scolor_rgb(col, scol);
806	+	} else {
807	+	COLOR   xyz;
808	+	if (xyz2myrgbmat[0][0] == 0)
809	+	compxyz2rgbWBmat(xyz2myrgbmat, out_prims);
810	+	scolor_cie(xyz, scol);
811	+	colortrans(col, xyz2myrgbmat, xyz);
812	+	clipgamut(col, xyz[CIEY], CGAMUT_LOWER, cblack, cwhite);
813	+	}
814	+	if (outform == 'c') {
815	+	COLR    clr;
816	+	setcolr(clr, colval(col,RED), colval(col,GRN), colval(col,BLU));
817	+	putbinary(clr, sizeof(COLR), 1, stdout);
818	+	} else if (sizeof(RREAL) != sizeof(COLORV)) {
819	+	RREAL   creal[3];
820	+	copycolor(creal, col);
821	+	(*putreal)(creal, 3);
822	+	} else
823	+	(*putreal)((RREAL *)col, 3);
824		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)