ViewVC Help

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

root/Development/ray/src/rt/rtrace.c

Comparing ray/src/rt/rtrace.c (file contents):
Revision 2.58 by greg, Sat Dec 12 23:08:13 2009 UTC vs.
Revision 2.67 by greg, Wed Jun 27 15:32:58 2012 UTC

#	Line 53 | Line 53 | OBJECT traset[MAXTSET+1]={0};          /* trace include/exclud
53
54		static RAY  thisray;                    /* for our convenience */
55
56	<	typedef void putf_t(double v);
56	>	typedef void putf_t(RREAL *v, int n);
57		static putf_t puta, putd, putf;
58
59		typedef void oputf_t(RAY *r);
#	Line 63 | Line 63 | static oputf_t  oputo, oputd, oputv, oputV, oputl, opu
63		static void setoutput(char *vs);
64		extern void tranotify(OBJECT obj);
65		static void bogusray(void);
66	<	static void rad(FVECT org, FVECT dir, double dmax);
67	<	static void irrad(FVECT org, FVECT dir);
66	>	static void raycast(RAY *r);
67	>	static void rayirrad(RAY *r);
68	>	static void rtcompute(FVECT org, FVECT dir, double dmax);
69		static int printvals(RAY *r);
70		static int getvec(FVECT vec, int fmt, FILE *fp);
71		static void tabin(RAY *r);
#	Line 108 | Line 109 | formstr(                               /* return format identifier */
109
110		extern void
111		rtrace(                         /* trace rays from file */
112	<	char  *fname
112	>	char  *fname,
113	>	int  nproc
114		)
115		{
116		unsigned long  vcount = (hresolu > 1) ? (unsigned long)hresolu*vresolu
117	<	: vresolu;
118	<	long  nextflush = hresolu;
117	>	: (unsigned long)vresolu;
118	>	long  nextflush = (vresolu > 0) & (hresolu > 1) ? 0 : hresolu;
119		FILE  *fp;
120		double  d;
121		FVECT  orig, direc;
#	Line 128 | Line 130 | rtrace(                                /* trace rays from file */
130		SET_FILE_BINARY(fp);
131		/* set up output */
132		setoutput(outvals);
133	+	if (imm_irrad)
134	+	castonly = 0;
135	+	else if (castonly)
136	+	nproc = 1;              /* don't bother multiprocessing */
137		switch (outform) {
138		case 'a': putreal = puta; break;
139		case 'f': putreal = putf; break;
#	Line 139 | Line 145 | rtrace(                                /* trace rays from file */
145		default:
146		error(CONSISTENCY, "botched output format");
147		}
148	<	if (ray_pnprocs > 1)
148	>	if (nproc > 1) {                /* start multiprocessing */
149	>	ray_popen(nproc);
150		ray_fifo_out = printvals;
151	+	}
152		if (hresolu > 0) {
153		if (vresolu > 0)
154		fprtresolu(hresolu, vresolu, stdout);
#	Line 152 | Line 160 | rtrace(                                /* trace rays from file */
160
161		d = normalize(direc);
162		if (d == 0.0) {                         /* zero ==> flush */
155	–	if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
156	–	error(USER, "lost children");
157	–	bogusray();
163		if (--nextflush <= 0 || !vcount) {
164	+	if (nproc > 1 && ray_fifo_flush() < 0)
165	+	error(USER, "lost children");
166	+	bogusray();
167		fflush(stdout);
168	<	nextflush = hresolu;
169	<	}
168	>	nextflush = (vresolu > 0) & (hresolu > 1) ? 0 :
169	>	hresolu;
170	>	} else
171	>	bogusray();
172		} else {                                /* compute and print */
173	<	if (imm_irrad)
164	<	irrad(orig, direc);
165	<	else
166	<	rad(orig, direc, lim_dist ? d : 0.0);
173	>	rtcompute(orig, direc, lim_dist ? d : 0.0);
174		/* flush if time */
175		if (!--nextflush) {
176	<	if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
176	>	if (nproc > 1 && ray_fifo_flush() < 0)
177		error(USER, "lost children");
178		fflush(stdout);
179		nextflush = hresolu;
#	Line 177 | Line 184 | rtrace(                                /* trace rays from file */
184		if (vcount && !--vcount)                /* check for end */
185		break;
186		}
187	<	if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
188	<	error(USER, "unable to complete processing");
187	>	if (nproc > 1) {                                /* clean up children */
188	>	if (ray_fifo_flush() < 0)
189	>	error(USER, "unable to complete processing");
190	>	ray_pclose(0);
191	>	}
192		if (fflush(stdout) < 0)
193		error(SYSTEM, "write error");
194		if (vcount)
#	Line 293 | Line 303 | bogusray(void)                 /* print out empty record */
303
304
305		static void
306	<	rad(            /* compute and print ray value(s) */
307	<	FVECT  org,
298	<	FVECT  dir,
299	<	double  dmax
306	>	raycast(                        /* compute first ray intersection only */
307	>	RAY *r
308		)
309		{
310	<	VCOPY(thisray.rorg, org);
311	<	VCOPY(thisray.rdir, dir);
312	<	thisray.rmax = dmax;
313	<	if (!castonly && ray_pnprocs > 1) {
314	<	if (ray_fifo_in(&thisray) < 0)
315	<	error(USER, "lost children");
308	<	return;
310	>	if (!localhit(r, &thescene)) {
311	>	if (r->ro == &Aftplane) {       /* clipped */
312	>	r->ro = NULL;
313	>	r->rot = FHUGE;
314	>	} else
315	>	sourcehit(r);
316		}
310	–	rayorigin(&thisray, PRIMARY, NULL, NULL);
311	–	if (castonly) {
312	–	if (!localhit(&thisray, &thescene)) {
313	–	if (thisray.ro == &Aftplane) {  /* clipped */
314	–	thisray.ro = NULL;
315	–	thisray.rot = FHUGE;
316	–	} else
317	–	sourcehit(&thisray);
318	–	}
319	–	} else
320	–	ray_trace(&thisray);
321	–	printvals(&thisray);
317		}
318
319
320		static void
321	<	irrad(                  /* compute immediate irradiance value */
321	>	rayirrad(                       /* compute irradiance rather than radiance */
322	>	RAY *r
323	>	)
324	>	{
325	>	void    (*old_revf)(RAY *) = r->revf;
326	>
327	>	r->rot = 1e-5;                  /* pretend we hit surface */
328	>	VSUM(r->rop, r->rorg, r->rdir, r->rot);
329	>	r->ron[0] = -r->rdir[0];
330	>	r->ron[1] = -r->rdir[1];
331	>	r->ron[2] = -r->rdir[2];
332	>	r->rod = 1.0;
333	>	/* compute result */
334	>	r->revf = raytrace;
335	>	(*ofun[Lamb.otype].funp)(&Lamb, r);
336	>	r->revf = old_revf;
337	>	}
338	>
339	>
340	>	static void
341	>	rtcompute(                      /* compute and print ray value(s) */
342		FVECT  org,
343	<	FVECT  dir
343	>	FVECT  dir,
344	>	double  dmax
345		)
346		{
347	<	VSUM(thisray.rorg, org, dir, 1.1e-4);
332	<	thisray.rdir[0] = -dir[0];
333	<	thisray.rdir[1] = -dir[1];
334	<	thisray.rdir[2] = -dir[2];
335	<	thisray.rmax = 0.0;
347	>	/* set up ray */
348		rayorigin(&thisray, PRIMARY, NULL, NULL);
349	<	/* pretend we hit surface */
350	<	thisray.rot = 1e-5;
351	<	thisray.rod = 1.0;
352	<	VCOPY(thisray.ron, dir);
353	<	VSUM(thisray.rop, org, dir, 1e-4);
354	<	/* compute and print */
355	<	(*ofun[Lamb.otype].funp)(&Lamb, &thisray);
349	>	if (imm_irrad) {
350	>	VSUM(thisray.rorg, org, dir, 1.1e-4);
351	>	thisray.rdir[0] = -dir[0];
352	>	thisray.rdir[1] = -dir[1];
353	>	thisray.rdir[2] = -dir[2];
354	>	thisray.rmax = 0.0;
355	>	thisray.revf = rayirrad;
356	>	} else {
357	>	VCOPY(thisray.rorg, org);
358	>	VCOPY(thisray.rdir, dir);
359	>	thisray.rmax = dmax;
360	>	if (castonly)
361	>	thisray.revf = raycast;
362	>	}
363	>	if (ray_pnprocs > 1) {          /* multiprocessing FIFO? */
364	>	if (ray_fifo_in(&thisray) < 0)
365	>	error(USER, "lost children");
366	>	return;
367	>	}
368	>	samplendx++;                    /* else do it ourselves */
369	>	rayvalue(&thisray);
370		printvals(&thisray);
371		}
372
#	Line 468 | Line 494 | oputo(                         /* print origin */
494		RAY  *r
495		)
496		{
497	<	(*putreal)(r->rorg[0]);
472	<	(*putreal)(r->rorg[1]);
473	<	(*putreal)(r->rorg[2]);
497	>	(*putreal)(r->rorg, 3);
498		}
499
500
#	Line 479 | Line 503 | oputd(                         /* print direction */
503		RAY  *r
504		)
505		{
506	<	(*putreal)(r->rdir[0]);
483	<	(*putreal)(r->rdir[1]);
484	<	(*putreal)(r->rdir[2]);
506	>	(*putreal)(r->rdir, 3);
507		}
508
509
#	Line 490 | Line 512 | oputv(                         /* print value */
512		RAY  *r
513		)
514		{
515	+	RREAL   cval[3];
516	+
517		if (outform == 'c') {
518		COLR  cout;
519		setcolr(cout,   colval(r->rcol,RED),
520		colval(r->rcol,GRN),
521		colval(r->rcol,BLU));
522	<	fwrite((char *)cout, sizeof(cout), 1, stdout);
522	>	fwrite(cout, sizeof(cout), 1, stdout);
523		return;
524		}
525	<	(*putreal)(colval(r->rcol,RED));
526	<	(*putreal)(colval(r->rcol,GRN));
527	<	(*putreal)(colval(r->rcol,BLU));
525	>	cval[0] = colval(r->rcol,RED);
526	>	cval[1] = colval(r->rcol,GRN);
527	>	cval[2] = colval(r->rcol,BLU);
528	>	(*putreal)(cval, 3);
529		}
530
531
#	Line 509 | Line 534 | oputV(                         /* print value contribution */
534		RAY *r
535		)
536		{
537	<	double  contr[3];
537	>	RREAL   contr[3];
538
539		raycontrib(contr, r, PRIMARY);
540		multcolor(contr, r->rcol);
541	<	(*putreal)(contr[RED]);
517	<	(*putreal)(contr[GRN]);
518	<	(*putreal)(contr[BLU]);
541	>	(*putreal)(contr, 3);
542		}
543
544
#	Line 524 | Line 547 | oputl(                         /* print effective distance */
547		RAY  *r
548		)
549		{
550	<	(*putreal)(r->rt);
550	>	(*putreal)(&r->rt, 1);
551		}
552
553
#	Line 533 | Line 556 | oputL(                         /* print single ray length */
556		RAY  *r
557		)
558		{
559	<	(*putreal)(r->rot);
559	>	(*putreal)(&r->rot, 1);
560		}
561
562
#	Line 542 | Line 565 | oputc(                         /* print local coordinates */
565		RAY  *r
566		)
567		{
568	<	(*putreal)(r->uv[0]);
546	<	(*putreal)(r->uv[1]);
568	>	(*putreal)(r->uv, 2);
569		}
570
571
572	+	static RREAL    vdummy[3] = {0.0, 0.0, 0.0};
573	+
574	+
575		static void
576		oputp(                          /* print point */
577		RAY  *r
578		)
579		{
580	<	if (r->rot < FHUGE) {
581	<	(*putreal)(r->rop[0]);
582	<	(*putreal)(r->rop[1]);
583	<	(*putreal)(r->rop[2]);
559	<	} else {
560	<	(*putreal)(0.0);
561	<	(*putreal)(0.0);
562	<	(*putreal)(0.0);
563	<	}
580	>	if (r->rot < FHUGE)
581	>	(*putreal)(r->rop, 3);
582	>	else
583	>	(*putreal)(vdummy, 3);
584		}
585
586
#	Line 569 | Line 589 | oputN(                         /* print unperturbed normal */
589		RAY  *r
590		)
591		{
592	<	if (r->rot < FHUGE) {
593	<	(*putreal)(r->ron[0]);
594	<	(*putreal)(r->ron[1]);
595	<	(*putreal)(r->ron[2]);
576	<	} else {
577	<	(*putreal)(0.0);
578	<	(*putreal)(0.0);
579	<	(*putreal)(0.0);
580	<	}
592	>	if (r->rot < FHUGE)
593	>	(*putreal)(r->ron, 3);
594	>	else
595	>	(*putreal)(vdummy, 3);
596		}
597
598
#	Line 589 | Line 604 | oputn(                         /* print perturbed normal */
604		FVECT  pnorm;
605
606		if (r->rot >= FHUGE) {
607	<	(*putreal)(0.0);
593	<	(*putreal)(0.0);
594	<	(*putreal)(0.0);
607	>	(*putreal)(vdummy, 3);
608		return;
609		}
610		raynormal(pnorm, r);
611	<	(*putreal)(pnorm[0]);
599	<	(*putreal)(pnorm[1]);
600	<	(*putreal)(pnorm[2]);
611	>	(*putreal)(pnorm, 3);
612		}
613
614
#	Line 619 | Line 630 | oputw(                         /* print weight */
630		RAY  *r
631		)
632		{
633	<	(*putreal)(r->rweight);
633	>	RREAL   rwt = r->rweight;
634	>
635	>	(*putreal)(&rwt, 1);
636		}
637
638
#	Line 628 | Line 641 | oputW(                         /* print coefficient */
641		RAY  *r
642		)
643		{
644	<	double  contr[3];
644	>	RREAL   contr[3];
645	>	/* shadow ray not on source? */
646	>	if (r->rsrc >= 0 && source[r->rsrc].so != r->ro)
647	>	setcolor(contr, 0.0, 0.0, 0.0);
648	>	else
649	>	raycontrib(contr, r, PRIMARY);
650
651	<	raycontrib(contr, r, PRIMARY);
634	<	(*putreal)(contr[RED]);
635	<	(*putreal)(contr[GRN]);
636	<	(*putreal)(contr[BLU]);
651	>	(*putreal)(contr, 3);
652		}
653
654
#	Line 681 | Line 696 | oputtilde(                     /* output tilde (spacer) */
696
697
698		static void
699	<	puta(                           /* print ascii value */
700	<	double  v
699	>	puta(                           /* print ascii value(s) */
700	>	RREAL *v, int n
701		)
702		{
703	<	printf("%e\t", v);
703	>	if (n == 3) {
704	>	printf("%e\t%e\t%e\t", v[0], v[1], v[2]);
705	>	return;
706	>	}
707	>	while (n--)
708	>	printf("%e\t", *v++);
709		}
710
711
712		static void
713	<	putd(v)                         /* print binary double */
694	<	double  v;
713	>	putd(RREAL *v, int n)           /* print binary double(s) */
714		{
715	<	fwrite((char *)&v, sizeof(v), 1, stdout);
715	>	if (sizeof(RREAL) != sizeof(double))
716	>	error(INTERNAL, "code error in putd()");
717	>	fwrite(v, sizeof(RREAL), n, stdout);
718		}
719
720
721		static void
722	<	putf(v)                         /* print binary float */
702	<	double  v;
722	>	putf(RREAL *v, int n)           /* print binary float(s) */
723		{
724	<	float f = v;
724	>	float   fa[3];
725	>	int     i;
726
727	<	fwrite((char *)&f, sizeof(f), 1, stdout);
727	>	if (n > 3)
728	>	error(INTERNAL, "code error in putf()");
729	>	for (i = n; i--; )
730	>	fa[i] = v[i];
731	>	fwrite(fa, sizeof(float), n, stdout);
732		}

Diff Legend

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