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.6 by greg, Sat Feb 22 02:07:29 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)
9 + */
10 +
11 + /* ====================================================================
12 + * The Radiance Software License, Version 1.0
13   *
14 < *     4/15/86
15 < *     5/19/88  Added fractal noise function
14 > * Copyright (c) 1990 - 2002 The Regents of the University of California,
15 > * through Lawrence Berkeley National Laboratory.   All rights reserved.
16 > *
17 > * Redistribution and use in source and binary forms, with or without
18 > * modification, are permitted provided that the following conditions
19 > * are met:
20 > *
21 > * 1. Redistributions of source code must retain the above copyright
22 > *         notice, this list of conditions and the following disclaimer.
23 > *
24 > * 2. Redistributions in binary form must reproduce the above copyright
25 > *       notice, this list of conditions and the following disclaimer in
26 > *       the documentation and/or other materials provided with the
27 > *       distribution.
28 > *
29 > * 3. The end-user documentation included with the redistribution,
30 > *           if any, must include the following acknowledgment:
31 > *             "This product includes Radiance software
32 > *                 (http://radsite.lbl.gov/)
33 > *                 developed by the Lawrence Berkeley National Laboratory
34 > *               (http://www.lbl.gov/)."
35 > *       Alternately, this acknowledgment may appear in the software itself,
36 > *       if and wherever such third-party acknowledgments normally appear.
37 > *
38 > * 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
39 > *       and "The Regents of the University of California" must
40 > *       not be used to endorse or promote products derived from this
41 > *       software without prior written permission. For written
42 > *       permission, please contact [email protected].
43 > *
44 > * 5. Products derived from this software may not be called "Radiance",
45 > *       nor may "Radiance" appear in their name, without prior written
46 > *       permission of Lawrence Berkeley National Laboratory.
47 > *
48 > * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
49 > * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
50 > * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
51 > * DISCLAIMED.   IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
52 > * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
53 > * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
54 > * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
55 > * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
56 > * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
57 > * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
58 > * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59 > * SUCH DAMAGE.
60 > * ====================================================================
61 > *
62 > * This software consists of voluntary contributions made by many
63 > * individuals on behalf of Lawrence Berkeley National Laboratory.   For more
64 > * information on Lawrence Berkeley National Laboratory, please see
65 > * <http://www.lbl.gov/>.
66   */
67  
68 + #include  <math.h>
69  
70   #define  A              0
71   #define  B              1
# Line 25 | Line 77 | static char SCCSid[] = "$SunId$ LBL";
77   #define  rand3c(x,y,z)  frand(89*(x)+97*(y)+101*(z))
78   #define  rand3d(x,y,z)  frand(103*(x)+107*(y)+109*(z))
79  
80 < #define  hermite(p0,p1,r0,r1,t)  (      p0*((2.0*t-3.0)*t*t+1.0) + \
81 <                                        p1*(-2.0*t+3.0)*t*t + \
82 <                                        r0*((t-2.0)*t+1.0)*t + \
83 <                                        r1*(t-1.0)*t*t )
80 > #define  hpoly1(t)      ((2.0*t-3.0)*t*t+1.0)
81 > #define  hpoly2(t)      (-2.0*t+3.0)*t*t
82 > #define  hpoly3(t)      ((t-2.0)*t+1.0)*t
83 > #define  hpoly4(t)      (t-1.0)*t*t
84  
85 < double  *noise3(), noise3coef(), argument(), frand();
85 > #define  hermite(p0,p1,r0,r1,t)  (      p0*hpoly1(t) + \
86 >                                        p1*hpoly2(t) + \
87 >                                        r0*hpoly3(t) + \
88 >                                        r1*hpoly4(t) )
89  
90 + static char  noise_name[4][8] = {"noise3x", "noise3y", "noise3z", "noise3"};
91 + static char  fnoise_name[] = "fnoise3";
92 + static char  hermite_name[] = "hermite";
93 +
94 + double  *noise3(), fnoise3(), argument(), frand();
95 + static  interpolate();
96 +
97   static long  xlim[3][2];
98   static double  xarg[3];
99  
100 < #define  EPSILON        .0001           /* error allowed in fractal */
100 > #define  EPSILON        .001            /* error allowed in fractal */
101  
102   #define  frand3(x,y,z)  frand(17*(x)+23*(y)+29*(z))
103  
42 – double  fnoise3();
104  
105 <
106 < double
107 < l_noise3()                      /* compute 3-dimensional noise function */
105 > static double
106 > l_noise3(nam)                   /* compute a noise function */
107 > register char  *nam;
108   {
109 <        return(noise3coef(D));
109 >        register int  i;
110 >        double  x[3];
111 >                                        /* get point */
112 >        x[0] = argument(1);
113 >        x[1] = argument(2);
114 >        x[2] = argument(3);
115 >                                        /* make appropriate call */
116 >        if (nam == fnoise_name)
117 >                return(fnoise3(x));
118 >        i = 4;
119 >        while (i--)
120 >                if (nam == noise_name[i])
121 >                        return(noise3(x)[i]);
122 >        eputs(nam);
123 >        eputs(": called l_noise3!\n");
124 >        quit(1);
125   }
126  
127  
128   double
129 < l_noise3a()                     /* compute x slope of noise function */
129 > l_hermite()                     /* library call for hermite interpolation */
130   {
131 <        return(noise3coef(A));
131 >        double  t;
132 >        
133 >        t = argument(5);
134 >        return( hermite(argument(1), argument(2),
135 >                        argument(3), argument(4), t) );
136   }
137  
138  
139 < double
60 < l_noise3b()                     /* compute y slope of noise function */
139 > setnoisefuncs()                 /* add noise functions to library */
140   {
141 <        return(noise3coef(B));
63 < }
141 >        register int  i;
142  
143 <
144 < double
145 < l_noise3c()                     /* compute z slope of noise function */
146 < {
147 <        return(noise3coef(C));
143 >        funset(hermite_name, 5, ':', l_hermite);
144 >        funset(fnoise_name, 3, ':', l_noise3);
145 >        i = 4;
146 >        while (i--)
147 >                funset(noise_name[i], 3, ':', l_noise3);
148   }
149  
150  
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 –
151   double *
152   noise3(xnew)                    /* compute the noise function */
153   register double  xnew[3];
154   {
104 –        extern double  floor();
155          static double  x[3] = {-100000.0, -100000.0, -100000.0};
156          static double  f[4];
157  
# Line 124 | Line 174 | interpolate(f, i, n)
174   double  f[4];
175   register int  i, n;
176   {
177 <        double  f0[4], f1[4];
177 >        double  f0[4], f1[4], hp1, hp2;
178  
179          if (n == 0) {
180                  f[A] = rand3a(xlim[0][i&1],xlim[1][i>>1&1],xlim[2][i>>2]);
# Line 135 | Line 185 | register int  i, n;
185                  n--;
186                  interpolate(f0, i, n);
187                  interpolate(f1, i | 1<<n, n);
188 <                f[A] = (1.0-xarg[n])*f0[A] + xarg[n]*f1[A];
189 <                f[B] = (1.0-xarg[n])*f0[B] + xarg[n]*f1[B];
190 <                f[C] = (1.0-xarg[n])*f0[C] + xarg[n]*f1[C];
191 <                f[D] = hermite(f0[D], f1[D], f0[n], f1[n], xarg[n]);
188 >                hp1 = hpoly1(xarg[n]); hp2 = hpoly2(xarg[n]);
189 >                f[A] = f0[A]*hp1 + f1[A]*hp2;
190 >                f[B] = f0[B]*hp1 + f1[B]*hp2;
191 >                f[C] = f0[C]*hp1 + f1[C]*hp2;
192 >                f[D] = f0[D]*hp1 + f1[D]*hp2 +
193 >                                f0[n]*hpoly3(xarg[n]) + f1[n]*hpoly4(xarg[n]);
194          }
195   }
196  
# Line 153 | Line 205 | register long  s;
205  
206  
207   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
208   fnoise3(p)                      /* compute fractal noise function */
209   double  p[3];
210   {
211 <        double  floor();
171 <        long  t[3], v[3], beg[3], s;
211 >        long  t[3], v[3], beg[3];
212          double  fval[8], fc;
213          int  branch;
214 +        register long  s;
215          register int  i, j;
216                                                  /* get starting cube */
217          s = (long)(1.0/EPSILON);
# Line 188 | Line 229 | double  p[3];
229          }
230                                                  /* compute fractal */
231          for ( ; ; ) {
232 <                s >>= 1;
232 >                fc = 0.0;
233 >                for (j = 0; j < 8; j++)
234 >                        fc += fval[j];
235 >                fc *= 0.125;
236 >                if ((s >>= 1) == 0)
237 >                        return(fc);             /* close enough */
238                  branch = 0;
239                  for (i = 0; i < 3; i++) {       /* do center */
240                          v[i] = beg[i] + s;
# Line 196 | Line 242 | double  p[3];
242                                  branch |= 1<<i;
243                          }
244                  }
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 */
245                  fc += s*EPSILON*frand3(v[0],v[1],v[2]);
246                  fval[~branch & 7] = fc;
247                  for (i = 0; i < 3; i++) {       /* do faces */

Diff Legend

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