47e93492e7a438f4d9598e327a0e76aebb391738
[blender.git] / source / blender / python / mathutils / mathutils_noise.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * This is a new part of Blender.
22  *
23  * Contributor(s): eeshlo, Campbell Barton
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/python/mathutils/mathutils_noise.c
29  *  \ingroup mathutils
30  *
31  * This file defines the 'noise' module, a general purpose module to access
32  * blenders noise functions.
33  */
34
35
36 /************************/
37 /* Blender Noise Module */
38 /************************/
39
40 #include <Python.h>
41
42 #include "structseq.h"
43
44 #include "BLI_blenlib.h"
45 #include "BLI_math.h"
46 #include "BLI_utildefines.h"
47
48 #include "MEM_guardedalloc.h"
49
50 #include "DNA_texture_types.h"
51
52 #include "mathutils.h"
53 #include "mathutils_noise.h"
54
55 /* 2.6 update
56  * Moved to submodule of mathutils.
57  * All vector functions now return mathutils.Vector
58  * Updated docs to be compatible with autodocs generation.
59  * Updated vector functions to use nD array functions.
60  * noise.vl_vector --> noise.variable_lacunarity
61  * noise.vector --> noise.noise_vector
62  */
63
64 /*-----------------------------------------*/
65 /* 'mersenne twister' random number generator */
66
67 /* 
68    A C-program for MT19937, with initialization improved 2002/2/10.
69    Coded by Takuji Nishimura and Makoto Matsumoto.
70    This is a faster version by taking Shawn Cokus's optimization,
71    Matthe Bellew's simplification, Isaku Wada's real version.
72
73    Before using, initialize the state by using init_genrand(seed) 
74    or init_by_array(init_key, key_length).
75
76    Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
77    All rights reserved.                          
78
79    Redistribution and use in source and binary forms, with or without
80    modification, are permitted provided that the following conditions
81    are met:
82
83      1. Redistributions of source code must retain the above copyright
84         notice, this list of conditions and the following disclaimer.
85
86      2. Redistributions in binary form must reproduce the above copyright
87         notice, this list of conditions and the following disclaimer in the
88         documentation and/or other materials provided with the distribution.
89
90      3. The names of its contributors may not be used to endorse or promote 
91         products derived from this software without specific prior written 
92         permission.
93
94    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
95    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
96    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
97    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
98    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
99    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
100    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
101    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
102    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
103    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
104    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
105
106
107    Any feedback is very welcome.
108    http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
109    email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
110 */
111
112 /* Period parameters */
113 #define N 624
114 #define M 397
115 #define MATRIX_A 0x9908b0dfUL   /* constant vector a */
116 #define UMASK 0x80000000UL      /* most significant w-r bits */
117 #define LMASK 0x7fffffffUL      /* least significant r bits */
118 #define MIXBITS(u,v) (((u) & UMASK) | ((v) & LMASK))
119 #define TWIST(u,v) ((MIXBITS(u,v) >> 1) ^ ((v)&1UL ? MATRIX_A : 0UL))
120
121 static unsigned long state[N];  /* the array for the state vector  */
122 static int left = 1;
123 static int initf = 0;
124 static unsigned long *next;
125
126 /* initializes state[N] with a seed */
127 static void init_genrand(unsigned long s)
128 {
129         int j;
130         state[0] = s & 0xffffffffUL;
131         for (j = 1; j < N; j++) {
132                 state[j] =
133                         (1812433253UL *
134                           (state[j - 1] ^ (state[j - 1] >> 30)) + j);
135                 /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
136                 /* In the previous versions, MSBs of the seed affect   */
137                 /* only MSBs of the array state[].                        */
138                 /* 2002/01/09 modified by Makoto Matsumoto             */
139                 state[j] &= 0xffffffffUL;       /* for >32 bit machines */
140         }
141         left = 1;
142         initf = 1;
143 }
144
145 static void next_state(void)
146 {
147         unsigned long *p = state;
148         int j;
149
150         /* if init_genrand() has not been called, */
151         /* a default initial seed is used         */
152         if (initf == 0)
153                 init_genrand(5489UL);
154
155         left = N;
156         next = state;
157
158         for (j = N - M + 1; --j; p++)
159                 *p = p[M] ^ TWIST(p[0], p[1]);
160
161         for (j = M; --j; p++)
162                 *p = p[M - N] ^ TWIST(p[0], p[1]);
163
164         *p = p[M - N] ^ TWIST(p[0], state[0]);
165 }
166
167 /*------------------------------------------------------------*/
168
169 static void setRndSeed(int seed)
170 {
171         if (seed == 0)
172                 init_genrand(time(NULL));
173         else
174                 init_genrand(seed);
175 }
176
177 /* float number in range [0, 1) using the mersenne twister rng */
178 static float frand(void)
179 {
180         unsigned long y;
181
182         if (--left == 0)
183                 next_state();
184         y = *next++;
185
186         /* Tempering */
187         y ^= (y >> 11);
188         y ^= (y << 7) & 0x9d2c5680UL;
189         y ^= (y << 15) & 0xefc60000UL;
190         y ^= (y >> 18);
191
192         return (float) y / 4294967296.f;
193 }
194
195 /*------------------------------------------------------------*/
196 /* Utility Functions */
197 /*------------------------------------------------------------*/
198
199 /* Fills an array of length size with random numbers in the range (-1, 1)*/
200 static void rand_vn(float *array_tar, const int size)
201 {
202         float *array_pt = array_tar + (size-1);
203         int i = size;
204         while (i--) { *(array_pt--) = 2.0f * frand() - 1.0f; }
205 }
206
207 /* Fills an array of length 3 with noise values */
208 static void noise_vector(float x, float y, float z, int nb, float v[3])
209 {
210         /* Simply evaluate noise at 3 different positions */
211         v[0] = (float)(2.0f * BLI_gNoise(1.f, x + 9.321f, y - 1.531f, z - 7.951f, 0, nb) - 1.0f);
212         v[1] = (float)(2.0f * BLI_gNoise(1.f, x, y, z, 0, nb) - 1.0f);
213         v[2] = (float)(2.0f * BLI_gNoise(1.f, x + 6.327f, y + 0.1671f, z - 2.672f, 0, nb) - 1.0f);
214 }
215
216 /* Returns a turbulence value for a given position (x, y, z) */
217 static float turb(float x, float y, float z, int oct, int hard, int nb,
218                    float ampscale, float freqscale)
219 {
220         float amp, out, t;
221         int i;
222         amp = 1.f;
223         out = (float)(2.0f * BLI_gNoise(1.f, x, y, z, 0, nb) - 1.0f);
224         if (hard)
225                 out = fabsf(out);
226         for (i = 1; i < oct; i++) {
227                 amp *= ampscale;
228                 x *= freqscale;
229                 y *= freqscale;
230                 z *= freqscale;
231                 t = (float)(amp * (2.0f * BLI_gNoise(1.f, x, y, z, 0, nb) - 1.0f));
232                 if (hard)
233                         t = fabsf(t);
234                 out += t;
235         }
236         return out;
237 }
238
239 /* Fills an array of length 3 with the turbulence vector for a given
240 position (x, y, z) */
241 static void vTurb(float x, float y, float z, int oct, int hard, int nb,
242                   float ampscale, float freqscale, float v[3])
243 {
244         float amp, t[3];
245         int i;
246         amp = 1.f;
247         noise_vector(x, y, z, nb, v);
248         if (hard) {
249                 v[0] = fabsf(v[0]);
250                 v[1] = fabsf(v[1]);
251                 v[2] = fabsf(v[2]);
252         }
253         for (i = 1; i < oct; i++) {
254                 amp *= ampscale;
255                 x *= freqscale;
256                 y *= freqscale;
257                 z *= freqscale;
258                 noise_vector(x, y, z, nb, t);
259                 if (hard) {
260                         t[0] = fabsf(t[0]);
261                         t[1] = fabsf(t[1]);
262                         t[2] = fabsf(t[2]);
263                 }
264                 v[0] += amp * t[0];
265                 v[1] += amp * t[1];
266                 v[2] += amp * t[2];
267         }
268 }
269
270 /*-------------------------DOC STRINGS ---------------------------*/
271 PyDoc_STRVAR(M_Noise_doc,
272 "The Blender noise module"
273 );
274
275 /*------------------------------------------------------------*/
276 /* Python Functions */
277 /*------------------------------------------------------------*/
278
279 PyDoc_STRVAR(M_Noise_random_doc,
280 ".. function:: random()\n"
281 "\n"
282 "   Returns a random number in the range [0, 1].\n"
283 "\n"
284 "   :return: The random number.\n"
285 "   :rtype: float\n"
286 );
287 static PyObject *M_Noise_random(PyObject *UNUSED(self))
288 {
289         return PyFloat_FromDouble(frand());
290 }
291
292 PyDoc_STRVAR(M_Noise_random_unit_vector_doc,
293 ".. function:: random_unit_vector(size=3)\n"
294 "\n"
295 "   Returns a unit vector with random entries.\n"
296 "\n"
297 "   :arg size: The size of the vector to be produced.\n"
298 "   :type size: Int\n"
299 "   :return: The random unit vector.\n"
300 "   :rtype: :class:`mathutils.Vector`\n"
301 );
302 static PyObject *M_Noise_random_unit_vector(PyObject *UNUSED(self), PyObject *args)
303 {
304         float vec[4] = {0.0f, 0.0f, 0.0f, 0.0f};
305         float norm = 2.0f;
306         int size = 3;
307
308         if (!PyArg_ParseTuple(args, "|i:random_vector", &size))
309                 return NULL;
310
311         if (size > 4 || size < 2) {
312                 PyErr_SetString(PyExc_ValueError, "Vector(): invalid size");
313                 return NULL;
314         }
315
316         while (norm == 0.0f || norm >= 1.0f) {
317                 rand_vn(vec, size);
318                 norm = normalize_vn(vec, size);
319         }
320
321         return Vector_CreatePyObject(vec, size, Py_NEW, NULL);
322 }
323 /* This is dumb, most people will want a unit vector anyway, since this doesn't have uniform distribution over a sphere*/
324 /*
325 PyDoc_STRVAR(M_Noise_random_vector_doc,
326 ".. function:: random_vector(size=3)\n"
327 "\n"
328 "   Returns a vector with random entries in the range [0, 1).\n"
329 "\n"
330 "   :arg size: The size of the vector to be produced.\n"
331 "   :type size: Int\n"
332 "   :return: The random vector.\n"
333 "   :rtype: :class:`mathutils.Vector`\n"
334 );
335 static PyObject *M_Noise_random_vector(PyObject *UNUSED(self), PyObject *args)
336 {
337         float vec[4]= {0.0f, 0.0f, 0.0f, 0.0f};
338         int size= 3;
339
340         if (!PyArg_ParseTuple(args, "|i:random_vector", &size))
341                 return NULL;
342
343         if (size > 4 || size < 2) {
344                 PyErr_SetString(PyExc_ValueError, "Vector(): invalid size");
345                 return NULL;
346         }
347
348         rand_vn(vec, size);
349
350         return Vector_CreatePyObject(vec, size, Py_NEW, NULL);
351 }
352 */
353
354 PyDoc_STRVAR(M_Noise_seed_set_doc,
355 ".. function:: seed_set(seed)\n"
356 "\n"
357 "   Sets the random seed used for random_unit_vector, random_vector and random.\n"
358 "\n"
359 "   :arg seed: Seed used for the random generator.\n"
360 "   :type seed: Int\n"
361 );
362 static PyObject *M_Noise_seed_set(PyObject *UNUSED(self), PyObject *args)
363 {
364         int s;
365         if (!PyArg_ParseTuple(args, "i:seed_set", &s))
366                 return NULL;
367         setRndSeed(s);
368         Py_RETURN_NONE;
369 }
370
371 PyDoc_STRVAR(M_Noise_noise_doc,
372 ".. function:: noise(position, noise_basis=noise.types.STDPERLIN)\n"
373 "\n"
374 "   Returns noise value from the noise basis at the position specified.\n"
375 "\n"
376 "   :arg position: The position to evaluate the selected noise function at.\n"
377 "   :type position: :class:`mathutils.Vector`\n"
378 "   :arg noise_basis: The type of noise to be evaluated.\n"
379 "   :type noise_basis: Value in noise.types or int\n"
380 "   :return: The noise value.\n"
381 "   :rtype: float\n"
382 );
383 static PyObject *M_Noise_noise(PyObject *UNUSED(self), PyObject *args)
384 {
385         PyObject *value;
386         float vec[3];
387         int nb = 1;
388         if (!PyArg_ParseTuple(args, "O|i:noise", &value, &nb))
389                 return NULL;
390
391         if (mathutils_array_parse(vec, 3, 3, value, "noise: invalid 'position' arg") == -1)
392                 return NULL;
393
394         return PyFloat_FromDouble((2.0f * BLI_gNoise(1.0f, vec[0], vec[1], vec[2], 0, nb) - 1.0f));
395 }
396
397 PyDoc_STRVAR(M_Noise_noise_vector_doc,
398 ".. function:: noise_vector(position, noise_basis=noise.types.STDPERLIN)\n"
399 "\n"
400 "   Returns the noise vector from the noise basis at the specified position.\n"
401 "\n"
402 "   :arg position: The position to evaluate the selected noise function at.\n"
403 "   :type position: :class:`mathutils.Vector`\n"
404 "   :arg noise_basis: The type of noise to be evaluated.\n"
405 "   :type noise_basis: Value in noise.types or int\n"
406 "   :return: The noise vector.\n"
407 "   :rtype: :class:`mathutils.Vector`\n"
408 );
409 static PyObject *M_Noise_noise_vector(PyObject *UNUSED(self), PyObject *args)
410 {
411         PyObject *value;
412         float vec[3], r_vec[3];
413         int nb = 1;
414
415         if (!PyArg_ParseTuple(args, "O|i:noise_vector", &value, &nb))
416                 return NULL;
417
418         if (mathutils_array_parse(vec, 3, 3, value, "noise_vector: invalid 'position' arg") == -1)
419                 return NULL;
420
421         noise_vector(vec[0], vec[1], vec[2], nb, r_vec);
422
423         return Vector_CreatePyObject(r_vec, 3, Py_NEW, NULL);
424 }
425
426 PyDoc_STRVAR(M_Noise_turbulence_doc,
427 ".. function:: turbulence(position, octaves, hard, noise_basis=noise.types.STDPERLIN, amplitude_scale=0.5, frequency_scale=2.0)\n"
428 "\n"
429 "   Returns the turbulence value from the noise basis at the specified position.\n"
430 "\n"
431 "   :arg position: The position to evaluate the selected noise function at.\n"
432 "   :type position: :class:`mathutils.Vector`\n"
433 "   :arg octaves: The number of different noise frequencies used.\n"
434 "   :type octaves: int\n"
435 "   :arg hard: Specifies whether returned turbulence is hard (sharp transitions) or soft (smooth transitions).\n"
436 "   :type hard: :boolean\n"
437 "   :arg noise_basis: The type of noise to be evaluated.\n"
438 "   :type noise_basis: Value in mathutils.noise.types or int\n"
439 "   :arg amplitude_scale: The amplitude scaling factor.\n"
440 "   :type amplitude_scale: float\n"
441 "   :arg frequency_scale: The frequency scaling factor\n"
442 "   :type frequency_scale: Value in noise.types or int\n"
443 "   :return: The turbulence value.\n"
444 "   :rtype: float\n"
445 );
446 static PyObject *M_Noise_turbulence(PyObject *UNUSED(self), PyObject *args)
447 {
448         PyObject *value;
449         float vec[3];
450         int oct, hd, nb = 1;
451         float as = 0.5f, fs = 2.0f;
452
453         if (!PyArg_ParseTuple(args, "Oii|iff:turbulence", &value, &oct, &hd, &nb, &as, &fs))
454                 return NULL;
455
456         if (mathutils_array_parse(vec, 3, 3, value, "turbulence: invalid 'position' arg") == -1)
457                 return NULL;
458
459         return PyFloat_FromDouble(turb(vec[0], vec[1], vec[2], oct, hd, nb, as, fs));
460 }
461
462 PyDoc_STRVAR(M_Noise_turbulence_vector_doc,
463 ".. function:: turbulence_vector(position, octaves, hard, noise_basis=noise.types.STDPERLIN, amplitude_scale=0.5, frequency_scale=2.0)\n"
464 "\n"
465 "   Returns the turbulence vector from the noise basis at the specified position.\n"
466 "\n"
467 "   :arg position: The position to evaluate the selected noise function at.\n"
468 "   :type position: :class:`mathutils.Vector`\n"
469 "   :arg octaves: The number of different noise frequencies used.\n"
470 "   :type octaves: int\n"
471 "   :arg hard: Specifies whether returned turbulence is hard (sharp transitions) or soft (smooth transitions).\n"
472 "   :type hard: :boolean\n"
473 "   :arg noise_basis: The type of noise to be evaluated.\n"
474 "   :type noise_basis: Value in mathutils.noise.types or int\n"
475 "   :arg amplitude_scale: The amplitude scaling factor.\n"
476 "   :type amplitude_scale: float\n"
477 "   :arg frequency_scale: The frequency scaling factor\n"
478 "   :type frequency_scale: Value in noise.types or int\n"
479 "   :return: The turbulence vector.\n"
480 "   :rtype: :class:`mathutils.Vector`\n"
481 );
482 static PyObject *M_Noise_turbulence_vector(PyObject *UNUSED(self), PyObject *args)
483 {
484         PyObject *value;
485         float vec[3], r_vec[3];
486         int oct, hd, nb = 1;
487         float as =0.5f, fs = 2.0f;
488         if (!PyArg_ParseTuple(args, "Oii|iff:turbulence_vector", &value, &oct, &hd, &nb, &as, &fs))
489                 return NULL;
490
491         if (mathutils_array_parse(vec, 3, 3, value, "turbulence_vector: invalid 'position' arg") == -1)
492                 return NULL;
493
494         vTurb(vec[0], vec[1], vec[2], oct, hd, nb, as, fs, r_vec);
495         return Vector_CreatePyObject(r_vec, 3, Py_NEW, NULL);
496 }
497
498 /* F. Kenton Musgrave's fractal functions */
499 PyDoc_STRVAR(M_Noise_fractal_doc,
500 ".. function:: fractal(position, H, lacunarity, octaves, noise_basis=noise.types.STDPERLIN)\n"
501 "\n"
502 "   Returns the fractal Brownian motion (fBm) noise value from the noise basis at the specified position.\n"
503 "\n"
504 "   :arg position: The position to evaluate the selected noise function at.\n"
505 "   :type position: :class:`mathutils.Vector`\n"
506 "   :arg H: The fractal increment factor.\n"
507 "   :type H: float\n"
508 "   :arg lacunarity: The gap between successive frequencies.\n"
509 "   :type lacunarity: float\n"
510 "   :arg octaves: The number of different noise frequencies used.\n"
511 "   :type octaves: int\n"
512 "   :arg noise_basis: The type of noise to be evaluated.\n"
513 "   :type noise_basis: Value in noise.types or int\n"
514 "   :return: The fractal Brownian motion noise value.\n"
515 "   :rtype: float\n"
516 );
517 static PyObject *M_Noise_fractal(PyObject *UNUSED(self), PyObject *args)
518 {
519         PyObject *value;
520         float vec[3];
521         float H, lac, oct;
522         int nb = 1;
523
524         if (!PyArg_ParseTuple(args, "Offf|i:fractal", &value, &H, &lac, &oct, &nb))
525                 return NULL;
526
527         if (mathutils_array_parse(vec, 3, 3, value, "fractal: invalid 'position' arg") == -1)
528                 return NULL;
529
530         return PyFloat_FromDouble(mg_fBm(vec[0], vec[1], vec[2], H, lac, oct, nb));
531 }
532
533 PyDoc_STRVAR(M_Noise_multi_fractal_doc,
534 ".. function:: multi_fractal(position, H, lacunarity, octaves, noise_basis=noise.types.STDPERLIN)\n"
535 "\n"
536 "   Returns multifractal noise value from the noise basis at the specified position.\n"
537 "\n"
538 "   :arg position: The position to evaluate the selected noise function at.\n"
539 "   :type position: :class:`mathutils.Vector`\n"
540 "   :arg H: The fractal increment factor.\n"
541 "   :type H: float\n"
542 "   :arg lacunarity: The gap between successive frequencies.\n"
543 "   :type lacunarity: float\n"
544 "   :arg octaves: The number of different noise frequencies used.\n"
545 "   :type octaves: int\n"
546 "   :arg noise_basis: The type of noise to be evaluated.\n"
547 "   :type noise_basis: Value in noise.types or int\n"
548 "   :return: The multifractal noise value.\n"
549 "   :rtype: float\n"
550 );
551 static PyObject *M_Noise_multi_fractal(PyObject *UNUSED(self), PyObject *args)
552 {
553         PyObject *value;
554         float vec[3];
555         float H, lac, oct;
556         int nb = 1;
557
558         if (!PyArg_ParseTuple(args, "Offf|i:multi_fractal", &value, &H, &lac, &oct, &nb))
559                 return NULL;
560
561         if (mathutils_array_parse(vec, 3, 3, value, "multi_fractal: invalid 'position' arg") == -1)
562                 return NULL;
563
564         return PyFloat_FromDouble(mg_MultiFractal(vec[0], vec[1], vec[2], H, lac, oct, nb));
565 }
566
567 PyDoc_STRVAR(M_Noise_variable_lacunarity_doc,
568 ".. function:: variable_lacunarity(position, distortion, noise_type1=noise.types.STDPERLIN, noise_type2=noise.types.STDPERLIN)\n"
569 "\n"
570 "   Returns variable lacunarity noise value, a distorted variety of noise, from noise type 1 distorted by noise type 2 at the specified position.\n"
571 "\n"
572 "   :arg position: The position to evaluate the selected noise function at.\n"
573 "   :type position: :class:`mathutils.Vector`\n"
574 "   :arg distortion: The amount of distortion.\n"
575 "   :type distortion: float\n"
576 "   :arg noise_type1: The type of noise to be distorted.\n"
577 "   :type noise_type1: Value in noise.types or int\n"
578 "   :arg noise_type2: The type of noise used to distort noise_type1.\n"
579 "   :type noise_type2: Value in noise.types or int\n"
580 "   :return: The variable lacunarity noise value.\n"
581 "   :rtype: float\n"
582 );
583 static PyObject *M_Noise_variable_lacunarity(PyObject *UNUSED(self), PyObject *args)
584 {
585         PyObject *value;
586         float vec[3];
587         float d;
588         int nt1 = 1, nt2 = 1;
589
590         if (!PyArg_ParseTuple(args, "Of|ii:variable_lacunarity", &value, &d, &nt1, &nt2))
591                 return NULL;
592
593         if (mathutils_array_parse(vec, 3, 3, value, "variable_lacunarity: invalid 'position' arg") == -1)
594                 return NULL;
595
596         return PyFloat_FromDouble(mg_VLNoise(vec[0], vec[1], vec[2], d, nt1, nt2));
597 }
598
599 PyDoc_STRVAR(M_Noise_hetero_terrain_doc,
600 ".. function:: hetero_terrain(position, H, lacunarity, octaves, offset, noise_basis=noise.types.STDPERLIN)\n"
601 "\n"
602 "   Returns the heterogeneous terrain value from the noise basis at the specified position.\n"
603 "\n"
604 "   :arg position: The position to evaluate the selected noise function at.\n"
605 "   :type position: :class:`mathutils.Vector`\n"
606 "   :arg H: The fractal dimension of the roughest areas.\n"
607 "   :type H: float\n"
608 "   :arg lacunarity: The gap between successive frequencies.\n"
609 "   :type lacunarity: float\n"
610 "   :arg octaves: The number of different noise frequencies used.\n"
611 "   :type octaves: int\n"
612 "   :arg offset: The height of the terrain above 'sea level'.\n"
613 "   :type offset: float\n"
614 "   :arg noise_basis: The type of noise to be evaluated.\n"
615 "   :type noise_basis: Value in noise.types or int\n"
616 "   :return: The heterogeneous terrain value.\n"
617 "   :rtype: float\n"
618 );
619 static PyObject *M_Noise_hetero_terrain(PyObject *UNUSED(self), PyObject *args)
620 {
621         PyObject *value;
622         float vec[3];
623         float H, lac, oct, ofs;
624         int nb = 1;
625
626         if (!PyArg_ParseTuple(args, "Offff|i:hetero_terrain", &value, &H, &lac, &oct, &ofs, &nb))
627                 return NULL;
628
629         if (mathutils_array_parse(vec, 3, 3, value, "hetero_terrain: invalid 'position' arg") == -1)
630                 return NULL;
631
632         return PyFloat_FromDouble(mg_HeteroTerrain(vec[0], vec[1], vec[2], H, lac, oct, ofs, nb));
633 }
634
635 PyDoc_STRVAR(M_Noise_hybrid_multi_fractal_doc,
636 ".. function:: hybrid_multi_fractal(position, H, lacunarity, octaves, offset, gain, noise_basis=noise.types.STDPERLIN)\n"
637 "\n"
638 "   Returns hybrid multifractal value from the noise basis at the specified position.\n"
639 "\n"
640 "   :arg position: The position to evaluate the selected noise function at.\n"
641 "   :type position: :class:`mathutils.Vector`\n"
642 "   :arg H: The fractal dimension of the roughest areas.\n"
643 "   :type H: float\n"
644 "   :arg lacunarity: The gap between successive frequencies.\n"
645 "   :type lacunarity: float\n"
646 "   :arg octaves: The number of different noise frequencies used.\n"
647 "   :type octaves: int\n"
648 "   :arg offset: The height of the terrain above 'sea level'.\n"
649 "   :type offset: float\n"
650 "   :arg gain: Scaling applied to the values.\n"
651 "   :type gain: float\n"
652 "   :arg noise_basis: The type of noise to be evaluated.\n"
653 "   :type noise_basis: Value in noise.types or int\n"
654 "   :return: The hybrid multifractal value.\n"
655 "   :rtype: float\n"
656 );
657 static PyObject *M_Noise_hybrid_multi_fractal(PyObject *UNUSED(self), PyObject *args)
658 {
659         PyObject *value;
660         float vec[3];
661         float H, lac, oct, ofs, gn;
662         int nb = 1;
663
664         if (!PyArg_ParseTuple(args, "Offfff|i:hybrid_multi_fractal", &value, &H, &lac, &oct, &ofs, &gn, &nb))
665                 return NULL;
666
667         if (mathutils_array_parse(vec, 3, 3, value, "hybrid_multi_fractal: invalid 'position' arg") == -1)
668                 return NULL;
669         
670         return PyFloat_FromDouble(mg_HybridMultiFractal(vec[0], vec[1], vec[2], H, lac, oct, ofs, gn, nb));
671 }
672
673 PyDoc_STRVAR(M_Noise_ridged_multi_fractal_doc,
674 ".. function:: ridged_multi_fractal(position, H, lacunarity, octaves, offset, gain, noise_basis=noise.types.STDPERLIN)\n"
675 "\n"
676 "   Returns ridged multifractal value from the noise basis at the specified position.\n"
677 "\n"
678 "   :arg position: The position to evaluate the selected noise function at.\n"
679 "   :type position: :class:`mathutils.Vector`\n"
680 "   :arg H: The fractal dimension of the roughest areas.\n"
681 "   :type H: float\n"
682 "   :arg lacunarity: The gap between successive frequencies.\n"
683 "   :type lacunarity: float\n"
684 "   :arg octaves: The number of different noise frequencies used.\n"
685 "   :type octaves: int\n"
686 "   :arg offset: The height of the terrain above 'sea level'.\n"
687 "   :type offset: float\n"
688 "   :arg gain: Scaling applied to the values.\n"
689 "   :type gain: float\n"
690 "   :arg noise_basis: The type of noise to be evaluated.\n"
691 "   :type noise_basis: Value in noise.types or int\n"
692 "   :return: The ridged multifractal value.\n"
693 "   :rtype: float\n"
694 );
695 static PyObject *M_Noise_ridged_multi_fractal(PyObject *UNUSED(self), PyObject *args)
696 {
697         PyObject *value;
698         float vec[3];
699         float H, lac, oct, ofs, gn;
700         int nb = 1;
701
702         if (!PyArg_ParseTuple(args, "Offfff|i:ridged_multi_fractal", &value, &H, &lac, &oct, &ofs, &gn, &nb))
703                 return NULL;
704
705         if (mathutils_array_parse(vec, 3, 3, value, "ridged_multi_fractal: invalid 'position' arg") == -1)
706                 return NULL;
707
708         return PyFloat_FromDouble(mg_RidgedMultiFractal(vec[0], vec[1], vec[2], H, lac, oct, ofs, gn, nb));
709 }
710
711 PyDoc_STRVAR(M_Noise_voronoi_doc,
712 ".. function:: voronoi(position, distance_metric=noise.distance_metrics.DISTANCE, exponent=2.5)\n"
713 "\n"
714 "   Returns a list of distances to the four closest features and their locations.\n"
715 "\n"
716 "   :arg position: The position to evaluate the selected noise function at.\n"
717 "   :type position: :class:`mathutils.Vector`\n"
718 "   :arg distance_metric: Method of measuring distance.\n"
719 "   :type distance_metric: Value in noise.distance_metrics or int\n"
720 "   :arg exponent: The exponent for Minkovsky distance metric.\n"
721 "   :type exponent: float\n"
722 "   :return: A list of distances to the four closest features and their locations.\n"
723 "   :rtype: list of four floats, list of four :class:`mathutils.Vector` types\n"
724 );
725 static PyObject *M_Noise_voronoi(PyObject *UNUSED(self), PyObject *args)
726 {
727         PyObject *value;
728         PyObject *list;
729         float vec[3];
730         float da[4], pa[12];
731         int dtype = 0;
732         float me = 2.5f;                /* default minkovsky exponent */
733
734         int i;
735
736         if (!PyArg_ParseTuple(args, "O|if:voronoi", &value, &dtype, &me))
737                 return NULL;
738
739         if (mathutils_array_parse(vec, 3, 3, value, "voronoi: invalid 'position' arg") == -1)
740                 return NULL;
741
742         list = PyList_New(4);
743
744         voronoi(vec[0], vec[1], vec[2], da, pa, me, dtype);
745
746         for (i = 0; i < 4; i++) {
747                 PyList_SET_ITEM(list, i, Vector_CreatePyObject(pa + 3 * i, 3, Py_NEW, NULL));
748         }
749
750         return Py_BuildValue("[[ffff]O]", da[0], da[1], da[2], da[3], list);
751 }
752
753 PyDoc_STRVAR(M_Noise_cell_doc,
754 ".. function:: cell(position)\n"
755 "\n"
756 "   Returns cell noise value at the specified position.\n"
757 "\n"
758 "   :arg position: The position to evaluate the selected noise function at.\n"
759 "   :type position: :class:`mathutils.Vector`\n"
760 "   :return: The cell noise value.\n"
761 "   :rtype: float\n"
762 );
763 static PyObject *M_Noise_cell(PyObject *UNUSED(self), PyObject *args)
764 {
765         PyObject *value;
766         float vec[3];
767
768         if (!PyArg_ParseTuple(args, "O:cell", &value))
769                 return NULL;
770
771         if (mathutils_array_parse(vec, 3, 3, value, "cell: invalid 'position' arg") == -1)
772                 return NULL;
773
774         return PyFloat_FromDouble(cellNoise(vec[0], vec[1], vec[2]));
775 }
776
777 PyDoc_STRVAR(M_Noise_cell_vector_doc,
778 ".. function:: cell_vector(position)\n"
779 "\n"
780 "   Returns cell noise vector at the specified position.\n"
781 "\n"
782 "   :arg position: The position to evaluate the selected noise function at.\n"
783 "   :type position: :class:`mathutils.Vector`\n"
784 "   :return: The cell noise vector.\n"
785 "   :rtype: :class:`mathutils.Vector`\n"
786 );
787 static PyObject *M_Noise_cell_vector(PyObject *UNUSED(self), PyObject *args)
788 {
789         PyObject *value;
790         float vec[3], r_vec[3];
791
792         if (!PyArg_ParseTuple(args, "O:cell_vector", &value))
793                 return NULL;
794
795         if (mathutils_array_parse(vec, 3, 3, value, "cell_vector: invalid 'position' arg") == -1)
796                 return NULL;
797
798         cellNoiseV(vec[0], vec[1], vec[2], r_vec);
799         return Vector_CreatePyObject(NULL, 3, Py_NEW, NULL);
800 }
801
802 static PyMethodDef M_Noise_methods[] = {
803         {"seed_set", (PyCFunction) M_Noise_seed_set, METH_VARARGS, M_Noise_seed_set_doc},
804         {"random", (PyCFunction) M_Noise_random, METH_NOARGS, M_Noise_random_doc},
805         {"random_unit_vector", (PyCFunction) M_Noise_random_unit_vector, METH_VARARGS, M_Noise_random_unit_vector_doc},
806         /*{"random_vector", (PyCFunction) M_Noise_random_vector, METH_VARARGS, M_Noise_random_vector_doc},*/
807         {"noise", (PyCFunction) M_Noise_noise, METH_VARARGS, M_Noise_noise_doc},
808         {"noise_vector", (PyCFunction) M_Noise_noise_vector, METH_VARARGS, M_Noise_noise_vector_doc},
809         {"turbulence", (PyCFunction) M_Noise_turbulence, METH_VARARGS, M_Noise_turbulence_doc},
810         {"turbulence_vector", (PyCFunction) M_Noise_turbulence_vector, METH_VARARGS, M_Noise_turbulence_vector_doc},
811         {"fractal", (PyCFunction) M_Noise_fractal, METH_VARARGS, M_Noise_fractal_doc},
812         {"multi_fractal", (PyCFunction) M_Noise_multi_fractal, METH_VARARGS, M_Noise_multi_fractal_doc},
813         {"variable_lacunarity", (PyCFunction) M_Noise_variable_lacunarity, METH_VARARGS, M_Noise_variable_lacunarity_doc},
814         {"hetero_terrain", (PyCFunction) M_Noise_hetero_terrain, METH_VARARGS, M_Noise_hetero_terrain_doc},
815         {"hybrid_multi_fractal", (PyCFunction) M_Noise_hybrid_multi_fractal, METH_VARARGS, M_Noise_hybrid_multi_fractal_doc},
816         {"ridged_multi_fractal", (PyCFunction) M_Noise_ridged_multi_fractal, METH_VARARGS, M_Noise_ridged_multi_fractal_doc},
817         {"voronoi", (PyCFunction) M_Noise_voronoi, METH_VARARGS, M_Noise_voronoi_doc},
818         {"cell", (PyCFunction) M_Noise_cell, METH_VARARGS, M_Noise_cell_doc},
819         {"cell_vector", (PyCFunction) M_Noise_cell_vector, METH_VARARGS, M_Noise_cell_vector_doc},
820         {NULL, NULL, 0, NULL}
821 };
822
823 static struct PyModuleDef M_Noise_module_def = {
824         PyModuleDef_HEAD_INIT,
825         "mathutils.noise",  /* m_name */
826         M_Noise_doc,  /* m_doc */
827         0,     /* m_size */
828         M_Noise_methods,  /* m_methods */
829         NULL,  /* m_reload */
830         NULL,  /* m_traverse */
831         NULL,  /* m_clear */
832         NULL,  /* m_free */
833 };
834
835 /*----------------------------MODULE INIT-------------------------*/
836 PyMODINIT_FUNC PyInit_mathutils_noise(void)
837 {
838         PyObject *submodule = PyModule_Create(&M_Noise_module_def);
839         PyObject *item_types, *item_metrics;
840
841         /* use current time as seed for random number generator by default */
842         setRndSeed(0);
843
844         PyModule_AddObject(submodule, "types", (item_types = PyInit_mathutils_noise_types()));
845         PyDict_SetItemString(PyThreadState_GET()->interp->modules, "noise.types", item_types);
846         Py_INCREF(item_types);
847
848         PyModule_AddObject(submodule, "distance_metrics", (item_metrics = PyInit_mathutils_noise_metrics()));
849         PyDict_SetItemString(PyThreadState_GET()->interp->modules, "noise.distance_metrics", item_metrics);
850         Py_INCREF(item_metrics);
851
852         return submodule;
853 }
854
855 /*----------------------------SUBMODULE INIT-------------------------*/
856 static struct PyModuleDef M_NoiseTypes_module_def = {
857         PyModuleDef_HEAD_INIT,
858         "mathutils.noise.types",  /* m_name */
859         NULL,  /* m_doc */
860         0,     /* m_size */
861         NULL,  /* m_methods */
862         NULL,  /* m_reload */
863         NULL,  /* m_traverse */
864         NULL,  /* m_clear */
865         NULL,  /* m_free */
866 };
867
868 PyMODINIT_FUNC PyInit_mathutils_noise_types(void)
869 {
870         PyObject *submodule = PyModule_Create(&M_NoiseTypes_module_def);
871
872         PyModule_AddIntConstant(submodule, (char *)"BLENDER", TEX_BLENDER);
873         PyModule_AddIntConstant(submodule, (char *)"STDPERLIN", TEX_STDPERLIN);
874         PyModule_AddIntConstant(submodule, (char *)"NEWPERLIN", TEX_NEWPERLIN);
875         PyModule_AddIntConstant(submodule, (char *)"VORONOI_F1", TEX_VORONOI_F1);
876         PyModule_AddIntConstant(submodule, (char *)"VORONOI_F2", TEX_VORONOI_F2);
877         PyModule_AddIntConstant(submodule, (char *)"VORONOI_F3", TEX_VORONOI_F3);
878         PyModule_AddIntConstant(submodule, (char *)"VORONOI_F4", TEX_VORONOI_F4);
879         PyModule_AddIntConstant(submodule, (char *)"VORONOI_F2F1", TEX_VORONOI_F2F1);
880         PyModule_AddIntConstant(submodule, (char *)"VORONOI_CRACKLE", TEX_VORONOI_CRACKLE);
881         PyModule_AddIntConstant(submodule, (char *)"CELLNOISE", TEX_CELLNOISE);
882
883         return submodule;
884 }
885
886 static struct PyModuleDef M_NoiseMetrics_module_def = {
887         PyModuleDef_HEAD_INIT,
888         "mathutils.noise.distance_metrics",  /* m_name */
889         NULL,  /* m_doc */
890         0,     /* m_size */
891         NULL,  /* m_methods */
892         NULL,  /* m_reload */
893         NULL,  /* m_traverse */
894         NULL,  /* m_clear */
895         NULL,  /* m_free */
896 };
897
898 PyMODINIT_FUNC PyInit_mathutils_noise_metrics(void)
899 {
900         PyObject *submodule = PyModule_Create(&M_NoiseMetrics_module_def);
901
902         PyModule_AddIntConstant(submodule, (char *)"DISTANCE", TEX_DISTANCE);
903         PyModule_AddIntConstant(submodule, (char *)"DISTANCE_SQUARED", TEX_DISTANCE_SQUARED);
904         PyModule_AddIntConstant(submodule, (char *)"MANHATTAN", TEX_MANHATTAN);
905         PyModule_AddIntConstant(submodule, (char *)"CHEBYCHEV", TEX_CHEBYCHEV);
906         PyModule_AddIntConstant(submodule, (char *)"MINKOVSKY_HALF", TEX_MINKOVSKY_HALF);
907         PyModule_AddIntConstant(submodule, (char *)"MINKOVSKY_FOUR", TEX_MINKOVSKY_FOUR);
908         PyModule_AddIntConstant(submodule, (char *)"MINKOVSKY", TEX_MINKOVSKY);
909
910         return submodule;
911 }