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