a9bbc016a54f1faf4fe3fa342d83bfbf7647795e
[blender.git] / source / blender / python / generic / noise.c
1 /**
2  * $Id$
3  *
4  * Blender.Noise BPython module implementation.
5  * This submodule has functions to generate noise of various types.
6  * 
7  * ***** BEGIN GPL LICENSE BLOCK *****
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License
11  * as published by the Free Software Foundation; either version 2
12  * of the License, or (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
22  *
23  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
24  * All rights reserved.
25  *
26  * This is a new part of Blender.
27  *
28  * Contributor(s): eeshlo
29  *
30  * ***** END GPL LICENSE BLOCK *****
31 */
32
33 /************************/
34 /* Blender Noise Module */
35 /************************/
36
37 #include <Python.h>
38 #include "structseq.h"
39
40 #include "BLI_blenlib.h"
41 #include "DNA_texture_types.h"
42
43 #include "BKE_utildefines.h"
44 /*-----------------------------------------*/
45 /* 'mersenne twister' random number generator */
46
47 /* 
48    A C-program for MT19937, with initialization improved 2002/2/10.
49    Coded by Takuji Nishimura and Makoto Matsumoto.
50    This is a faster version by taking Shawn Cokus's optimization,
51    Matthe Bellew's simplification, Isaku Wada's real version.
52
53    Before using, initialize the state by using init_genrand(seed) 
54    or init_by_array(init_key, key_length).
55
56    Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
57    All rights reserved.                          
58
59    Redistribution and use in source and binary forms, with or without
60    modification, are permitted provided that the following conditions
61    are met:
62
63      1. Redistributions of source code must retain the above copyright
64         notice, this list of conditions and the following disclaimer.
65
66      2. Redistributions in binary form must reproduce the above copyright
67         notice, this list of conditions and the following disclaimer in the
68         documentation and/or other materials provided with the distribution.
69
70      3. The names of its contributors may not be used to endorse or promote 
71         products derived from this software without specific prior written 
72         permission.
73
74    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
75    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
76    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
77    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
78    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
79    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
80    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
81    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
82    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
83    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
84    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
85
86
87    Any feedback is very welcome.
88    http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
89    email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
90 */
91
92 /* 2.5 update
93  * Noise.setRandomSeed --> seed_set
94  * Noise.randuvec --> random_unit_vector
95  * Noise.vNoise --> noise_vector
96  * Noise.vTurbulence --> turbulence_vector
97  * Noise.multiFractal --> multi_fractal
98  * Noise.cellNoise --> cell
99  * Noise.cellNoiseV --> cell_vector
100  * Noise.vlNoise --> vl_vector
101  * Noise.heteroTerrain --> hetero_terrain
102  * Noise.hybridMFractal --> hybrid_multi_fractal
103  * Noise.fBm --> fractal
104  * Noise.ridgedMFractal --> ridged_multi_fractal
105  *
106  * Const's *
107  * Noise.NoiseTypes --> types
108  * Noise.DistanceMetrics --> distance_metrics
109  */
110
111 /* Period parameters */
112 #define N 624
113 #define M 397
114 #define MATRIX_A 0x9908b0dfUL   /* constant vector a */
115 #define UMASK 0x80000000UL      /* most significant w-r bits */
116 #define LMASK 0x7fffffffUL      /* least significant r bits */
117 #define MIXBITS(u,v) (((u) & UMASK) | ((v) & LMASK))
118 #define TWIST(u,v) ((MIXBITS(u,v) >> 1) ^ ((v)&1UL ? MATRIX_A : 0UL))
119
120 static unsigned long state[N];  /* the array for the state vector  */
121 static int left = 1;
122 static int initf = 0;
123 static unsigned long *next;
124
125 PyObject *Noise_Init(void);
126
127 /* initializes state[N] with a seed */
128 static void init_genrand(unsigned long s)
129 {
130         int j;
131         state[0] = s & 0xffffffffUL;
132         for(j = 1; j < N; j++) {
133                 state[j] =
134                         (1812433253UL *
135                           (state[j - 1] ^ (state[j - 1] >> 30)) + j);
136                 /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
137                 /* In the previous versions, MSBs of the seed affect   */
138                 /* only MSBs of the array state[].                        */
139                 /* 2002/01/09 modified by Makoto Matsumoto             */
140                 state[j] &= 0xffffffffUL;       /* for >32 bit machines */
141         }
142         left = 1;
143         initf = 1;
144 }
145
146 static void next_state(void)
147 {
148         unsigned long *p = state;
149         int j;
150
151         /* if init_genrand() has not been called, */
152         /* a default initial seed is used         */
153         if(initf == 0)
154                 init_genrand(5489UL);
155
156         left = N;
157         next = state;
158
159         for(j = N - M + 1; --j; p++)
160                 *p = p[M] ^ TWIST(p[0], p[1]);
161
162         for(j = M; --j; p++)
163                 *p = p[M - N] ^ TWIST(p[0], p[1]);
164
165         *p = p[M - N] ^ TWIST(p[0], state[0]);
166 }
167
168 /*------------------------------------------------------------*/
169
170 static void setRndSeed(int seed)
171 {
172         if(seed == 0)
173                 init_genrand(time(NULL));
174         else
175                 init_genrand(seed);
176 }
177
178 /* float number in range [0, 1) using the mersenne twister rng */
179 static float frand()
180 {
181         unsigned long y;
182
183         if(--left == 0)
184                 next_state();
185         y = *next++;
186
187         /* Tempering */
188         y ^= (y >> 11);
189         y ^= (y << 7) & 0x9d2c5680UL;
190         y ^= (y << 15) & 0xefc60000UL;
191         y ^= (y >> 18);
192
193         return (float) y / 4294967296.f;
194 }
195
196 /*------------------------------------------------------------*/
197
198 /* returns random unit vector */
199 static void randuvec(float v[3])
200 {
201         float r;
202         v[2] = 2.f * frand() - 1.f;
203         if((r = 1.f - v[2] * v[2]) > 0.f) {
204                 float a = (float)(6.283185307f * frand());
205                 r = (float)sqrt(r);
206                 v[0] = (float)(r * cos(a));
207                 v[1] = (float)(r * sin(a));
208         } else
209                 v[2] = 1.f;
210 }
211
212 static PyObject *Noise_random(PyObject *UNUSED(self))
213 {
214         return PyFloat_FromDouble(frand());
215 }
216
217 static PyObject *Noise_random_unit_vector(PyObject *UNUSED(self))
218 {
219         float v[3] = {0.0f, 0.0f, 0.0f};
220         randuvec(v);
221         return Py_BuildValue("[fff]", v[0], v[1], v[2]);
222 }
223
224 /*---------------------------------------------------------------------*/
225
226 /* Random seed init. Only used for MT random() & randuvec() */
227
228 static PyObject *Noise_seed_set(PyObject *UNUSED(self), PyObject *args)
229 {
230         int s;
231         if(!PyArg_ParseTuple(args, "i:seed_set", &s))
232                 return NULL;
233         setRndSeed(s);
234         Py_RETURN_NONE;
235 }
236
237 /*-------------------------------------------------------------------------*/
238
239 /* General noise */
240
241 static PyObject *Noise_noise(PyObject *UNUSED(self), PyObject *args)
242 {
243         float x, y, z;
244         int nb = 1;
245         if(!PyArg_ParseTuple(args, "(fff)|i:noise", &x, &y, &z, &nb))
246                 return NULL;
247
248         return PyFloat_FromDouble((2.0 * BLI_gNoise(1.0, x, y, z, 0, nb) - 1.0));
249 }
250
251 /*-------------------------------------------------------------------------*/
252
253 /* General Vector noise */
254
255 static void noise_vector(float x, float y, float z, int nb, float v[3])
256 {
257         /* Simply evaluate noise at 3 different positions */
258         v[0] = (float)(2.0 * BLI_gNoise(1.f, x + 9.321f, y - 1.531f, z - 7.951f, 0,
259                                  nb) - 1.0);
260         v[1] = (float)(2.0 * BLI_gNoise(1.f, x, y, z, 0, nb) - 1.0);
261         v[2] = (float)(2.0 * BLI_gNoise(1.f, x + 6.327f, y + 0.1671f, z - 2.672f, 0,
262                                  nb) - 1.0);
263 }
264
265 static PyObject *Noise_vector(PyObject *UNUSED(self), PyObject *args)
266 {
267         float x, y, z, v[3];
268         int nb = 1;
269         if(!PyArg_ParseTuple(args, "(fff)|i:vector", &x, &y, &z, &nb))
270                 return NULL;
271         noise_vector(x, y, z, nb, v);
272         return Py_BuildValue("[fff]", v[0], v[1], v[2]);
273 }
274
275 /*---------------------------------------------------------------------------*/
276
277 /* General turbulence */
278
279 static float turb(float x, float y, float z, int oct, int hard, int nb,
280                    float ampscale, float freqscale)
281 {
282         float amp, out, t;
283         int i;
284         amp = 1.f;
285         out = (float)(2.0 * BLI_gNoise(1.f, x, y, z, 0, nb) - 1.0);
286         if(hard)
287                 out = (float)fabs(out);
288         for(i = 1; i < oct; i++) {
289                 amp *= ampscale;
290                 x *= freqscale;
291                 y *= freqscale;
292                 z *= freqscale;
293                 t = (float)(amp * (2.0 * BLI_gNoise(1.f, x, y, z, 0, nb) - 1.0));
294                 if(hard)
295                         t = (float)fabs(t);
296                 out += t;
297         }
298         return out;
299 }
300
301 static PyObject *Noise_turbulence(PyObject *UNUSED(self), PyObject *args)
302 {
303         float x, y, z;
304         int oct, hd, nb = 1;
305         float as = 0.5, fs = 2.0;
306         if(!PyArg_ParseTuple(args, "(fff)ii|iff:turbulence", &x, &y, &z, &oct, &hd, &nb, &as, &fs))
307                 return NULL;
308
309         return PyFloat_FromDouble(turb(x, y, z, oct, hd, nb, as, fs));
310 }
311
312 /*--------------------------------------------------------------------------*/
313
314 /* Turbulence Vector */
315
316 static void vTurb(float x, float y, float z, int oct, int hard, int nb,
317                    float ampscale, float freqscale, float v[3])
318 {
319         float amp, t[3];
320         int i;
321         amp = 1.f;
322         noise_vector(x, y, z, nb, v);
323         if(hard) {
324                 v[0] = (float)fabs(v[0]);
325                 v[1] = (float)fabs(v[1]);
326                 v[2] = (float)fabs(v[2]);
327         }
328         for(i = 1; i < oct; i++) {
329                 amp *= ampscale;
330                 x *= freqscale;
331                 y *= freqscale;
332                 z *= freqscale;
333                 noise_vector(x, y, z, nb, t);
334                 if(hard) {
335                         t[0] = (float)fabs(t[0]);
336                         t[1] = (float)fabs(t[1]);
337                         t[2] = (float)fabs(t[2]);
338                 }
339                 v[0] += amp * t[0];
340                 v[1] += amp * t[1];
341                 v[2] += amp * t[2];
342         }
343 }
344
345 static PyObject *Noise_turbulence_vector(PyObject *UNUSED(self), PyObject *args)
346 {
347         float x, y, z, v[3];
348         int oct, hd, nb = 1;
349         float as = 0.5, fs = 2.0;
350         if(!PyArg_ParseTuple(args, "(fff)ii|iff:turbulence_vector", &x, &y, &z, &oct, &hd, &nb, &as, &fs))
351                 return NULL;
352         vTurb(x, y, z, oct, hd, nb, as, fs, v);
353         return Py_BuildValue("[fff]", v[0], v[1], v[2]);
354 }
355
356 /*---------------------------------------------------------------------*/
357
358 /* F. Kenton Musgrave's fractal functions */
359
360 static PyObject *Noise_fractal(PyObject *UNUSED(self), PyObject *args)
361 {
362         float x, y, z, H, lac, oct;
363         int nb = 1;
364         if(!PyArg_ParseTuple(args, "(fff)fff|i:fractal", &x, &y, &z, &H, &lac, &oct, &nb))
365                 return NULL;
366         return PyFloat_FromDouble(mg_fBm(x, y, z, H, lac, oct, nb));
367 }
368
369 /*------------------------------------------------------------------------*/
370
371 static PyObject *Noise_multi_fractal(PyObject *UNUSED(self), PyObject *args)
372 {
373         float x, y, z, H, lac, oct;
374         int nb = 1;
375         if(!PyArg_ParseTuple(args, "(fff)fff|i:multi_fractal", &x, &y, &z, &H, &lac, &oct, &nb))
376                 return NULL;
377
378         return PyFloat_FromDouble(mg_MultiFractal(x, y, z, H, lac, oct, nb));
379 }
380
381 /*------------------------------------------------------------------------*/
382
383 static PyObject *Noise_vl_vector(PyObject *UNUSED(self), PyObject *args)
384 {
385         float x, y, z, d;
386         int nt1 = 1, nt2 = 1;
387         if(!PyArg_ParseTuple(args, "(fff)f|ii:vl_vector", &x, &y, &z, &d, &nt1, &nt2))
388                 return NULL;
389         return PyFloat_FromDouble(mg_VLNoise(x, y, z, d, nt1, nt2));
390 }
391
392 /*-------------------------------------------------------------------------*/
393
394 static PyObject *Noise_hetero_terrain(PyObject *UNUSED(self), PyObject *args)
395 {
396         float x, y, z, H, lac, oct, ofs;
397         int nb = 1;
398         if(!PyArg_ParseTuple(args, "(fff)ffff|i:hetero_terrain", &x, &y, &z, &H, &lac, &oct, &ofs, &nb))
399                 return NULL;
400
401         return PyFloat_FromDouble(mg_HeteroTerrain(x, y, z, H, lac, oct, ofs, nb));
402 }
403
404 /*-------------------------------------------------------------------------*/
405
406 static PyObject *Noise_hybrid_multi_fractal(PyObject *UNUSED(self), PyObject *args)
407 {
408         float x, y, z, H, lac, oct, ofs, gn;
409         int nb = 1;
410         if(!PyArg_ParseTuple(args, "(fff)fffff|i:hybrid_multi_fractal", &x, &y, &z, &H, &lac, &oct, &ofs, &gn, &nb))
411                 return NULL;
412         
413         return PyFloat_FromDouble(mg_HybridMultiFractal(x, y, z, H, lac, oct, ofs, gn, nb));
414 }
415
416 /*------------------------------------------------------------------------*/
417
418 static PyObject *Noise_ridged_multi_fractal(PyObject *UNUSED(self), PyObject *args)
419 {
420         float x, y, z, H, lac, oct, ofs, gn;
421         int nb = 1;
422         if(!PyArg_ParseTuple(args, "(fff)fffff|i:ridged_multi_fractal", &x, &y, &z, &H, &lac, &oct, &ofs, &gn, &nb))
423                 return NULL;
424         return PyFloat_FromDouble(mg_RidgedMultiFractal(x, y, z, H, lac, oct, ofs, gn, nb));
425 }
426
427 /*-------------------------------------------------------------------------*/
428
429 static PyObject *Noise_voronoi(PyObject *UNUSED(self), PyObject *args)
430 {
431         float x, y, z, da[4], pa[12];
432         int dtype = 0;
433         float me = 2.5;         /* default minkovsky exponent */
434         if(!PyArg_ParseTuple(args, "(fff)|if:voronoi", &x, &y, &z, &dtype, &me))
435                 return NULL;
436         voronoi(x, y, z, da, pa, me, dtype);
437         return Py_BuildValue("[[ffff][[fff][fff][fff][fff]]]",
438                               da[0], da[1], da[2], da[3],
439                               pa[0], pa[1], pa[2],
440                               pa[3], pa[4], pa[5],
441                               pa[6], pa[7], pa[8], pa[9], pa[10], pa[11]);
442 }
443
444 /*-------------------------------------------------------------------------*/
445
446 static PyObject *Noise_cell(PyObject *UNUSED(self), PyObject *args)
447 {
448         float x, y, z;
449         if(!PyArg_ParseTuple(args, "(fff):cell", &x, &y, &z))
450                 return NULL;
451
452         return PyFloat_FromDouble(cellNoise(x, y, z));
453 }
454
455 /*--------------------------------------------------------------------------*/
456
457 static PyObject *Noise_cell_vector(PyObject *UNUSED(self), PyObject *args)
458 {
459         float x, y, z, ca[3];
460         if(!PyArg_ParseTuple(args, "(fff):cell_vector", &x, &y, &z))
461                 return NULL;
462         cellNoiseV(x, y, z, ca);
463         return Py_BuildValue("[fff]", ca[0], ca[1], ca[2]);
464 }
465
466 /*--------------------------------------------------------------------------*/
467 /* For all other Blender modules, this stuff seems to be put in a header file.
468    This doesn't seem really appropriate to me, so I just put it here, feel free to change it.
469    In the original module I actually kept the docs stings with the functions themselves,
470    but I grouped them here so that it can easily be moved to a header if anyone thinks that is necessary. */
471
472 static char random__doc__[] = "() No arguments.\n\n\
473 Returns a random floating point number in the range [0, 1)";
474
475 static char random_unit_vector__doc__[] =
476         "() No arguments.\n\nReturns a random unit vector (3-float list).";
477
478 static char seed_set__doc__[] = "(seed value)\n\n\
479 Initializes random number generator.\n\
480 if seed is zero, the current time will be used instead.";
481
482 static char noise__doc__[] = "((x,y,z) tuple, [noisetype])\n\n\
483 Returns general noise of the optional specified type.\n\
484 Optional argument noisetype determines the type of noise, STDPERLIN by default, see NoiseTypes.";
485
486 static char noise_vector__doc__[] = "((x,y,z) tuple, [noisetype])\n\n\
487 Returns noise vector (3-float list) of the optional specified type.\
488 Optional argument noisetype determines the type of noise, STDPERLIN by default, see NoiseTypes.";
489
490 static char turbulence__doc__[] =
491         "((x,y,z) tuple, octaves, hard, [noisebasis], [ampscale], [freqscale])\n\n\
492 Returns general turbulence value using the optional specified noisebasis function.\n\
493 octaves (integer) is the number of noise values added.\n\
494 hard (bool), when false (0) returns 'soft' noise, when true (1) returns 'hard' noise (returned value always positive).\n\
495 Optional arguments:\n\
496 noisebasis determines the type of noise used for the turbulence, STDPERLIN by default, see NoiseTypes.\n\
497 ampscale sets the amplitude scale value of the noise frequencies added, 0.5 by default.\n\
498 freqscale sets the frequency scale factor, 2.0 by default.";
499
500 static char turbulence_vector__doc__[] =
501         "((x,y,z) tuple, octaves, hard, [noisebasis], [ampscale], [freqscale])\n\n\
502 Returns general turbulence vector (3-float list) using the optional specified noisebasis function.\n\
503 octaves (integer) is the number of noise values added.\n\
504 hard (bool), when false (0) returns 'soft' noise, when true (1) returns 'hard' noise (returned vector always positive).\n\
505 Optional arguments:\n\
506 noisebasis determines the type of noise used for the turbulence, STDPERLIN by default, see NoiseTypes.\n\
507 ampscale sets the amplitude scale value of the noise frequencies added, 0.5 by default.\n\
508 freqscale sets the frequency scale factor, 2.0 by default.";
509
510 static char fractal__doc__[] =
511         "((x,y,z) tuple, H, lacunarity, octaves, [noisebasis])\n\n\
512 Returns Fractal Brownian Motion noise value(fBm).\n\
513 H is the fractal increment parameter.\n\
514 lacunarity is the gap between successive frequencies.\n\
515 octaves is the number of frequencies in the fBm.\n\
516 Optional argument noisebasis determines the type of noise used for the turbulence, STDPERLIN by default, see NoiseTypes.";
517
518 static char multi_fractal__doc__[] =
519         "((x,y,z) tuple, H, lacunarity, octaves, [noisebasis])\n\n\
520 Returns Multifractal noise value.\n\
521 H determines the highest fractal dimension.\n\
522 lacunarity is gap between successive frequencies.\n\
523 octaves is the number of frequencies in the fBm.\n\
524 Optional argument noisebasis determines the type of noise used for the turbulence, STDPERLIN by default, see NoiseTypes.";
525
526 static char vl_vector__doc__[] =
527         "((x,y,z) tuple, distortion, [noisetype1], [noisetype2])\n\n\
528 Returns Variable Lacunarity Noise value, a distorted variety of noise.\n\
529 distortion sets the amount of distortion.\n\
530 Optional arguments noisetype1 and noisetype2 set the noisetype to distort and the noisetype used for the distortion respectively.\n\
531 See NoiseTypes, both are STDPERLIN by default.";
532
533 static char hetero_terrain__doc__[] =
534         "((x,y,z) tuple, H, lacunarity, octaves, offset, [noisebasis])\n\n\
535 returns Heterogeneous Terrain value\n\
536 H determines the fractal dimension of the roughest areas.\n\
537 lacunarity is the gap between successive frequencies.\n\
538 octaves is the number of frequencies in the fBm.\n\
539 offset raises the terrain from 'sea level'.\n\
540 Optional argument noisebasis determines the type of noise used for the turbulence, STDPERLIN by default, see NoiseTypes.";
541
542 static char hybrid_multi_fractal__doc__[] =
543         "((x,y,z) tuple, H, lacunarity, octaves, offset, gain, [noisebasis])\n\n\
544 returns Hybrid Multifractal value.\n\
545 H determines the fractal dimension of the roughest areas.\n\
546 lacunarity is the gap between successive frequencies.\n\
547 octaves is the number of frequencies in the fBm.\n\
548 offset raises the terrain from 'sea level'.\n\
549 gain scales the values.\n\
550 Optional argument noisebasis determines the type of noise used for the turbulence, STDPERLIN by default, see NoiseTypes.";
551
552 static char ridged_multi_fractal__doc__[] =
553         "((x,y,z) tuple, H, lacunarity, octaves, offset, gain [noisebasis])\n\n\
554 returns Ridged Multifractal value.\n\
555 H determines the fractal dimension of the roughest areas.\n\
556 lacunarity is the gap between successive frequencies.\n\
557 octaves is the number of frequencies in the fBm.\n\
558 offset raises the terrain from 'sea level'.\n\
559 gain scales the values.\n\
560 Optional argument noisebasis determines the type of noise used for the turbulence, STDPERLIN by default, see NoiseTypes.";
561
562 static char voronoi__doc__[] =
563         "((x,y,z) tuple, distance_metric, [exponent])\n\n\
564 returns a list, containing a list of distances in order of closest feature,\n\
565 and a list containing the positions of the four closest features\n\
566 Optional arguments:\n\
567 distance_metric: see DistanceMetrics, default is DISTANCE\n\
568 exponent is only used with MINKOVSKY, default is 2.5.";
569
570 static char cell__doc__[] = "((x,y,z) tuple)\n\n\
571 returns cellnoise float value.";
572
573 static char cell_vector__doc__[] = "((x,y,z) tuple)\n\n\
574 returns cellnoise vector/point/color (3-float list).";
575
576 static char Noise__doc__[] = "Blender Noise and Turbulence Module\n\n\
577 This module can be used to generate noise of various types.\n\
578 This can be used for terrain generation, to create textures,\n\
579 make animations more 'animated', object deformation, etc.\n\
580 As an example, this code segment when scriptlinked to a framechanged event,\n\
581 will make the camera sway randomly about, by changing parameters this can\n\
582 look like anything from an earthquake to a very nervous or maybe even drunk cameraman...\n\
583 (the camera needs an ipo with at least one Loc & Rot key for this to work!):\n\
584 \n\
585 \tfrom Blender import Get, Scene, Noise\n\
586 \n\
587 \t####################################################\n\
588 \t# This controls jitter speed\n\
589 \tsl = 0.025\n\
590 \t# This controls the amount of position jitter\n\
591 \tsp = 0.1\n\
592 \t# This controls the amount of rotation jitter\n\
593 \tsr = 0.25\n\
594 \t####################################################\n\
595 \n\
596 \ttime = Get('curtime')\n\
597 \tob = Scene.GetCurrent().getCurrentCamera()\n\
598 \tps = (sl*time, sl*time, sl*time)\n\
599 \t# To add jitter only when the camera moves, use this next line instead\n\
600 \t#ps = (sl*ob.LocX, sl*ob.LocY, sl*ob.LocZ)\n\
601 \trv = Noise.turbulence_vector(ps, 3, 0, Noise.NoiseTypes.NEWPERLIN)\n\
602 \tob.dloc = (sp*rv[0], sp*rv[1], sp*rv[2])\n\
603 \tob.drot = (sr*rv[0], sr*rv[1], sr*rv[2])\n\
604 \n";
605
606 /* Just in case, declarations for a header file */
607 /*
608 static PyObject *Noise_random(PyObject *UNUSED(self));
609 static PyObject *Noise_random_unit_vector(PyObject *UNUSED(self));
610 static PyObject *Noise_seed_set(PyObject *UNUSED(self), PyObject *args);
611 static PyObject *Noise_noise(PyObject *UNUSED(self), PyObject *args);
612 static PyObject *Noise_vector(PyObject *UNUSED(self), PyObject *args);
613 static PyObject *Noise_turbulence(PyObject *UNUSED(self), PyObject *args);
614 static PyObject *Noise_turbulence_vector(PyObject *UNUSED(self), PyObject *args);
615 static PyObject *Noise_fractal(PyObject *UNUSED(self), PyObject *args);
616 static PyObject *Noise_multi_fractal(PyObject *UNUSED(self), PyObject *args);
617 static PyObject *Noise_vl_vector(PyObject *UNUSED(self), PyObject *args);
618 static PyObject *Noise_hetero_terrain(PyObject *UNUSED(self), PyObject *args);
619 static PyObject *Noise_hybrid_multi_fractal(PyObject *UNUSED(self), PyObject *args);
620 static PyObject *Noise_ridged_multi_fractal(PyObject *UNUSED(self), PyObject *args);
621 static PyObject *Noise_voronoi(PyObject *UNUSED(self), PyObject *args);
622 static PyObject *Noise_cell(PyObject *UNUSED(self), PyObject *args);
623 static PyObject *Noise_cell_vector(PyObject *UNUSED(self), PyObject *args);
624 */
625
626 static PyMethodDef NoiseMethods[] = {
627         {"seed_set", (PyCFunction) Noise_seed_set, METH_VARARGS, seed_set__doc__},
628         {"random", (PyCFunction) Noise_random, METH_NOARGS, random__doc__},
629         {"random_unit_vector", (PyCFunction) Noise_random_unit_vector, METH_NOARGS, random_unit_vector__doc__},
630         {"noise", (PyCFunction) Noise_noise, METH_VARARGS, noise__doc__},
631         {"vector", (PyCFunction) Noise_vector, METH_VARARGS, noise_vector__doc__},
632         {"turbulence", (PyCFunction) Noise_turbulence, METH_VARARGS, turbulence__doc__},
633         {"turbulence_vector", (PyCFunction) Noise_turbulence_vector, METH_VARARGS, turbulence_vector__doc__},
634         {"fractal", (PyCFunction) Noise_fractal, METH_VARARGS, fractal__doc__},
635         {"multi_fractal", (PyCFunction) Noise_multi_fractal, METH_VARARGS, multi_fractal__doc__},
636         {"vl_vector", (PyCFunction) Noise_vl_vector, METH_VARARGS, vl_vector__doc__},
637         {"hetero_terrain", (PyCFunction) Noise_hetero_terrain, METH_VARARGS, hetero_terrain__doc__},
638         {"hybrid_multi_fractal", (PyCFunction) Noise_hybrid_multi_fractal, METH_VARARGS, hybrid_multi_fractal__doc__},
639         {"ridged_multi_fractal", (PyCFunction) Noise_ridged_multi_fractal, METH_VARARGS, ridged_multi_fractal__doc__},
640         {"voronoi", (PyCFunction) Noise_voronoi, METH_VARARGS, voronoi__doc__},
641         {"cell", (PyCFunction) Noise_cell, METH_VARARGS, cell__doc__},
642         {"cell_vector", (PyCFunction) Noise_cell_vector, METH_VARARGS, cell_vector__doc__},
643         {NULL, NULL, 0, NULL}
644 };
645
646 /*----------------------------------------------------------------------*/
647
648 static struct PyModuleDef noise_module_def = {
649         PyModuleDef_HEAD_INIT,
650         "noise",  /* m_name */
651         Noise__doc__,  /* m_doc */
652         0,  /* m_size */
653         NoiseMethods,  /* m_methods */
654         0,  /* m_reload */
655         0,  /* m_traverse */
656         0,  /* m_clear */
657         0,  /* m_free */
658 };
659
660 PyObject *Noise_Init(void)
661 {
662         PyObject *submodule = PyModule_Create(&noise_module_def);
663         PyDict_SetItemString(PyImport_GetModuleDict(), noise_module_def.m_name, submodule);
664
665         /* use current time as seed for random number generator by default */
666         setRndSeed(0);  
667
668         /* Constant noisetype dictionary */
669         if(submodule) {
670                 static PyStructSequence_Field noise_types_fields[] = {
671                         {"BLENDER", ""},
672                         {"STDPERLIN", ""},
673                         {"NEWPERLIN", ""},
674                         {"VORONOI_F1", ""},
675                         {"VORONOI_F2", ""},
676                         {"VORONOI_F3", ""},
677                         {"VORONOI_F4", ""},
678                         {"VORONOI_F2F1", ""},
679                         {"VORONOI_CRACKLE", ""},
680                         {"CELLNOISE", ""},
681                         {0}
682                 };
683
684                 static PyStructSequence_Desc noise_types_info_desc = {
685                         "noise.types",     /* name */
686                         "Noise type",    /* doc */
687                         noise_types_fields,    /* fields */
688                         (sizeof(noise_types_fields)/sizeof(PyStructSequence_Field)) - 1
689                 };
690
691                 static PyTypeObject NoiseType;
692
693                 PyObject *noise_types;
694                 
695                 int pos = 0;
696                 
697                 PyStructSequence_InitType(&NoiseType, &noise_types_info_desc);
698         
699                 noise_types = PyStructSequence_New(&NoiseType);
700                 if (noise_types == NULL) {
701                         return NULL;
702                 }
703
704                 PyStructSequence_SET_ITEM(noise_types, pos++, PyLong_FromLong(TEX_BLENDER));
705                 PyStructSequence_SET_ITEM(noise_types, pos++, PyLong_FromLong(TEX_STDPERLIN));
706                 PyStructSequence_SET_ITEM(noise_types, pos++, PyLong_FromLong(TEX_NEWPERLIN));
707                 PyStructSequence_SET_ITEM(noise_types, pos++, PyLong_FromLong(TEX_VORONOI_F1));
708                 PyStructSequence_SET_ITEM(noise_types, pos++, PyLong_FromLong(TEX_VORONOI_F2));
709                 PyStructSequence_SET_ITEM(noise_types, pos++, PyLong_FromLong(TEX_VORONOI_F3));
710                 PyStructSequence_SET_ITEM(noise_types, pos++, PyLong_FromLong(TEX_VORONOI_F4));
711                 PyStructSequence_SET_ITEM(noise_types, pos++, PyLong_FromLong(TEX_VORONOI_F2F1));
712                 PyStructSequence_SET_ITEM(noise_types, pos++, PyLong_FromLong(TEX_VORONOI_CRACKLE));
713                 PyStructSequence_SET_ITEM(noise_types, pos++, PyLong_FromLong(TEX_CELLNOISE));
714
715                 PyModule_AddObject(submodule, "types", noise_types);
716         }
717         
718         if(submodule) {
719                 static PyStructSequence_Field distance_metrics_fields[] = {
720                         {"DISTANCE", ""},
721                         {"DISTANCE_SQUARED", ""},
722                         {"MANHATTAN", ""},
723                         {"CHEBYCHEV", ""},
724                         {"MINKOVSKY_HALF", ""},
725                         {"MINKOVSKY_FOUR", ""},
726                         {"MINKOVSKY", ""},
727                         {0}
728                 };
729
730                 static PyStructSequence_Desc noise_types_info_desc = {
731                         "noise.distance_metrics",     /* name */
732                         "Distance Metrics for noise module.",    /* doc */
733                         distance_metrics_fields,    /* fields */
734                         (sizeof(distance_metrics_fields)/sizeof(PyStructSequence_Field)) - 1
735                 };
736                 
737                 static PyTypeObject DistanceMetrics;
738                 
739                 PyObject *distance_metrics;
740                 
741                 int pos = 0;
742                 
743                 PyStructSequence_InitType(&DistanceMetrics, &noise_types_info_desc);
744         
745                 distance_metrics = PyStructSequence_New(&DistanceMetrics);
746                 if (distance_metrics == NULL) {
747                         return NULL;
748                 }
749
750                 PyStructSequence_SET_ITEM(distance_metrics, pos++, PyLong_FromLong(TEX_DISTANCE));
751                 PyStructSequence_SET_ITEM(distance_metrics, pos++, PyLong_FromLong(TEX_DISTANCE_SQUARED));
752                 PyStructSequence_SET_ITEM(distance_metrics, pos++, PyLong_FromLong(TEX_MANHATTAN));
753                 PyStructSequence_SET_ITEM(distance_metrics, pos++, PyLong_FromLong(TEX_CHEBYCHEV));
754                 PyStructSequence_SET_ITEM(distance_metrics, pos++, PyLong_FromLong(TEX_MINKOVSKY_HALF));
755                 PyStructSequence_SET_ITEM(distance_metrics, pos++, PyLong_FromLong(TEX_MINKOVSKY_FOUR));
756                 PyStructSequence_SET_ITEM(distance_metrics, pos++, PyLong_FromLong(TEX_MINKOVSKY));
757
758                 PyModule_AddObject(submodule, "distance_metrics", distance_metrics);
759         }
760
761         return submodule;
762 }