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.54 by greg, Wed Apr 5 14:30:38 2006 UTC vs.
Revision 2.62 by greg, Mon Dec 14 07:31:37 2009 UTC

#	Line 31 | Line 31 | static const char      RCSid[] = "$Id$";
31		#include  "resolu.h"
32		#include  "random.h"
33
34	<	CUBE  thescene;                         /* our scene */
35	<	OBJECT  nsceneobjs;                     /* number of objects in our scene */
34	>	extern int  inform;                     /* input format */
35	>	extern int  outform;                    /* output format */
36	>	extern char  *outvals;                  /* output values */
37
38	<	int  dimlist[MAXDIM];                   /* sampling dimensions */
39	<	int  ndims = 0;                         /* number of sampling dimensions */
39	<	int  samplendx = 0;                     /* index for this sample */
38	>	extern int  imm_irrad;                  /* compute immediate irradiance? */
39	>	extern int  lim_dist;                   /* limit distance? */
40
41	<	int  imm_irrad = 0;                     /* compute immediate irradiance? */
42	<	int  lim_dist = 0;                      /* limit distance? */
41	>	extern char  *tralist[];                /* list of modifers to trace (or no) */
42	>	extern int  traincl;                    /* include == 1, exclude == 0 */
43
44	<	int  inform = 'a';                      /* input format */
45	<	int  outform = 'a';                     /* output format */
46	<	char  *outvals = "v";                   /* output specification */
44	>	extern int  hresolu;                    /* horizontal resolution */
45	>	extern int  vresolu;                    /* vertical resolution */
46
47	<	int  do_irrad = 0;                      /* compute irradiance? */
47	>	static int  castonly = 0;
48
50	–	int  rand_samp = 1;                     /* pure Monte Carlo sampling? */
51	–
52	–	void  (*trace)() = NULL;                /* trace call */
53	–
54	–	char  *tralist[128];                    /* list of modifers to trace (or no) */
55	–	int  traincl = -1;                      /* include == 1, exclude == 0 */
49		#ifndef  MAXTSET
50	<	#define  MAXTSET        8192            /* maximum number in trace set */
50	>	#define  MAXTSET        8191            /* maximum number in trace set */
51		#endif
52		OBJECT  traset[MAXTSET+1]={0};          /* trace include/exclude set */
53
61	–	int  hresolu = 0;                       /* horizontal (scan) size */
62	–	int  vresolu = 0;                       /* vertical resolution */
63	–
64	–	double  dstrsrc = 0.0;                  /* square source distribution */
65	–	double  shadthresh = .03;               /* shadow threshold */
66	–	double  shadcert = .75;                 /* shadow certainty */
67	–	int  directrelay = 2;                   /* number of source relays */
68	–	int  vspretest = 512;                   /* virtual source pretest density */
69	–	int  directvis = 1;                     /* sources visible? */
70	–	double  srcsizerat = .2;                /* maximum ratio source size/dist. */
71	–
72	–	COLOR  cextinction = BLKCOLOR;          /* global extinction coefficient */
73	–	COLOR  salbedo = BLKCOLOR;              /* global scattering albedo */
74	–	double  seccg = 0.;                     /* global scattering eccentricity */
75	–	double  ssampdist = 0.;                 /* scatter sampling distance */
76	–
77	–	double  specthresh = .15;               /* specular sampling threshold */
78	–	double  specjitter = 1.;                /* specular sampling jitter */
79	–
80	–	int  backvis = 1;                       /* back face visibility */
81	–
82	–	int  maxdepth = -10;                    /* maximum recursion depth */
83	–	double  minweight = 2e-3;               /* minimum ray weight */
84	–
85	–	char  *ambfile = NULL;                  /* ambient file name */
86	–	COLOR  ambval = BLKCOLOR;               /* ambient value */
87	–	int  ambvwt = 0;                        /* initial weight for ambient value */
88	–	double  ambacc = 0.15;                  /* ambient accuracy */
89	–	int  ambres = 256;                      /* ambient resolution */
90	–	int  ambdiv = 1024;                     /* ambient divisions */
91	–	int  ambssamp = 512;                    /* ambient super-samples */
92	–	int  ambounce = 0;                      /* ambient bounces */
93	–	char  *amblist[AMBLLEN];                /* ambient include/exclude list */
94	–	int  ambincl = -1;                      /* include == 1, exclude == 0 */
95	–
96	–	static int  castonly = 0;
97	–
54		static RAY  thisray;                    /* for our convenience */
55
56		typedef void putf_t(double v);
#	Line 105 | Line 61 | static oputf_t  oputo, oputd, oputv, oputV, oputl, opu
61		oputn, oputN, oputs, oputw, oputW, oputm, oputM, oputtilde;
62
63		static void setoutput(char *vs);
64	<	static void tranotify(OBJECT obj);
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);
68	<	static void printvals(RAY  *r);
69	<	static int getvec(FVECT  vec, int  fmt, FILE  *fp);
70	<	static void tabin(RAY  *r);
71	<	static void ourtrace(RAY  *r);
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);
72	>	static void ourtrace(RAY *r);
73
74		static oputf_t *ray_out[16], *every_out[16];
75		static putf_t *putreal;
76
120	–	void  (*addobjnotify[])() = {ambnotify, tranotify, NULL};
77
122	–
78		void
79		quit(                   /* quit program */
80		int  code
81		)
82		{
83	<	#ifndef  NON_POSIX /* XXX we don't clean up elsewhere? */
84	<	headclean();            /* delete header file */
85	<	pfclean();              /* clean up persist files */
83	>	if (ray_pnprocs > 0)    /* close children if any */
84	>	ray_pclose(0);
85	>	#ifndef  NON_POSIX
86	>	else if (!ray_pnprocs) {
87	>	headclean();    /* delete header file */
88	>	pfclean();      /* clean up persist files */
89	>	}
90		#endif
91		exit(code);
92		}
93
94
95	<	extern char *
95	>	char *
96		formstr(                                /* return format identifier */
97		int  f
98		)
#	Line 150 | 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
#	Line 170 | 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 181 | Line 145 | rtrace(                                /* trace rays from file */
145		default:
146		error(CONSISTENCY, "botched output format");
147		}
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 192 | Line 160 | rtrace(                                /* trace rays from file */
160
161		d = normalize(direc);
162		if (d == 0.0) {                         /* zero ==> flush */
163	+	if (nproc > 1 && ray_fifo_flush() < 0)
164	+	error(USER, "lost children");
165		bogusray();
166		if (--nextflush <= 0 || !vcount) {
167		fflush(stdout);
168		nextflush = hresolu;
169		}
170	<	} else {
171	<	samplendx++;
202	<	/* compute and print */
203	<	if (imm_irrad)
204	<	irrad(orig, direc);
205	<	else
206	<	rad(orig, direc, lim_dist ? d : 0.0);
170	>	} else {                                /* compute and print */
171	>	rtcompute(orig, direc, lim_dist ? d : 0.0);
172		/* flush if time */
173		if (!--nextflush) {
174	+	if (nproc > 1 && ray_fifo_flush() < 0)
175	+	error(USER, "lost children");
176		fflush(stdout);
177		nextflush = hresolu;
178		}
#	Line 215 | Line 182 | rtrace(                                /* trace rays from file */
182		if (vcount && !--vcount)                /* check for end */
183		break;
184		}
185	+	if (nproc > 1) {                                /* clean up children */
186	+	if (ray_fifo_flush() < 0)
187	+	error(USER, "unable to complete processing");
188	+	ray_pclose(0);
189	+	}
190		if (fflush(stdout) < 0)
191		error(SYSTEM, "write error");
192		if (vcount)
#	Line 236 | Line 208 | trace_sources(void)                    /* trace rays to light sources,
208
209		static void
210		setoutput(                              /* set up output tables */
211	<	register char  *vs
211	>	char  *vs
212		)
213		{
214	<	register oputf_t **table = ray_out;
214	>	oputf_t **table = ray_out;
215
216		castonly = 1;
217		while (*vs)
#	Line 329 | Line 301 | bogusray(void)                 /* print out empty record */
301
302
303		static void
304	<	rad(            /* compute and print ray value(s) */
305	<	FVECT  org,
334	<	FVECT  dir,
335	<	double  dmax
304	>	raycast(                        /* compute first ray intersection only */
305	>	RAY *r
306		)
307		{
308	<	VCOPY(thisray.rorg, org);
309	<	VCOPY(thisray.rdir, dir);
310	<	thisray.rmax = dmax;
311	<	rayorigin(&thisray, PRIMARY, NULL, NULL);
312	<	if (castonly) {
313	<	if (!localhit(&thisray, &thescene)) {
314	<	if (thisray.ro == &Aftplane) {  /* clipped */
345	<	thisray.ro = NULL;
346	<	thisray.rot = FHUGE;
347	<	} else
348	<	sourcehit(&thisray);
349	<	}
350	<	} else
351	<	rayvalue(&thisray);
352	<	printvals(&thisray);
308	>	if (!localhit(r, &thescene)) {
309	>	if (r->ro == &Aftplane) {       /* clipped */
310	>	r->ro = NULL;
311	>	r->rot = FHUGE;
312	>	} else
313	>	sourcehit(r);
314	>	}
315		}
316
317
318		static void
319	<	irrad(                  /* compute immediate irradiance value */
320	<	FVECT  org,
359	<	FVECT  dir
319	>	rayirrad(                       /* compute irradiance rather than radiance */
320	>	RAY *r
321		)
322		{
323	<	register int  i;
323	>	void    (*old_revf)(RAY *) = r->revf;
324
325	<	for (i = 0; i < 3; i++) {
326	<	thisray.rorg[i] = org[i] + dir[i];
327	<	thisray.rdir[i] = -dir[i];
328	<	}
329	<	thisray.rmax = 0.0;
325	>	r->rot = 1e-5;                  /* pretend we hit surface */
326	>	VSUM(r->rop, r->rorg, r->rdir, r->rot);
327	>	r->ron[0] = -r->rdir[0];
328	>	r->ron[1] = -r->rdir[1];
329	>	r->ron[2] = -r->rdir[2];
330	>	r->rod = 1.0;
331	>	/* compute result */
332	>	r->revf = raytrace;
333	>	(*ofun[Lamb.otype].funp)(&Lamb, r);
334	>	r->revf = old_revf;
335	>	}
336	>
337	>
338	>	static void
339	>	rtcompute(                      /* compute and print ray value(s) */
340	>	FVECT  org,
341	>	FVECT  dir,
342	>	double  dmax
343	>	)
344	>	{
345	>	/* set up ray */
346		rayorigin(&thisray, PRIMARY, NULL, NULL);
347	<	/* pretend we hit surface */
348	<	thisray.rot = 1.0-1e-4;
349	<	thisray.rod = 1.0;
350	<	VCOPY(thisray.ron, dir);
351	<	for (i = 0; i < 3; i++)         /* fudge factor */
352	<	thisray.rop[i] = org[i] + 1e-4*dir[i];
353	<	/* compute and print */
354	<	(*ofun[Lamb.otype].funp)(&Lamb, &thisray);
347	>	if (imm_irrad) {
348	>	VSUM(thisray.rorg, org, dir, 1.1e-4);
349	>	thisray.rdir[0] = -dir[0];
350	>	thisray.rdir[1] = -dir[1];
351	>	thisray.rdir[2] = -dir[2];
352	>	thisray.rmax = 0.0;
353	>	thisray.revf = rayirrad;
354	>	} else {
355	>	VCOPY(thisray.rorg, org);
356	>	VCOPY(thisray.rdir, dir);
357	>	thisray.rmax = dmax;
358	>	if (castonly)
359	>	thisray.revf = raycast;
360	>	}
361	>	if (ray_pnprocs > 1) {          /* multiprocessing FIFO? */
362	>	if (ray_fifo_in(&thisray) < 0)
363	>	error(USER, "lost children");
364	>	return;
365	>	}
366	>	samplendx++;                    /* else do it ourselves */
367	>	rayvalue(&thisray);
368		printvals(&thisray);
369		}
370
371
372	<	static void
372	>	static int
373		printvals(                      /* print requested ray values */
374		RAY  *r
375		)
376		{
377	<	register oputf_t **tp;
377	>	oputf_t **tp;
378
379		if (ray_out[0] == NULL)
380	<	return;
380	>	return(0);
381		for (tp = ray_out; *tp != NULL; tp++)
382		(**tp)(r);
383		if (outform == 'a')
384		putchar('\n');
385	+	return(1);
386		}
387
388
389		static int
390		getvec(         /* get a vector from fp */
391	<	register FVECT  vec,
391	>	FVECT  vec,
392		int  fmt,
393		FILE  *fp
394		)
#	Line 405 | Line 396 | getvec(                /* get a vector from fp */
396		static float  vf[3];
397		static double  vd[3];
398		char  buf[32];
399	<	register int  i;
399	>	int  i;
400
401		switch (fmt) {
402		case 'a':                                       /* ascii */
#	Line 419 | Line 410 | getvec(                /* get a vector from fp */
410		case 'f':                                       /* binary float */
411		if (fread((char *)vf, sizeof(float), 3, fp) != 3)
412		return(-1);
413	<	vec[0] = vf[0]; vec[1] = vf[1]; vec[2] = vf[2];
413	>	VCOPY(vec, vf);
414		break;
415		case 'd':                                       /* binary double */
416		if (fread((char *)vd, sizeof(double), 3, fp) != 3)
417		return(-1);
418	<	vec[0] = vd[0]; vec[1] = vd[1]; vec[2] = vd[2];
418	>	VCOPY(vec, vd);
419		break;
420		default:
421		error(CONSISTENCY, "botched input format");
#	Line 433 | Line 424 | getvec(                /* get a vector from fp */
424		}
425
426
427	<	static void
427	>	void
428		tranotify(                      /* record new modifier */
429		OBJECT  obj
430		)
431		{
432		static int  hitlimit = 0;
433	<	register OBJREC  *o = objptr(obj);
434	<	register char  **tralp;
433	>	OBJREC   *o = objptr(obj);
434	>	char  **tralp;
435
436		if (obj == OVOID) {             /* starting over */
437		traset[0] = 0;
#	Line 467 | Line 458 | ourtrace(                              /* print ray values */
458		RAY  *r
459		)
460		{
461	<	register oputf_t **tp;
461	>	oputf_t **tp;
462
463		if (every_out[0] == NULL)
464		return;

Diff Legend

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