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 2.2 by greg, Fri Oct 2 16:18:50 1992 UTC vs.
Revision 2.12 by greg, Tue Feb 22 16:45:12 2011 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  <math.h>
11 > #include "copyright.h"
12  
13 + #include  "ray.h"
14 + #include  "func.h"
15 +
16   #define  A              0
17   #define  B              1
18   #define  C              2
# Line 36 | Line 33 | static char SCCSid[] = "$SunId$ LBL";
33                                          r0*hpoly3(t) + \
34                                          r1*hpoly4(t) )
35  
36 < static char  noise_name[4][8] = {"noise3a", "noise3b", "noise3c", "noise3"};
36 > static char  noise_name[4][8] = {"noise3x", "noise3y", "noise3z", "noise3"};
37   static char  fnoise_name[] = "fnoise3";
38   static char  hermite_name[] = "hermite";
39  
43 – double  *noise3(), fnoise3(), argument(), frand();
44 –
40   static long  xlim[3][2];
41   static double  xarg[3];
42  
43 < #define  EPSILON        .0001           /* error allowed in fractal */
43 > #define  EPSILON        .001            /* error allowed in fractal */
44  
45   #define  frand3(x,y,z)  frand(17*(x)+23*(y)+29*(z))
46  
47 + static double l_noise3(char  *nam);
48 + static double l_hermite(char *nm);
49 + static double * noise3(double  xnew[3]);
50 + static void interpolate(double  f[4], int  i, int  n);
51 + static double frand(long  s);
52 + static double fnoise3(double  p[3]);
53  
54 +
55   static double
56 < l_noise3(nam)                   /* compute a noise function */
57 < register char  *nam;
56 > l_noise3(                       /* compute a noise function */
57 >        register char  *nam
58 > )
59   {
60          register int  i;
61          double  x[3];
# Line 70 | Line 73 | register char  *nam;
73          eputs(nam);
74          eputs(": called l_noise3!\n");
75          quit(1);
76 +        return 1; /* pro forma return */
77   }
78  
79  
80 < double
81 < l_hermite()                     /* library call for hermite interpolation */
80 > static double
81 > l_hermite(char *nm)             /* library call for hermite interpolation */
82   {
83          double  t;
84          
# Line 84 | Line 88 | l_hermite()                    /* library call for hermite interpolatio
88   }
89  
90  
91 < setnoisefuncs()                 /* add noise functions to library */
91 > extern void
92 > setnoisefuncs(void)                     /* add noise functions to library */
93   {
94          register int  i;
95  
# Line 96 | Line 101 | setnoisefuncs()                        /* add noise functions to library */
101   }
102  
103  
104 < double *
105 < noise3(xnew)                    /* compute the noise function */
106 < register double  xnew[3];
104 > static double *
105 > noise3(                 /* compute the noise function */
106 >        register double  xnew[3]
107 > )
108   {
109          static double  x[3] = {-100000.0, -100000.0, -100000.0};
110          static double  f[4];
# Line 117 | Line 123 | register double  xnew[3];
123   }
124  
125  
126 < static
127 < interpolate(f, i, n)
128 < double  f[4];
129 < register int  i, n;
126 > static void
127 > interpolate(
128 >        double  f[4],
129 >        register int  i,
130 >        register int  n
131 > )
132   {
133          double  f0[4], f1[4], hp1, hp2;
134  
# Line 143 | Line 151 | register int  i, n;
151   }
152  
153  
154 < double
155 < frand(s)                        /* get random number from seed */
156 < register long  s;
154 > static double
155 > frand(                  /* get random number from seed */
156 >        register long  s
157 > )
158   {
159          s = s<<13 ^ s;
160          return(1.0-((s*(s*s*15731+789221)+1376312589)&0x7fffffff)/1073741824.0);
161   }
162  
163  
164 < double
165 < fnoise3(p)                      /* compute fractal noise function */
166 < double  p[3];
164 > static double
165 > fnoise3(                        /* compute fractal noise function */
166 >        double  p[3]
167 > )
168   {
169          long  t[3], v[3], beg[3];
170          double  fval[8], fc;
# Line 206 | Line 216 | double  p[3];
216                          v[i] = beg[i] + s;
217                  }
218                  for (i = 0; i < 3; i++) {       /* do edges */
219 <                        j = (i+1)%3;
219 >                        if ((j = i+1) == 3) j = 0;
220                          if (branch & 1<<j)
221                                  v[j] += s;
222                          else
223                                  v[j] -= s;
224 <                        j = (i+2)%3;
224 >                        if (++j == 3) j = 0;
225                          if (branch & 1<<j)
226                                  v[j] += s;
227                          else
# Line 220 | Line 230 | double  p[3];
230                          fc += fval[branch | 1<<i];
231                          fc = 0.5*fc + s*EPSILON*frand3(v[0],v[1],v[2]);
232                          fval[branch^1<<i] = fc;
233 <                        j = (i+1)%3;
233 >                        if ((j = i+1) == 3) j = 0;
234                          v[j] = beg[j] + s;
235 <                        j = (i+2)%3;
235 >                        if (++j == 3) j = 0;
236                          v[j] = beg[j] + s;
237                  }
238                  for (i = 0; i < 3; i++)         /* new cube */

Diff Legend

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