ViewVC Help

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

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

Comparing ray/src/rt/noise3.c (file contents):
Revision 1.2 by greg, Fri Mar 3 12:25:34 1989 UTC vs.
Revision 2.6 by greg, Sat Feb 22 02:07:29 2003 UTC

#	Line 1 | Line 1
1	–	/* Copyright (c) 1988 Regents of the University of California */
2	–
1		#ifndef lint
2	<	static char SCCSid[] = "$SunId$ LBL";
2	>	static const char       RCSid[] = "$Id$";
3		#endif
6	–
4		/*
5		*  noise3.c - noise functions for random textures.
6		*
7		*     Credit for the smooth algorithm goes to Ken Perlin.
8		*     (ref. SIGGRAPH Vol 19, No 3, pp 287-96)
9	+	*/
10	+
11	+	/* ====================================================================
12	+	* The Radiance Software License, Version 1.0
13		*
14	<	*     4/15/86
15	<	*     5/19/88  Added fractal noise function
14	>	* Copyright (c) 1990 - 2002 The Regents of the University of California,
15	>	* through Lawrence Berkeley National Laboratory.   All rights reserved.
16	>	*
17	>	* Redistribution and use in source and binary forms, with or without
18	>	* modification, are permitted provided that the following conditions
19	>	* are met:
20	>	*
21	>	* 1. Redistributions of source code must retain the above copyright
22	>	*         notice, this list of conditions and the following disclaimer.
23	>	*
24	>	* 2. Redistributions in binary form must reproduce the above copyright
25	>	*       notice, this list of conditions and the following disclaimer in
26	>	*       the documentation and/or other materials provided with the
27	>	*       distribution.
28	>	*
29	>	* 3. The end-user documentation included with the redistribution,
30	>	*           if any, must include the following acknowledgment:
31	>	*             "This product includes Radiance software
32	>	*                 (http://radsite.lbl.gov/)
33	>	*                 developed by the Lawrence Berkeley National Laboratory
34	>	*               (http://www.lbl.gov/)."
35	>	*       Alternately, this acknowledgment may appear in the software itself,
36	>	*       if and wherever such third-party acknowledgments normally appear.
37	>	*
38	>	* 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
39	>	*       and "The Regents of the University of California" must
40	>	*       not be used to endorse or promote products derived from this
41	>	*       software without prior written permission. For written
42	>	*       permission, please contact [email protected].
43	>	*
44	>	* 5. Products derived from this software may not be called "Radiance",
45	>	*       nor may "Radiance" appear in their name, without prior written
46	>	*       permission of Lawrence Berkeley National Laboratory.
47	>	*
48	>	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
49	>	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
50	>	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
51	>	* DISCLAIMED.   IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
52	>	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
53	>	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
54	>	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
55	>	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
56	>	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
57	>	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
58	>	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59	>	* SUCH DAMAGE.
60	>	* ====================================================================
61	>	*
62	>	* This software consists of voluntary contributions made by many
63	>	* individuals on behalf of Lawrence Berkeley National Laboratory.   For more
64	>	* information on Lawrence Berkeley National Laboratory, please see
65	>	* <http://www.lbl.gov/>.
66		*/
67
68	+	#include  <math.h>
69
70		#define  A              0
71		#define  B              1
#	Line 25 | Line 77 | static char SCCSid[] = "$SunId$ LBL";
77		#define  rand3c(x,y,z)  frand(89*(x)+97*(y)+101*(z))
78		#define  rand3d(x,y,z)  frand(103*(x)+107*(y)+109*(z))
79
80	<	#define  hermite(p0,p1,r0,r1,t)  (      p0*((2.0*t-3.0)*t*t+1.0) + \
81	<	p1*(-2.0*t+3.0)*t*t + \
82	<	r0*((t-2.0)*t+1.0)*t + \
83	<	r1*(t-1.0)*t*t )
80	>	#define  hpoly1(t)      ((2.0*t-3.0)*t*t+1.0)
81	>	#define  hpoly2(t)      (-2.0*t+3.0)*t*t
82	>	#define  hpoly3(t)      ((t-2.0)*t+1.0)*t
83	>	#define  hpoly4(t)      (t-1.0)*t*t
84
85	<	double  *noise3(), noise3coef(), argument(), frand();
85	>	#define  hermite(p0,p1,r0,r1,t)  (      p0*hpoly1(t) + \
86	>	p1*hpoly2(t) + \
87	>	r0*hpoly3(t) + \
88	>	r1*hpoly4(t) )
89
90	+	static char  noise_name[4][8] = {"noise3x", "noise3y", "noise3z", "noise3"};
91	+	static char  fnoise_name[] = "fnoise3";
92	+	static char  hermite_name[] = "hermite";
93	+
94	+	double  *noise3(), fnoise3(), argument(), frand();
95	+	static  interpolate();
96	+
97		static long  xlim[3][2];
98		static double  xarg[3];
99
100	<	#define  EPSILON        .0001           /* error allowed in fractal */
100	>	#define  EPSILON        .001            /* error allowed in fractal */
101
102	<	#define  frand3(x,y,z)  frand((long)((12.38*(x)-22.30*(y)-42.63*(z))/EPSILON))
102	>	#define  frand3(x,y,z)  frand(17*(x)+23*(y)+29*(z))
103
42	–	double  fnoise3();
104
105	<
106	<	double
107	<	l_noise3()                      /* compute 3-dimensional noise function */
105	>	static double
106	>	l_noise3(nam)                   /* compute a noise function */
107	>	register char  *nam;
108		{
109	<	return(noise3coef(D));
109	>	register int  i;
110	>	double  x[3];
111	>	/* get point */
112	>	x[0] = argument(1);
113	>	x[1] = argument(2);
114	>	x[2] = argument(3);
115	>	/* make appropriate call */
116	>	if (nam == fnoise_name)
117	>	return(fnoise3(x));
118	>	i = 4;
119	>	while (i--)
120	>	if (nam == noise_name[i])
121	>	return(noise3(x)[i]);
122	>	eputs(nam);
123	>	eputs(": called l_noise3!\n");
124	>	quit(1);
125		}
126
127
128		double
129	<	l_noise3a()                     /* compute x slope of noise function */
129	>	l_hermite()                     /* library call for hermite interpolation */
130		{
131	<	return(noise3coef(A));
131	>	double  t;
132	>
133	>	t = argument(5);
134	>	return( hermite(argument(1), argument(2),
135	>	argument(3), argument(4), t) );
136		}
137
138
139	<	double
60	<	l_noise3b()                     /* compute y slope of noise function */
139	>	setnoisefuncs()                 /* add noise functions to library */
140		{
141	<	return(noise3coef(B));
63	<	}
141	>	register int  i;
142
143	<
144	<	double
145	<	l_noise3c()                     /* compute z slope of noise function */
146	<	{
147	<	return(noise3coef(C));
143	>	funset(hermite_name, 5, ':', l_hermite);
144	>	funset(fnoise_name, 3, ':', l_noise3);
145	>	i = 4;
146	>	while (i--)
147	>	funset(noise_name[i], 3, ':', l_noise3);
148		}
149
150
73	–	double
74	–	l_fnoise3()                     /* compute fractal noise function */
75	–	{
76	–	double  x[3];
77	–
78	–	x[0] = argument(1);
79	–	x[1] = argument(2);
80	–	x[2] = argument(3);
81	–
82	–	return(fnoise3(x));
83	–	}
84	–
85	–
86	–	static double
87	–	noise3coef(coef)                /* return coefficient of noise function */
88	–	int  coef;
89	–	{
90	–	double  x[3];
91	–
92	–	x[0] = argument(1);
93	–	x[1] = argument(2);
94	–	x[2] = argument(3);
95	–
96	–	return(noise3(x)[coef]);
97	–	}
98	–
99	–
151		double *
152		noise3(xnew)                    /* compute the noise function */
153		register double  xnew[3];
154		{
104	–	extern double  floor();
155		static double  x[3] = {-100000.0, -100000.0, -100000.0};
156		static double  f[4];
157
#	Line 124 | Line 174 | interpolate(f, i, n)
174		double  f[4];
175		register int  i, n;
176		{
177	<	double  f0[4], f1[4];
177	>	double  f0[4], f1[4], hp1, hp2;
178
179		if (n == 0) {
180		f[A] = rand3a(xlim[0][i&1],xlim[1][i>>1&1],xlim[2][i>>2]);
#	Line 135 | Line 185 | register int  i, n;
185		n--;
186		interpolate(f0, i, n);
187		interpolate(f1, i | 1<<n, n);
188	<	f[A] = (1.0-xarg[n])*f0[A] + xarg[n]*f1[A];
189	<	f[B] = (1.0-xarg[n])*f0[B] + xarg[n]*f1[B];
190	<	f[C] = (1.0-xarg[n])*f0[C] + xarg[n]*f1[C];
191	<	f[D] = hermite(f0[D], f1[D], f0[n], f1[n], xarg[n]);
188	>	hp1 = hpoly1(xarg[n]); hp2 = hpoly2(xarg[n]);
189	>	f[A] = f0[A]*hp1 + f1[A]*hp2;
190	>	f[B] = f0[B]*hp1 + f1[B]*hp2;
191	>	f[C] = f0[C]*hp1 + f1[C]*hp2;
192	>	f[D] = f0[D]*hp1 + f1[D]*hp2 +
193	>	f0[n]*hpoly3(xarg[n]) + f1[n]*hpoly4(xarg[n]);
194		}
195		}
196
#	Line 153 | Line 205 | register long  s;
205
206
207		double
156	–	l_hermite()                     /* library call for hermite interpolation */
157	–	{
158	–	double  t;
159	–
160	–	t = argument(5);
161	–	return( hermite(argument(1), argument(2),
162	–	argument(3), argument(4), t) );
163	–	}
164	–
165	–
166	–	double
208		fnoise3(p)                      /* compute fractal noise function */
209	<	register double  p[3];
209	>	double  p[3];
210		{
211	<	double  floor();
212	<	double  v[3], beg[3], fval[8], s, fc;
213	<	int  closing, branch;
211	>	long  t[3], v[3], beg[3];
212	>	double  fval[8], fc;
213	>	int  branch;
214	>	register long  s;
215		register int  i, j;
216		/* get starting cube */
217	<	for (i = 0; i < 3; i++)
218	<	beg[i] = floor(p[i]);
217	>	s = (long)(1.0/EPSILON);
218	>	for (i = 0; i < 3; i++) {
219	>	t[i] = s*p[i];
220	>	beg[i] = s*floor(p[i]);
221	>	}
222		for (j = 0; j < 8; j++) {
223		for (i = 0; i < 3; i++) {
224		v[i] = beg[i];
225		if (j & 1<<i)
226	<	v[i] += 1.0;
226	>	v[i] += s;
227		}
228		fval[j] = frand3(v[0],v[1],v[2]);
229		}
185	–	s = 1.0;
230		/* compute fractal */
231		for ( ; ; ) {
232	<	s *= 0.5;
232	>	fc = 0.0;
233	>	for (j = 0; j < 8; j++)
234	>	fc += fval[j];
235	>	fc *= 0.125;
236	>	if ((s >>= 1) == 0)
237	>	return(fc);             /* close enough */
238		branch = 0;
190	–	closing = 0;
239		for (i = 0; i < 3; i++) {       /* do center */
240		v[i] = beg[i] + s;
241	<	if (p[i] > v[i]) {
241	>	if (t[i] > v[i]) {
242		branch |= 1<<i;
243	<	if (p[i] - v[i] > EPSILON)
196	<	closing++;
197	<	} else if (v[i] - p[i] > EPSILON)
198	<	closing++;
243	>	}
244		}
245	<	fc = 0.0;
201	<	for (j = 0; j < 8; j++)
202	<	fc += fval[j];
203	<	fc = 0.125*fc + s*frand3(v[0],v[1],v[2]);
204	<	if (closing == 0)
205	<	return(fc);             /* close enough */
245	>	fc += s*EPSILON*frand3(v[0],v[1],v[2]);
246		fval[~branch & 7] = fc;
247		for (i = 0; i < 3; i++) {       /* do faces */
248		if (branch & 1<<i)
#	Line 213 | Line 253 | register double  p[3];
253		for (j = 0; j < 8; j++)
254		if (~(j^branch) & 1<<i)
255		fc += fval[j];
256	<	fc = 0.25*fc + s*frand3(v[0],v[1],v[2]);
256	>	fc = 0.25*fc + s*EPSILON*frand3(v[0],v[1],v[2]);
257		fval[~(branch^1<<i) & 7] = fc;
258		v[i] = beg[i] + s;
259		}
#	Line 230 | Line 270 | register double  p[3];
270		v[j] -= s;
271		fc = fval[branch & ~(1<<i)];
272		fc += fval[branch | 1<<i];
273	<	fc = 0.5*fc + s*frand3(v[0],v[1],v[2]);
273	>	fc = 0.5*fc + s*EPSILON*frand3(v[0],v[1],v[2]);
274		fval[branch^1<<i] = fc;
275		j = (i+1)%3;
276		v[j] = beg[j] + s;

Diff Legend

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