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

Diff Legend

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