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.57 by greg, Sat Dec 12 19:01:00 2009 UTC vs.
Revision 2.64 by greg, Sun Sep 26 15:49:39 2010 UTC

#	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 82 | Line 83 | quit(                  /* quit program */
83		if (ray_pnprocs > 0)    /* close children if any */
84		ray_pclose(0);
85		#ifndef  NON_POSIX
86	<	headclean();            /* delete header file */
87	<	pfclean();              /* clean up persist files */
86	>	else if (!ray_pnprocs) {
87	>	headclean();    /* delete header file */
88	>	pfclean();      /* clean up persist files */
89	>	}
90		#endif
91		exit(code);
92		}
#	Line 106 | 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;
118	>	long  nextflush = (vresolu > 0) & (hresolu > 1) ? 0 : hresolu;
119		FILE  *fp;
120		double  d;
121		FVECT  orig, direc;
#	Line 126 | 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 137 | Line 145 | rtrace(                                /* trace rays from file */
145		default:
146		error(CONSISTENCY, "botched output format");
147		}
148	<	ray_fifo_out = printvals;
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 149 | Line 160 | rtrace(                                /* trace rays from file */
160
161		d = normalize(direc);
162		if (d == 0.0) {                         /* zero ==> flush */
152	–	if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
153	–	error(USER, "lost children");
154	–	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)
161	<	irrad(orig, direc);
162	<	else
163	<	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 174 | 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 290 | Line 303 | bogusray(void)                 /* print out empty record */
303
304
305		static void
306	<	rad(            /* compute and print ray value(s) */
307	<	FVECT  org,
295	<	FVECT  dir,
296	<	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 (ray_pnprocs > 1) {
314	<	if (ray_fifo_in(&thisray) < 0)
315	<	error(USER, "lost children");
305	<	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		}
307	–	rayorigin(&thisray, PRIMARY, NULL, NULL);
308	–	if (castonly) {
309	–	if (!localhit(&thisray, &thescene)) {
310	–	if (thisray.ro == &Aftplane) {  /* clipped */
311	–	thisray.ro = NULL;
312	–	thisray.rot = FHUGE;
313	–	} else
314	–	sourcehit(&thisray);
315	–	}
316	–	} else
317	–	ray_trace(&thisray);
318	–	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);
329	<	thisray.rdir[0] = -dir[0];
330	<	thisray.rdir[1] = -dir[1];
331	<	thisray.rdir[2] = -dir[2];
332	<	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 383 | Line 412 | getvec(                /* get a vector from fp */
412		case 'f':                                       /* binary float */
413		if (fread((char *)vf, sizeof(float), 3, fp) != 3)
414		return(-1);
415	<	vec[0] = vf[0]; vec[1] = vf[1]; vec[2] = vf[2];
415	>	VCOPY(vec, vf);
416		break;
417		case 'd':                                       /* binary double */
418		if (fread((char *)vd, sizeof(double), 3, fp) != 3)
419		return(-1);
420	<	vec[0] = vd[0]; vec[1] = vd[1]; vec[2] = vd[2];
420	>	VCOPY(vec, vd);
421		break;
422		default:
423		error(CONSISTENCY, "botched input format");

Diff Legend

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