ViewVC Help

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

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

Comparing ray/src/rt/raytrace.c (file contents):
Revision 2.34 by greg, Sat Feb 22 02:07:29 2003 UTC vs.
Revision 2.44 by greg, Wed Dec 31 01:50:02 2003 UTC

#	Line 1 | Line 1
1		#ifndef lint
2	<	static const char       RCSid[] = "$Id$";
2	>	static const char RCSid[] = "$Id$";
3		#endif
4		/*
5		*  raytrace.c - routines for tracing and shading rays.
#	Line 7 | Line 7 | static const char      RCSid[] = "$Id$";
7		*  External symbols declared in ray.h
8		*/
9
10	<	/* ====================================================================
11	<	* The Radiance Software License, Version 1.0
12	<	*
13	<	* Copyright (c) 1990 - 2002 The Regents of the University of California,
14	<	* through Lawrence Berkeley National Laboratory.   All rights reserved.
15	<	*
16	<	* Redistribution and use in source and binary forms, with or without
17	<	* modification, are permitted provided that the following conditions
18	<	* are met:
19	<	*
20	<	* 1. Redistributions of source code must retain the above copyright
21	<	*         notice, this list of conditions and the following disclaimer.
22	<	*
23	<	* 2. Redistributions in binary form must reproduce the above copyright
24	<	*       notice, this list of conditions and the following disclaimer in
25	<	*       the documentation and/or other materials provided with the
26	<	*       distribution.
27	<	*
28	<	* 3. The end-user documentation included with the redistribution,
29	<	*           if any, must include the following acknowledgment:
30	<	*             "This product includes Radiance software
31	<	*                 (http://radsite.lbl.gov/)
32	<	*                 developed by the Lawrence Berkeley National Laboratory
33	<	*               (http://www.lbl.gov/)."
34	<	*       Alternately, this acknowledgment may appear in the software itself,
35	<	*       if and wherever such third-party acknowledgments normally appear.
36	<	*
37	<	* 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
38	<	*       and "The Regents of the University of California" must
39	<	*       not be used to endorse or promote products derived from this
40	<	*       software without prior written permission. For written
41	<	*       permission, please contact [email protected].
42	<	*
43	<	* 5. Products derived from this software may not be called "Radiance",
44	<	*       nor may "Radiance" appear in their name, without prior written
45	<	*       permission of Lawrence Berkeley National Laboratory.
46	<	*
47	<	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
48	<	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
49	<	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
50	<	* DISCLAIMED.   IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
51	<	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
52	<	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
53	<	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
54	<	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
55	<	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
56	<	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
57	<	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58	<	* SUCH DAMAGE.
59	<	* ====================================================================
60	<	*
61	<	* This software consists of voluntary contributions made by many
62	<	* individuals on behalf of Lawrence Berkeley National Laboratory.   For more
63	<	* information on Lawrence Berkeley National Laboratory, please see
64	<	* <http://www.lbl.gov/>.
65	<	*/
10	>	#include "copyright.h"
11
12		#include  "ray.h"
13
#	Line 75 | Line 20 | static const char      RCSid[] = "$Id$";
20		unsigned long  raynum = 0;              /* next unique ray number */
21		unsigned long  nrays = 0;               /* number of calls to localhit */
22
23	<	static FLOAT  Lambfa[5] = {PI, PI, PI, 0.0, 0.0};
23	>	static RREAL  Lambfa[5] = {PI, PI, PI, 0.0, 0.0};
24		OBJREC  Lamb = {
25		OVOID, MAT_PLASTIC, "Lambertian",
26		{0, 5, NULL, Lambfa}, NULL,
#	Line 86 | Line 31 | OBJREC  Aftplane;                      /* aft clipping plane object */
31		static int  raymove(), checkhit();
32		static void  checkset();
33
89	–	#ifndef  MAXLOOP
90	–	#define  MAXLOOP        0               /* modifier loop detection */
91	–	#endif
92	–
34		#define  RAYHIT         (-1)            /* return value for intercepted ray */
35
36
#	Line 150 | Line 91 | register RAY  *r;
91		{
92		r->rno = raynum++;
93		r->newcset = r->clipset;
94	+	r->hitf = rayhit;
95		r->robj = OVOID;
96		r->ro = NULL;
97		r->rox = NULL;
98		r->rt = r->rot = FHUGE;
99		r->pert[0] = r->pert[1] = r->pert[2] = 0.0;
100	+	r->uv[0] = r->uv[1] = 0.0;
101		setcolor(r->pcol, 1.0, 1.0, 1.0);
102		setcolor(r->rcol, 0.0, 0.0, 0.0);
103		}
#	Line 211 | Line 154 | int  mod;
154		{
155		int  gotmat;
156		register OBJREC  *m;
214	–	#if  MAXLOOP
215	–	static int  depth = 0;
216	–	/* check for infinite loop */
217	–	if (depth++ >= MAXLOOP)
218	–	objerror(r->ro, USER, "possible modifier loop");
219	–	#endif
157		r->rt = r->rot;                 /* set effective ray length */
158		for (gotmat = 0; !gotmat && mod != OVOID; mod = m->omod) {
159		m = objptr(mod);
#	Line 227 | Line 164 | int  mod;
164		}
165		******/
166		/* hack for irradiance calculation */
167	<	if (do_irrad && !(r->crtype & ~(PRIMARY|TRANS))) {
167	>	if (do_irrad && !(r->crtype & ~(PRIMARY|TRANS)) &&
168	>	m->otype != MAT_CLIP &&
169	>	(ofun[m->otype].flags & (T_M|T_X))) {
170		if (irr_ignore(m->otype)) {
232	–	#if  MAXLOOP
233	–	depth--;
234	–	#endif
171		raytrans(r);
172		return(1);
173		}
#	Line 241 | Line 177 | int  mod;
177		/* materials call raytexture */
178		gotmat = (*ofun[m->otype].funp)(m, r);
179		}
244	–	#if  MAXLOOP
245	–	depth--;
246	–	#endif
180		return(gotmat);
181		}
182
#	Line 280 | Line 213 | register RAY  *r;
213		}
214
215
216	+	void
217		raytexture(r, mod)                      /* get material modifiers */
218		RAY  *r;
219	<	int  mod;
219	>	OBJECT  mod;
220		{
221		register OBJREC  *m;
288	–	#if  MAXLOOP
289	–	static int  depth = 0;
290	–	/* check for infinite loop */
291	–	if (depth++ >= MAXLOOP)
292	–	objerror(r->ro, USER, "modifier loop");
293	–	#endif
222		/* execute textures and patterns */
223		for ( ; mod != OVOID; mod = m->omod) {
224		m = objptr(mod);
#	Line 306 | Line 234 | int  mod;
234		objerror(r->ro, USER, errmsg);
235		}
236		}
309	–	#if  MAXLOOP
310	–	depth--;                        /* end here */
311	–	#endif
237		}
238
239
#	Line 329 | Line 254 | double  coef;
254		/* compute foreground and background */
255		foremat = backmat = 0;
256		/* foreground */
257	<	copystruct(&fr, r);
257	>	fr = *r;
258		if (coef > FTINY)
259		foremat = rayshade(&fr, fore);
260		/* background */
261	<	copystruct(&br, r);
261	>	br = *r;
262		if (coef < 1.0-FTINY)
263		backmat = rayshade(&br, back);
264		/* check for transparency */
265	<	if (backmat ^ foremat)
265	>	if (backmat ^ foremat) {
266		if (backmat && coef > FTINY)
267		raytrans(&fr);
268		else if (foremat && coef < 1.0-FTINY)
269		raytrans(&br);
270	+	}
271		/* mix perturbations */
272		for (i = 0; i < 3; i++)
273		r->pert[i] = coef*fr.pert[i] + (1.0-coef)*br.pert[i];
#	Line 464 | Line 390 | register RAY  *r;
390		}
391
392
393	+	void
394	+	rayhit(oset, r)                 /* standard ray hit test */
395	+	OBJECT  *oset;
396	+	RAY  *r;
397	+	{
398	+	OBJREC  *o;
399	+	int     i;
400	+
401	+	for (i = oset[0]; i > 0; i--) {
402	+	o = objptr(oset[i]);
403	+	if ((*ofun[o->otype].funp)(o, r))
404	+	r->robj = oset[i];
405	+	}
406	+	}
407	+
408	+
409		int
410		localhit(r, scene)              /* check for hit in the octree */
411		register RAY  *r;
#	Line 522 | Line 464 | register CUBE  *scene;
464		}
465		cxset[0] = 0;
466		raymove(curpos, cxset, sflags, r, scene);
467	<	return(r->ro != NULL & r->ro != &Aftplane);
467	>	return((r->ro != NULL) & (r->ro != &Aftplane));
468		}
469
470
#	Line 619 | Line 561 | CUBE  *cu;
561		OBJECT  *cxs;
562		{
563		OBJECT  oset[MAXSET+1];
622	–	register OBJREC  *o;
623	–	register int  i;
564
565		objset(oset, cu->cutree);
566	<	checkset(oset, cxs);                    /* eliminate double-checking */
567	<	for (i = oset[0]; i > 0; i--) {
568	<	o = objptr(oset[i]);
569	<	if ((*ofun[o->otype].funp)(o, r))
570	<	r->robj = oset[i];
631	<	}
632	<	if (r->ro == NULL)
566	>	checkset(oset, cxs);                    /* avoid double-checking */
567	>
568	>	(*r->hitf)(oset, r);                    /* test for hit in set */
569	>
570	>	if (r->robj == OVOID)
571		return(0);                      /* no scores yet */
572
573		return(incube(cu, r->rop));             /* hit OK if in current cube */

Diff Legend

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