ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/noise3.c
(Generate patch)

Comparing ray/src/rt/noise3.c (file contents):
Revision 1.5 by greg, Fri May 24 14:23:33 1991 UTC vs.
Revision 2.11 by greg, Fri Sep 3 21:16:50 2010 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  <math.h>
14 +
15 + #include  "calcomp.h"
16 + #include  "func.h"
17 +
18   #define  A              0
19   #define  B              1
20   #define  C              2
# Line 25 | Line 25 | static char SCCSid[] = "$SunId$ LBL";
25   #define  rand3c(x,y,z)  frand(89*(x)+97*(y)+101*(z))
26   #define  rand3d(x,y,z)  frand(103*(x)+107*(y)+109*(z))
27  
28 < #define  hermite(p0,p1,r0,r1,t)  (      p0*((2.0*t-3.0)*t*t+1.0) + \
29 <                                        p1*(-2.0*t+3.0)*t*t + \
30 <                                        r0*((t-2.0)*t+1.0)*t + \
31 <                                        r1*(t-1.0)*t*t )
28 > #define  hpoly1(t)      ((2.0*t-3.0)*t*t+1.0)
29 > #define  hpoly2(t)      (-2.0*t+3.0)*t*t
30 > #define  hpoly3(t)      ((t-2.0)*t+1.0)*t
31 > #define  hpoly4(t)      (t-1.0)*t*t
32  
33 < static char  *noise_name[4] = {"noise3a", "noise3b", "noise3c", "noise3"};
33 > #define  hermite(p0,p1,r0,r1,t)  (      p0*hpoly1(t) + \
34 >                                        p1*hpoly2(t) + \
35 >                                        r0*hpoly3(t) + \
36 >                                        r1*hpoly4(t) )
37 >
38 > static char  noise_name[4][8] = {"noise3x", "noise3y", "noise3z", "noise3"};
39   static char  fnoise_name[] = "fnoise3";
40   static char  hermite_name[] = "hermite";
41  
37 – double  *noise3(), fnoise3(), argument(), frand();
38 –
42   static long  xlim[3][2];
43   static double  xarg[3];
44  
45 < #define  EPSILON        .0001           /* error allowed in fractal */
45 > #define  EPSILON        .001            /* error allowed in fractal */
46  
47   #define  frand3(x,y,z)  frand(17*(x)+23*(y)+29*(z))
48  
49 + static double l_noise3(char  *nam);
50 + static double l_hermite(char *nm);
51 + static double * noise3(double  xnew[3]);
52 + static void interpolate(double  f[4], int  i, int  n);
53 + static double frand(long  s);
54 + static double fnoise3(double  p[3]);
55  
56 +
57   static double
58 < l_noise3(nam)                   /* compute a noise function */
59 < register char  *nam;
58 > l_noise3(                       /* compute a noise function */
59 >        register char  *nam
60 > )
61   {
62          register int  i;
63          double  x[3];
# Line 61 | Line 72 | register char  *nam;
72          while (i--)
73                  if (nam == noise_name[i])
74                          return(noise3(x)[i]);
75 <        eputs("Bad call to l_noise3()!\n");
75 >        eputs(nam);
76 >        eputs(": called l_noise3!\n");
77          quit(1);
78 +        return 1; /* pro forma return */
79   }
80  
81  
82 < double
83 < l_hermite()                     /* library call for hermite interpolation */
82 > static double
83 > l_hermite(char *nm)             /* library call for hermite interpolation */
84   {
85          double  t;
86          
# Line 77 | Line 90 | l_hermite()                    /* library call for hermite interpolatio
90   }
91  
92  
93 < setnoisefuncs()                 /* add noise functions to library */
93 > extern void
94 > setnoisefuncs(void)                     /* add noise functions to library */
95   {
96          register int  i;
97  
# Line 89 | Line 103 | setnoisefuncs()                        /* add noise functions to library */
103   }
104  
105  
106 < double *
107 < noise3(xnew)                    /* compute the noise function */
108 < register double  xnew[3];
106 > static double *
107 > noise3(                 /* compute the noise function */
108 >        register double  xnew[3]
109 > )
110   {
96 –        extern double  floor();
111          static double  x[3] = {-100000.0, -100000.0, -100000.0};
112          static double  f[4];
113  
# Line 111 | Line 125 | register double  xnew[3];
125   }
126  
127  
128 < static
129 < interpolate(f, i, n)
130 < double  f[4];
131 < register int  i, n;
128 > static void
129 > interpolate(
130 >        double  f[4],
131 >        register int  i,
132 >        register int  n
133 > )
134   {
135 <        double  f0[4], f1[4];
135 >        double  f0[4], f1[4], hp1, hp2;
136  
137          if (n == 0) {
138                  f[A] = rand3a(xlim[0][i&1],xlim[1][i>>1&1],xlim[2][i>>2]);
# Line 127 | Line 143 | register int  i, n;
143                  n--;
144                  interpolate(f0, i, n);
145                  interpolate(f1, i | 1<<n, n);
146 <                f[A] = (1.0-xarg[n])*f0[A] + xarg[n]*f1[A];
147 <                f[B] = (1.0-xarg[n])*f0[B] + xarg[n]*f1[B];
148 <                f[C] = (1.0-xarg[n])*f0[C] + xarg[n]*f1[C];
149 <                f[D] = hermite(f0[D], f1[D], f0[n], f1[n], xarg[n]);
146 >                hp1 = hpoly1(xarg[n]); hp2 = hpoly2(xarg[n]);
147 >                f[A] = f0[A]*hp1 + f1[A]*hp2;
148 >                f[B] = f0[B]*hp1 + f1[B]*hp2;
149 >                f[C] = f0[C]*hp1 + f1[C]*hp2;
150 >                f[D] = f0[D]*hp1 + f1[D]*hp2 +
151 >                                f0[n]*hpoly3(xarg[n]) + f1[n]*hpoly4(xarg[n]);
152          }
153   }
154  
155  
156 < double
157 < frand(s)                        /* get random number from seed */
158 < register long  s;
156 > static double
157 > frand(                  /* get random number from seed */
158 >        register long  s
159 > )
160   {
161          s = s<<13 ^ s;
162          return(1.0-((s*(s*s*15731+789221)+1376312589)&0x7fffffff)/1073741824.0);
163   }
164  
165  
166 < double
167 < fnoise3(p)                      /* compute fractal noise function */
168 < double  p[3];
166 > static double
167 > fnoise3(                        /* compute fractal noise function */
168 >        double  p[3]
169 > )
170   {
151 –        double  floor();
171          long  t[3], v[3], beg[3];
172          double  fval[8], fc;
173          int  branch;
# Line 199 | Line 218 | double  p[3];
218                          v[i] = beg[i] + s;
219                  }
220                  for (i = 0; i < 3; i++) {       /* do edges */
221 <                        j = (i+1)%3;
221 >                        if ((j = i+1) == 3) j = 0;
222                          if (branch & 1<<j)
223                                  v[j] += s;
224                          else
225                                  v[j] -= s;
226 <                        j = (i+2)%3;
226 >                        if (++j == 3) j = 0;
227                          if (branch & 1<<j)
228                                  v[j] += s;
229                          else
# Line 213 | Line 232 | double  p[3];
232                          fc += fval[branch | 1<<i];
233                          fc = 0.5*fc + s*EPSILON*frand3(v[0],v[1],v[2]);
234                          fval[branch^1<<i] = fc;
235 <                        j = (i+1)%3;
235 >                        if ((j = i+1) == 3) j = 0;
236                          v[j] = beg[j] + s;
237 <                        j = (i+2)%3;
237 >                        if (++j == 3) j = 0;
238                          v[j] = beg[j] + s;
239                  }
240                  for (i = 0; i < 3; i++)         /* new cube */

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines