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.3 by greg, Tue Oct 30 21:03:49 1990 UTC vs.
Revision 2.3 by greg, Mon Mar 8 12:37:25 1993 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 + static  interpolate();
45 +
46   static long  xlim[3][2];
47   static double  xarg[3];
48  
# Line 39 | Line 50 | static double  xarg[3];
50  
51   #define  frand3(x,y,z)  frand(17*(x)+23*(y)+29*(z))
52  
42 – double  fnoise3();
53  
54 <
55 < double
56 < l_noise3()                      /* compute 3-dimensional noise function */
54 > static double
55 > l_noise3(nam)                   /* compute a noise function */
56 > register char  *nam;
57   {
58 <        return(noise3coef(D));
58 >        register int  i;
59 >        double  x[3];
60 >                                        /* get point */
61 >        x[0] = argument(1);
62 >        x[1] = argument(2);
63 >        x[2] = argument(3);
64 >                                        /* make appropriate call */
65 >        if (nam == fnoise_name)
66 >                return(fnoise3(x));
67 >        i = 4;
68 >        while (i--)
69 >                if (nam == noise_name[i])
70 >                        return(noise3(x)[i]);
71 >        eputs(nam);
72 >        eputs(": called l_noise3!\n");
73 >        quit(1);
74   }
75  
76  
77   double
78 < l_noise3a()                     /* compute x slope of noise function */
78 > l_hermite()                     /* library call for hermite interpolation */
79   {
80 <        return(noise3coef(A));
80 >        double  t;
81 >        
82 >        t = argument(5);
83 >        return( hermite(argument(1), argument(2),
84 >                        argument(3), argument(4), t) );
85   }
86  
87  
88 < double
60 < l_noise3b()                     /* compute y slope of noise function */
88 > setnoisefuncs()                 /* add noise functions to library */
89   {
90 <        return(noise3coef(B));
63 < }
90 >        register int  i;
91  
92 <
93 < double
94 < l_noise3c()                     /* compute z slope of noise function */
95 < {
96 <        return(noise3coef(C));
92 >        funset(hermite_name, 5, ':', l_hermite);
93 >        funset(fnoise_name, 3, ':', l_noise3);
94 >        i = 4;
95 >        while (i--)
96 >                funset(noise_name[i], 3, ':', l_noise3);
97   }
98  
99  
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 –
100   double *
101   noise3(xnew)                    /* compute the noise function */
102   register double  xnew[3];
103   {
104 –        extern double  floor();
104          static double  x[3] = {-100000.0, -100000.0, -100000.0};
105          static double  f[4];
106  
# Line 124 | Line 123 | interpolate(f, i, n)
123   double  f[4];
124   register int  i, n;
125   {
126 <        double  f0[4], f1[4];
126 >        double  f0[4], f1[4], hp1, hp2;
127  
128          if (n == 0) {
129                  f[A] = rand3a(xlim[0][i&1],xlim[1][i>>1&1],xlim[2][i>>2]);
# Line 135 | Line 134 | register int  i, n;
134                  n--;
135                  interpolate(f0, i, n);
136                  interpolate(f1, i | 1<<n, n);
137 <                f[A] = (1.0-xarg[n])*f0[A] + xarg[n]*f1[A];
138 <                f[B] = (1.0-xarg[n])*f0[B] + xarg[n]*f1[B];
139 <                f[C] = (1.0-xarg[n])*f0[C] + xarg[n]*f1[C];
140 <                f[D] = hermite(f0[D], f1[D], f0[n], f1[n], xarg[n]);
137 >                hp1 = hpoly1(xarg[n]); hp2 = hpoly2(xarg[n]);
138 >                f[A] = f0[A]*hp1 + f1[A]*hp2;
139 >                f[B] = f0[B]*hp1 + f1[B]*hp2;
140 >                f[C] = f0[C]*hp1 + f1[C]*hp2;
141 >                f[D] = f0[D]*hp1 + f1[D]*hp2 +
142 >                                f0[n]*hpoly3(xarg[n]) + f1[n]*hpoly4(xarg[n]);
143          }
144   }
145  
# Line 153 | Line 154 | register long  s;
154  
155  
156   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
157   fnoise3(p)                      /* compute fractal noise function */
158   double  p[3];
159   {
160 <        double  floor();
171 <        long  t[3], v[3], beg[3], s;
160 >        long  t[3], v[3], beg[3];
161          double  fval[8], fc;
162          int  branch;
163 +        register long  s;
164          register int  i, j;
165                                                  /* get starting cube */
166          s = (long)(1.0/EPSILON);
# Line 188 | Line 178 | double  p[3];
178          }
179                                                  /* compute fractal */
180          for ( ; ; ) {
181 <                s >>= 1;
181 >                fc = 0.0;
182 >                for (j = 0; j < 8; j++)
183 >                        fc += fval[j];
184 >                fc *= 0.125;
185 >                if ((s >>= 1) == 0)
186 >                        return(fc);             /* close enough */
187                  branch = 0;
188                  for (i = 0; i < 3; i++) {       /* do center */
189                          v[i] = beg[i] + s;
# Line 196 | Line 191 | double  p[3];
191                                  branch |= 1<<i;
192                          }
193                  }
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 */
194                  fc += s*EPSILON*frand3(v[0],v[1],v[2]);
195                  fval[~branch & 7] = fc;
196                  for (i = 0; i < 3; i++) {       /* do faces */

Diff Legend

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