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.27 by greg, Sat Feb 22 02:07:29 2003 UTC vs.
Revision 2.41 by greg, Wed May 25 04:44:26 2005 UTC

#	Line 5 | Line 5 | static const char      RCSid[] = "$Id$";
5		*  rtrace.c - program and variables for individual ray tracing.
6		*/
7
8	<	/* ====================================================================
9	<	* The Radiance Software License, Version 1.0
10	<	*
11	<	* Copyright (c) 1990 - 2002 The Regents of the University of California,
12	<	* through Lawrence Berkeley National Laboratory.   All rights reserved.
13	<	*
14	<	* Redistribution and use in source and binary forms, with or without
15	<	* modification, are permitted provided that the following conditions
16	<	* are met:
17	<	*
18	<	* 1. Redistributions of source code must retain the above copyright
19	<	*         notice, this list of conditions and the following disclaimer.
20	<	*
21	<	* 2. Redistributions in binary form must reproduce the above copyright
22	<	*       notice, this list of conditions and the following disclaimer in
23	<	*       the documentation and/or other materials provided with the
24	<	*       distribution.
25	<	*
26	<	* 3. The end-user documentation included with the redistribution,
27	<	*           if any, must include the following acknowledgment:
28	<	*             "This product includes Radiance software
29	<	*                 (http://radsite.lbl.gov/)
30	<	*                 developed by the Lawrence Berkeley National Laboratory
31	<	*               (http://www.lbl.gov/)."
32	<	*       Alternately, this acknowledgment may appear in the software itself,
33	<	*       if and wherever such third-party acknowledgments normally appear.
34	<	*
35	<	* 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
36	<	*       and "The Regents of the University of California" must
37	<	*       not be used to endorse or promote products derived from this
38	<	*       software without prior written permission. For written
39	<	*       permission, please contact [email protected].
40	<	*
41	<	* 5. Products derived from this software may not be called "Radiance",
42	<	*       nor may "Radiance" appear in their name, without prior written
43	<	*       permission of Lawrence Berkeley National Laboratory.
44	<	*
45	<	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
46	<	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
47	<	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
48	<	* DISCLAIMED.   IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
49	<	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
50	<	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
51	<	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
52	<	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
53	<	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
54	<	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
55	<	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56	<	* SUCH DAMAGE.
57	<	* ====================================================================
58	<	*
59	<	* This software consists of voluntary contributions made by many
60	<	* individuals on behalf of Lawrence Berkeley National Laboratory.   For more
61	<	* information on Lawrence Berkeley National Laboratory, please see
62	<	* <http://www.lbl.gov/>.
63	<	*/
8	>	#include "copyright.h"
9
10		/*
11		*  Input is in the form:
#	Line 76 | Line 21 | static const char      RCSid[] = "$Id$";
21		*  irradiance values are desired.
22		*/
23
24	<	#include  "ray.h"
24	>	#include  <time.h>
25
26	+	#include  "platform.h"
27	+	#include  "ray.h"
28	+	#include  "ambient.h"
29	+	#include  "source.h"
30		#include  "otypes.h"
82	–
31		#include  "resolu.h"
32
33		CUBE  thescene;                         /* our scene */
#	Line 100 | Line 48 | int  do_irrad = 0;                     /* compute irradiance? */
48
49		void  (*trace)() = NULL;                /* trace call */
50
103	–	extern void  ambnotify(), tranotify();
104	–	void  (*addobjnotify[])() = {ambnotify, tranotify, NULL};
51		char  *tralist[128];                    /* list of modifers to trace (or no) */
52		int  traincl = -1;                      /* include == 1, exclude == 0 */
53		#define  MAXTSET        511             /* maximum number in trace set */
#	Line 111 | Line 57 | int  hresolu = 0;                      /* horizontal (scan) size */
57		int  vresolu = 0;                       /* vertical resolution */
58
59		double  dstrsrc = 0.0;                  /* square source distribution */
60	<	double  shadthresh = .05;               /* shadow threshold */
61	<	double  shadcert = .5;                  /* shadow certainty */
60	>	double  shadthresh = .03;               /* shadow threshold */
61	>	double  shadcert = .75;                 /* shadow certainty */
62		int  directrelay = 2;                   /* number of source relays */
63		int  vspretest = 512;                   /* virtual source pretest density */
64		int  directvis = 1;                     /* sources visible? */
#	Line 128 | Line 74 | double  specjitter = 1.;               /* specular sampling jitter
74
75		int  backvis = 1;                       /* back face visibility */
76
77	<	int  maxdepth = 6;                      /* maximum recursion depth */
78	<	double  minweight = 4e-3;               /* minimum ray weight */
77	>	int  maxdepth = 8;                      /* maximum recursion depth */
78	>	double  minweight = 2e-3;               /* minimum ray weight */
79
80		char  *ambfile = NULL;                  /* ambient file name */
81		COLOR  ambval = BLKCOLOR;               /* ambient value */
82		int  ambvwt = 0;                        /* initial weight for ambient value */
83	<	double  ambacc = 0.2;                   /* ambient accuracy */
84	<	int  ambres = 128;                      /* ambient resolution */
85	<	int  ambdiv = 512;                      /* ambient divisions */
86	<	int  ambssamp = 0;                      /* ambient super-samples */
83	>	double  ambacc = 0.15;                  /* ambient accuracy */
84	>	int  ambres = 256;                      /* ambient resolution */
85	>	int  ambdiv = 1024;                     /* ambient divisions */
86	>	int  ambssamp = 512;                    /* ambient super-samples */
87		int  ambounce = 0;                      /* ambient bounces */
88	<	char  *amblist[128];                    /* ambient include/exclude list */
88	>	char  *amblist[AMBLLEN];                /* ambient include/exclude list */
89		int  ambincl = -1;                      /* include == 1, exclude == 0 */
90
91	+	static int  castonly = 0;
92
93		static RAY  thisray;                    /* for our convenience */
94
95	<	static void  oputo(), oputd(), oputv(), oputl(), oputL(),
96	<	oputp(), oputn(), oputN(), oputs(), oputw(), oputm();
95	>	typedef void putf_t(double v);
96	>	static putf_t puta, putd, putf;
97
98	<	static void  ourtrace(), tabin();
99	<	static void  (*ray_out[16])(), (*every_out[16])();
100	<	static int  castonly = 0;
98	>	typedef void oputf_t(RAY *r);
99	>	static oputf_t  oputo, oputd, oputv, oputl, oputL, oputc, oputp,
100	>	oputn, oputN, oputs, oputw, oputW, oputm, oputM, oputdash;
101
102	<	static void  puta(), putf(), putd();
102	>	static void setoutput(char *vs);
103	>	static void tranotify(OBJECT obj);
104	>	static void bogusray(void);
105	>	static void rad(FVECT  org, FVECT  dir, double  dmax);
106	>	static void irrad(FVECT  org, FVECT  dir);
107	>	static void printvals(RAY  *r);
108	>	static int getvec(FVECT  vec, int  fmt, FILE  *fp);
109	>	static void tabin(RAY  *r);
110	>	static void ourtrace(RAY  *r);
111
112	<	static void  (*putreal)();
112	>	static oputf_t *ray_out[16], *every_out[16];
113	>	static putf_t *putreal;
114
115	<	void    bogusray(), rad(), irrad(), printvals();
115	>	void  (*addobjnotify[])() = {ambnotify, tranotify, NULL};
116
117
118		void
119	<	quit(code)                      /* quit program */
120	<	int  code;
119	>	quit(                   /* quit program */
120	>	int  code
121	>	)
122		{
123	<	#ifndef  NIX
123	>	#ifndef  NON_POSIX /* XXX we don't clean up elsewhere? */
124		headclean();            /* delete header file */
125		pfclean();              /* clean up persist files */
126		#endif
#	Line 171 | Line 128 | int  code;
128		}
129
130
131	<	char *
132	<	formstr(f)                              /* return format identifier */
133	<	int  f;
131	>	extern char *
132	>	formstr(                                /* return format identifier */
133	>	int  f
134	>	)
135		{
136		switch (f) {
137		case 'a': return("ascii");
#	Line 185 | Line 143 | int  f;
143		}
144
145
146	<	void
147	<	rtrace(fname)                           /* trace rays from file */
148	<	char  *fname;
146	>	extern void
147	>	rtrace(                         /* trace rays from file */
148	>	char  *fname
149	>	)
150		{
151		long  vcount = hresolu>1 ? hresolu*vresolu : vresolu;
152		long  nextflush = hresolu;
#	Line 201 | Line 160 | char  *fname;
160		sprintf(errmsg, "cannot open input file \"%s\"", fname);
161		error(SYSTEM, errmsg);
162		}
163	<	#ifdef MSDOS
163	>	#ifdef _WIN32
164		if (inform != 'a')
165	<	setmode(fileno(fp), O_BINARY);
165	>	SET_FILE_BINARY(fp);
166		#endif
167		/* set up output */
168		setoutput(outvals);
#	Line 260 | Line 219 | char  *fname;
219		}
220
221
222	<	setoutput(vs)                           /* set up output tables */
223	<	register char  *vs;
222	>	static void
223	>	trace_sources(void)                     /* trace rays to light sources, also */
224		{
225	<	extern void  (*trace)();
226	<	register void (**table)() = ray_out;
225	>	int     sn;
226	>
227	>	for (sn = 0; sn < nsources; sn++)
228	>	source[sn].sflags |= SFOLLOW;
229	>	}
230
231	+
232	+	static void
233	+	setoutput(                              /* set up output tables */
234	+	register char  *vs
235	+	)
236	+	{
237	+	register oputf_t **table = ray_out;
238	+
239		castonly = 1;
240		while (*vs)
241		switch (*vs++) {
242	+	case 'T':                               /* trace sources */
243	+	trace_sources();
244	+	/* fall through */
245		case 't':                               /* trace */
246		*table = NULL;
247		table = every_out;
#	Line 289 | Line 262 | register char  *vs;
262		*table++ = oputl;
263		castonly = 0;
264		break;
265	+	case 'c':                               /* local coordinates */
266	+	*table++ = oputc;
267	+	break;
268		case 'L':                               /* single ray length */
269		*table++ = oputL;
270		break;
#	Line 308 | Line 284 | register char  *vs;
284		case 'w':                               /* weight */
285		*table++ = oputw;
286		break;
287	+	case 'W':                               /* coefficient */
288	+	*table++ = oputW;
289	+	if (ambounce > 0 && (ambacc > FTINY || ambssamp > 0))
290	+	error(WARNING,
291	+	"-otW accuracy depends on -aa 0 -as 0");
292	+	break;
293		case 'm':                               /* modifier */
294		*table++ = oputm;
295		break;
296	+	case 'M':                               /* material */
297	+	*table++ = oputM;
298	+	break;
299	+	case '-':                               /* dash */
300	+	*table++ = oputdash;
301	+	break;
302		}
303		*table = NULL;
304		}
305
306
307	<	void
308	<	bogusray()                      /* print out empty record */
307	>	static void
308	>	bogusray(void)                  /* print out empty record */
309		{
310		thisray.rorg[0] = thisray.rorg[1] = thisray.rorg[2] =
311		thisray.rdir[0] = thisray.rdir[1] = thisray.rdir[2] = 0.0;
312	<	rayorigin(&thisray, NULL, PRIMARY, 1.0);
312	>	thisray.rmax = 0.0;
313	>	rayorigin(&thisray, PRIMARY, NULL, NULL);
314		printvals(&thisray);
315		}
316
317
318	<	void
319	<	rad(org, dir, dmax)             /* compute and print ray value(s) */
320	<	FVECT  org, dir;
321	<	double  dmax;
318	>	static void
319	>	rad(            /* compute and print ray value(s) */
320	>	FVECT  org,
321	>	FVECT  dir,
322	>	double  dmax
323	>	)
324		{
325		VCOPY(thisray.rorg, org);
326		VCOPY(thisray.rdir, dir);
327		thisray.rmax = dmax;
328	<	rayorigin(&thisray, NULL, PRIMARY, 1.0);
328	>	rayorigin(&thisray, PRIMARY, NULL, NULL);
329		if (castonly) {
330	<	if (!localhit(&thisray, &thescene))
330	>	if (!localhit(&thisray, &thescene)) {
331		if (thisray.ro == &Aftplane) {  /* clipped */
332		thisray.ro = NULL;
333		thisray.rot = FHUGE;
334		} else
335		sourcehit(&thisray);
336	+	}
337		} else
338		rayvalue(&thisray);
339		printvals(&thisray);
340		}
341
342
343	<	void
344	<	irrad(org, dir)                 /* compute immediate irradiance value */
345	<	FVECT  org, dir;
343	>	static void
344	>	irrad(                  /* compute immediate irradiance value */
345	>	FVECT  org,
346	>	FVECT  dir
347	>	)
348		{
349		register int  i;
350
#	Line 358 | Line 352 | FVECT  org, dir;
352		thisray.rorg[i] = org[i] + dir[i];
353		thisray.rdir[i] = -dir[i];
354		}
355	<	rayorigin(&thisray, NULL, PRIMARY, 1.0);
355	>	thisray.rmax = 0.0;
356	>	rayorigin(&thisray, PRIMARY, NULL, NULL);
357		/* pretend we hit surface */
358		thisray.rot = 1.0-1e-4;
359		thisray.rod = 1.0;
#	Line 371 | Line 366 | FVECT  org, dir;
366		}
367
368
369	<	void
370	<	printvals(r)                    /* print requested ray values */
371	<	RAY  *r;
369	>	static void
370	>	printvals(                      /* print requested ray values */
371	>	RAY  *r
372	>	)
373		{
374	<	register void  (**tp)();
374	>	register oputf_t **tp;
375
376		if (ray_out[0] == NULL)
377		return;
#	Line 386 | Line 382 | RAY  *r;
382		}
383
384
385	<	int
386	<	getvec(vec, fmt, fp)            /* get a vector from fp */
387	<	register FVECT  vec;
388	<	int  fmt;
389	<	FILE  *fp;
385	>	static int
386	>	getvec(         /* get a vector from fp */
387	>	register FVECT  vec,
388	>	int  fmt,
389	>	FILE  *fp
390	>	)
391		{
392		static float  vf[3];
393		static double  vd[3];
#	Line 423 | Line 420 | FILE  *fp;
420		}
421
422
423	<	void
424	<	tranotify(obj)                  /* record new modifier */
425	<	OBJECT  obj;
423	>	static void
424	>	tranotify(                      /* record new modifier */
425	>	OBJECT  obj
426	>	)
427		{
428		static int  hitlimit = 0;
429		register OBJREC  *o = objptr(obj);
#	Line 452 | Line 450 | OBJECT obj;
450
451
452		static void
453	<	ourtrace(r)                             /* print ray values */
454	<	RAY  *r;
453	>	ourtrace(                               /* print ray values */
454	>	RAY  *r
455	>	)
456		{
457	<	register void  (**tp)();
457	>	register oputf_t **tp;
458
459		if (every_out[0] == NULL)
460		return;
#	Line 467 | Line 466 | RAY  *r;
466		tabin(r);
467		for (tp = every_out; *tp != NULL; tp++)
468		(**tp)(r);
469	<	putchar('\n');
469	>	if (outform == 'a')
470	>	putchar('\n');
471		}
472
473
474		static void
475	<	tabin(r)                                /* tab in appropriate amount */
476	<	RAY  *r;
475	>	tabin(                          /* tab in appropriate amount */
476	>	RAY  *r
477	>	)
478		{
479	<	register RAY  *rp;
479	>	const RAY  *rp;
480
481		for (rp = r->parent; rp != NULL; rp = rp->parent)
482		putchar('\t');
#	Line 483 | Line 484 | RAY  *r;
484
485
486		static void
487	<	oputo(r)                                /* print origin */
488	<	register RAY  *r;
487	>	oputo(                          /* print origin */
488	>	RAY  *r
489	>	)
490		{
491		(*putreal)(r->rorg[0]);
492		(*putreal)(r->rorg[1]);
#	Line 493 | Line 495 | register RAY  *r;
495
496
497		static void
498	<	oputd(r)                                /* print direction */
499	<	register RAY  *r;
498	>	oputd(                          /* print direction */
499	>	RAY  *r
500	>	)
501		{
502		(*putreal)(r->rdir[0]);
503		(*putreal)(r->rdir[1]);
#	Line 503 | Line 506 | register RAY  *r;
506
507
508		static void
509	<	oputv(r)                                /* print value */
510	<	register RAY  *r;
509	>	oputv(                          /* print value */
510	>	RAY  *r
511	>	)
512		{
509	–	COLR  cout;
510	–
513		if (outform == 'c') {
514	+	COLR  cout;
515		setcolr(cout,   colval(r->rcol,RED),
516		colval(r->rcol,GRN),
517		colval(r->rcol,BLU));
#	Line 522 | Line 525 | register RAY  *r;
525
526
527		static void
528	<	oputl(r)                                /* print effective distance */
529	<	register RAY  *r;
528	>	oputl(                          /* print effective distance */
529	>	RAY  *r
530	>	)
531		{
532		(*putreal)(r->rt);
533		}
534
535
536		static void
537	<	oputL(r)                                /* print single ray length */
538	<	register RAY  *r;
537	>	oputL(                          /* print single ray length */
538	>	RAY  *r
539	>	)
540		{
541		(*putreal)(r->rot);
542		}
543
544
545		static void
546	<	oputp(r)                                /* print point */
547	<	register RAY  *r;
546	>	oputc(                          /* print local coordinates */
547	>	RAY  *r
548	>	)
549		{
550	+	(*putreal)(r->uv[0]);
551	+	(*putreal)(r->uv[1]);
552	+	}
553	+
554	+
555	+	static void
556	+	oputp(                          /* print point */
557	+	RAY  *r
558	+	)
559	+	{
560		if (r->rot < FHUGE) {
561		(*putreal)(r->rop[0]);
562		(*putreal)(r->rop[1]);
#	Line 554 | Line 570 | register RAY  *r;
570
571
572		static void
573	<	oputN(r)                                /* print unperturbed normal */
574	<	register RAY  *r;
573	>	oputN(                          /* print unperturbed normal */
574	>	RAY  *r
575	>	)
576		{
577		if (r->rot < FHUGE) {
578		(*putreal)(r->ron[0]);
#	Line 570 | Line 587 | register RAY  *r;
587
588
589		static void
590	<	oputn(r)                                /* print perturbed normal */
591	<	RAY  *r;
590	>	oputn(                          /* print perturbed normal */
591	>	RAY  *r
592	>	)
593		{
594		FVECT  pnorm;
595
#	Line 589 | Line 607 | RAY  *r;
607
608
609		static void
610	<	oputs(r)                                /* print name */
611	<	register RAY  *r;
610	>	oputs(                          /* print name */
611	>	RAY  *r
612	>	)
613		{
614		if (r->ro != NULL)
615		fputs(r->ro->oname, stdout);
#	Line 601 | Line 620 | register RAY  *r;
620
621
622		static void
623	<	oputw(r)                                /* print weight */
624	<	register RAY  *r;
623	>	oputw(                          /* print weight */
624	>	RAY  *r
625	>	)
626		{
627		(*putreal)(r->rweight);
628		}
629
630
631		static void
632	<	oputm(r)                                /* print modifier */
633	<	register RAY  *r;
632	>	oputW(                          /* print contribution */
633	>	RAY  *r
634	>	)
635		{
636	+	COLOR   contr;
637	+
638	+	raycontrib(contr, r, PRIMARY);
639	+	(*putreal)(colval(contr,RED));
640	+	(*putreal)(colval(contr,GRN));
641	+	(*putreal)(colval(contr,BLU));
642	+	}
643	+
644	+
645	+	static void
646	+	oputm(                          /* print modifier */
647	+	RAY  *r
648	+	)
649	+	{
650		if (r->ro != NULL)
651		if (r->ro->omod != OVOID)
652		fputs(objptr(r->ro->omod)->oname, stdout);
#	Line 624 | Line 659 | register RAY  *r;
659
660
661		static void
662	<	puta(v)                         /* print ascii value */
663	<	double  v;
662	>	oputM(                          /* print material */
663	>	RAY  *r
664	>	)
665	>	{
666	>	OBJREC  *mat;
667	>
668	>	if (r->ro != NULL) {
669	>	if ((mat = findmaterial(r->ro)) != NULL)
670	>	fputs(mat->oname, stdout);
671	>	else
672	>	fputs(VOIDID, stdout);
673	>	} else
674	>	putchar('*');
675	>	putchar('\t');
676	>	}
677	>
678	>
679	>	static void
680	>	oputdash(                       /* output dash (spacer) */
681	>	RAY  *r
682	>	)
683	>	{
684	>	putchar('-');
685	>	putchar('\t');
686	>	}
687	>
688	>
689	>	static void
690	>	puta(                           /* print ascii value */
691	>	double  v
692	>	)
693		{
694		printf("%e\t", v);
695		}

Diff Legend

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