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.6 by greg, Sat Feb 22 02:07:29 2003 UTC vs.
Revision 2.12 by greg, Tue Feb 22 16:45:12 2011 UTC

# Line 8 | Line 8 | static const char      RCSid[] = "$Id$";
8   *     (ref. SIGGRAPH Vol 19, No 3, pp 287-96)
9   */
10  
11 < /* ====================================================================
12 < * The Radiance Software License, Version 1.0
13 < *
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 < */
11 > #include "copyright.h"
12  
13 < #include  <math.h>
13 > #include  "ray.h"
14 > #include  "func.h"
15  
16   #define  A              0
17   #define  B              1
# Line 91 | Line 37 | static char  noise_name[4][8] = {"noise3x", "noise3y",
37   static char  fnoise_name[] = "fnoise3";
38   static char  hermite_name[] = "hermite";
39  
94 – double  *noise3(), fnoise3(), argument(), frand();
95 – static  interpolate();
96 –
40   static long  xlim[3][2];
41   static double  xarg[3];
42  
# Line 101 | Line 44 | static double  xarg[3];
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 122 | 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 136 | 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 148 | 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 169 | 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 195 | 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 258 | 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 272 | 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