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.2 by greg, Fri Oct 2 16:18:50 1992 UTC

#	Line 14 | Line 14 | static char SCCSid[] = "$SunId$ LBL";
14		*     5/19/88  Added fractal noise function
15		*/
16
17	+	#include  <math.h>
18
19		#define  A              0
20		#define  B              1
#	Line 25 | Line 26 | static char SCCSid[] = "$SunId$ LBL";
26		#define  rand3c(x,y,z)  frand(89*(x)+97*(y)+101*(z))
27		#define  rand3d(x,y,z)  frand(103*(x)+107*(y)+109*(z))
28
29	<	#define  hermite(p0,p1,r0,r1,t)  (      p0*((2.0*t-3.0)*t*t+1.0) + \
30	<	p1*(-2.0*t+3.0)*t*t + \
31	<	r0*((t-2.0)*t+1.0)*t + \
32	<	r1*(t-1.0)*t*t )
29	>	#define  hpoly1(t)      ((2.0*t-3.0)*t*t+1.0)
30	>	#define  hpoly2(t)      (-2.0*t+3.0)*t*t
31	>	#define  hpoly3(t)      ((t-2.0)*t+1.0)*t
32	>	#define  hpoly4(t)      (t-1.0)*t*t
33
34	<	double  *noise3(), noise3coef(), argument(), frand();
34	>	#define  hermite(p0,p1,r0,r1,t)  (      p0*hpoly1(t) + \
35	>	p1*hpoly2(t) + \
36	>	r0*hpoly3(t) + \
37	>	r1*hpoly4(t) )
38
39	+	static char  noise_name[4][8] = {"noise3a", "noise3b", "noise3c", "noise3"};
40	+	static char  fnoise_name[] = "fnoise3";
41	+	static char  hermite_name[] = "hermite";
42	+
43	+	double  *noise3(), fnoise3(), argument(), frand();
44	+
45		static long  xlim[3][2];
46		static double  xarg[3];
47
48		#define  EPSILON        .0001           /* error allowed in fractal */
49
50	<	#define  frand3(x,y,z)  frand((long)((12.38*(x)-22.30*(y)-42.63*(z))/EPSILON))
50	>	#define  frand3(x,y,z)  frand(17*(x)+23*(y)+29*(z))
51
42	–	double  fnoise3();
52
53	<
54	<	double
55	<	l_noise3()                      /* compute 3-dimensional noise function */
53	>	static double
54	>	l_noise3(nam)                   /* compute a noise function */
55	>	register char  *nam;
56		{
57	<	return(noise3coef(D));
57	>	register int  i;
58	>	double  x[3];
59	>	/* get point */
60	>	x[0] = argument(1);
61	>	x[1] = argument(2);
62	>	x[2] = argument(3);
63	>	/* make appropriate call */
64	>	if (nam == fnoise_name)
65	>	return(fnoise3(x));
66	>	i = 4;
67	>	while (i--)
68	>	if (nam == noise_name[i])
69	>	return(noise3(x)[i]);
70	>	eputs(nam);
71	>	eputs(": called l_noise3!\n");
72	>	quit(1);
73		}
74
75
76		double
77	<	l_noise3a()                     /* compute x slope of noise function */
77	>	l_hermite()                     /* library call for hermite interpolation */
78		{
79	<	return(noise3coef(A));
79	>	double  t;
80	>
81	>	t = argument(5);
82	>	return( hermite(argument(1), argument(2),
83	>	argument(3), argument(4), t) );
84		}
85
86
87	<	double
60	<	l_noise3b()                     /* compute y slope of noise function */
87	>	setnoisefuncs()                 /* add noise functions to library */
88		{
89	<	return(noise3coef(B));
63	<	}
89	>	register int  i;
90
91	<
92	<	double
93	<	l_noise3c()                     /* compute z slope of noise function */
94	<	{
95	<	return(noise3coef(C));
91	>	funset(hermite_name, 5, ':', l_hermite);
92	>	funset(fnoise_name, 3, ':', l_noise3);
93	>	i = 4;
94	>	while (i--)
95	>	funset(noise_name[i], 3, ':', l_noise3);
96		}
97
98
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	–
99		double *
100		noise3(xnew)                    /* compute the noise function */
101		register double  xnew[3];
102		{
104	–	extern double  floor();
103		static double  x[3] = {-100000.0, -100000.0, -100000.0};
104		static double  f[4];
105
#	Line 124 | Line 122 | interpolate(f, i, n)
122		double  f[4];
123		register int  i, n;
124		{
125	<	double  f0[4], f1[4];
125	>	double  f0[4], f1[4], hp1, hp2;
126
127		if (n == 0) {
128		f[A] = rand3a(xlim[0][i&1],xlim[1][i>>1&1],xlim[2][i>>2]);
#	Line 135 | Line 133 | register int  i, n;
133		n--;
134		interpolate(f0, i, n);
135		interpolate(f1, i | 1<<n, n);
136	<	f[A] = (1.0-xarg[n])*f0[A] + xarg[n]*f1[A];
137	<	f[B] = (1.0-xarg[n])*f0[B] + xarg[n]*f1[B];
138	<	f[C] = (1.0-xarg[n])*f0[C] + xarg[n]*f1[C];
139	<	f[D] = hermite(f0[D], f1[D], f0[n], f1[n], xarg[n]);
136	>	hp1 = hpoly1(xarg[n]); hp2 = hpoly2(xarg[n]);
137	>	f[A] = f0[A]*hp1 + f1[A]*hp2;
138	>	f[B] = f0[B]*hp1 + f1[B]*hp2;
139	>	f[C] = f0[C]*hp1 + f1[C]*hp2;
140	>	f[D] = f0[D]*hp1 + f1[D]*hp2 +
141	>	f0[n]*hpoly3(xarg[n]) + f1[n]*hpoly4(xarg[n]);
142		}
143		}
144
#	Line 153 | Line 153 | register long  s;
153
154
155		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
156		fnoise3(p)                      /* compute fractal noise function */
157	<	register double  p[3];
157	>	double  p[3];
158		{
159	<	double  floor();
160	<	double  v[3], beg[3], fval[8], s, fc;
161	<	int  closing, branch;
159	>	long  t[3], v[3], beg[3];
160	>	double  fval[8], fc;
161	>	int  branch;
162	>	register long  s;
163		register int  i, j;
164		/* get starting cube */
165	<	for (i = 0; i < 3; i++)
166	<	beg[i] = floor(p[i]);
165	>	s = (long)(1.0/EPSILON);
166	>	for (i = 0; i < 3; i++) {
167	>	t[i] = s*p[i];
168	>	beg[i] = s*floor(p[i]);
169	>	}
170		for (j = 0; j < 8; j++) {
171		for (i = 0; i < 3; i++) {
172		v[i] = beg[i];
173		if (j & 1<<i)
174	<	v[i] += 1.0;
174	>	v[i] += s;
175		}
176		fval[j] = frand3(v[0],v[1],v[2]);
177		}
185	–	s = 1.0;
178		/* compute fractal */
179		for ( ; ; ) {
180	<	s *= 0.5;
180	>	fc = 0.0;
181	>	for (j = 0; j < 8; j++)
182	>	fc += fval[j];
183	>	fc *= 0.125;
184	>	if ((s >>= 1) == 0)
185	>	return(fc);             /* close enough */
186		branch = 0;
190	–	closing = 0;
187		for (i = 0; i < 3; i++) {       /* do center */
188		v[i] = beg[i] + s;
189	<	if (p[i] > v[i]) {
189	>	if (t[i] > v[i]) {
190		branch |= 1<<i;
191	<	if (p[i] - v[i] > EPSILON)
196	<	closing++;
197	<	} else if (v[i] - p[i] > EPSILON)
198	<	closing++;
191	>	}
192		}
193	<	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 */
193	>	fc += s*EPSILON*frand3(v[0],v[1],v[2]);
194		fval[~branch & 7] = fc;
195		for (i = 0; i < 3; i++) {       /* do faces */
196		if (branch & 1<<i)
#	Line 213 | Line 201 | register double  p[3];
201		for (j = 0; j < 8; j++)
202		if (~(j^branch) & 1<<i)
203		fc += fval[j];
204	<	fc = 0.25*fc + s*frand3(v[0],v[1],v[2]);
204	>	fc = 0.25*fc + s*EPSILON*frand3(v[0],v[1],v[2]);
205		fval[~(branch^1<<i) & 7] = fc;
206		v[i] = beg[i] + s;
207		}
#	Line 230 | Line 218 | register double  p[3];
218		v[j] -= s;
219		fc = fval[branch & ~(1<<i)];
220		fc += fval[branch | 1<<i];
221	<	fc = 0.5*fc + s*frand3(v[0],v[1],v[2]);
221	>	fc = 0.5*fc + s*EPSILON*frand3(v[0],v[1],v[2]);
222		fval[branch^1<<i] = fc;
223		j = (i+1)%3;
224		v[j] = beg[j] + s;

Diff Legend

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