Cleanup: parenthesize defines
[blender.git] / source / blender / blenlib / intern / 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  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  *
27  */
28
29 /** \file blender/blenlib/intern/noise.c
30  *  \ingroup bli
31  */
32
33 #include <math.h>
34
35 #include "BLI_noise.h"
36
37 /* local */
38 static float noise3_perlin(float vec[3]);
39 //static float turbulence_perlin(const float point[3], float lofreq, float hifreq);
40 //static float turbulencep(float noisesize, float x, float y, float z, int nr);
41
42 /* UNUSED */
43 // #define HASHVEC(x, y, z) hashvectf + 3 * hash[(hash[(hash[(z) & 255] + (y)) & 255] + (x)) & 255]
44
45 /* needed for voronoi */
46 #define HASHPNT(x, y, z) hashpntf + 3 * hash[(hash[(hash[(z) & 255] + (y)) & 255] + (x)) & 255]
47 static const float hashpntf[768] = {
48         0.536902, 0.020915, 0.501445, 0.216316, 0.517036, 0.822466, 0.965315,
49         0.377313, 0.678764, 0.744545, 0.097731, 0.396357, 0.247202, 0.520897,
50         0.613396, 0.542124, 0.146813, 0.255489, 0.810868, 0.638641, 0.980742,
51         0.292316, 0.357948, 0.114382, 0.861377, 0.629634, 0.722530, 0.714103,
52         0.048549, 0.075668, 0.564920, 0.162026, 0.054466, 0.411738, 0.156897,
53         0.887657, 0.599368, 0.074249, 0.170277, 0.225799, 0.393154, 0.301348,
54         0.057434, 0.293849, 0.442745, 0.150002, 0.398732, 0.184582, 0.915200,
55         0.630984, 0.974040, 0.117228, 0.795520, 0.763238, 0.158982, 0.616211,
56         0.250825, 0.906539, 0.316874, 0.676205, 0.234720, 0.667673, 0.792225,
57         0.273671, 0.119363, 0.199131, 0.856716, 0.828554, 0.900718, 0.705960,
58         0.635923, 0.989433, 0.027261, 0.283507, 0.113426, 0.388115, 0.900176,
59         0.637741, 0.438802, 0.715490, 0.043692, 0.202640, 0.378325, 0.450325,
60         0.471832, 0.147803, 0.906899, 0.524178, 0.784981, 0.051483, 0.893369,
61         0.596895, 0.275635, 0.391483, 0.844673, 0.103061, 0.257322, 0.708390,
62         0.504091, 0.199517, 0.660339, 0.376071, 0.038880, 0.531293, 0.216116,
63         0.138672, 0.907737, 0.807994, 0.659582, 0.915264, 0.449075, 0.627128,
64         0.480173, 0.380942, 0.018843, 0.211808, 0.569701, 0.082294, 0.689488,
65         0.573060, 0.593859, 0.216080, 0.373159, 0.108117, 0.595539, 0.021768,
66         0.380297, 0.948125, 0.377833, 0.319699, 0.315249, 0.972805, 0.792270,
67         0.445396, 0.845323, 0.372186, 0.096147, 0.689405, 0.423958, 0.055675,
68         0.117940, 0.328456, 0.605808, 0.631768, 0.372170, 0.213723, 0.032700,
69         0.447257, 0.440661, 0.728488, 0.299853, 0.148599, 0.649212, 0.498381,
70         0.049921, 0.496112, 0.607142, 0.562595, 0.990246, 0.739659, 0.108633,
71         0.978156, 0.209814, 0.258436, 0.876021, 0.309260, 0.600673, 0.713597,
72         0.576967, 0.641402, 0.853930, 0.029173, 0.418111, 0.581593, 0.008394,
73         0.589904, 0.661574, 0.979326, 0.275724, 0.111109, 0.440472, 0.120839,
74         0.521602, 0.648308, 0.284575, 0.204501, 0.153286, 0.822444, 0.300786,
75         0.303906, 0.364717, 0.209038, 0.916831, 0.900245, 0.600685, 0.890002,
76         0.581660, 0.431154, 0.705569, 0.551250, 0.417075, 0.403749, 0.696652,
77         0.292652, 0.911372, 0.690922, 0.323718, 0.036773, 0.258976, 0.274265,
78         0.225076, 0.628965, 0.351644, 0.065158, 0.080340, 0.467271, 0.130643,
79         0.385914, 0.919315, 0.253821, 0.966163, 0.017439, 0.392610, 0.478792,
80         0.978185, 0.072691, 0.982009, 0.097987, 0.731533, 0.401233, 0.107570,
81         0.349587, 0.479122, 0.700598, 0.481751, 0.788429, 0.706864, 0.120086,
82         0.562691, 0.981797, 0.001223, 0.192120, 0.451543, 0.173092, 0.108960,
83         0.549594, 0.587892, 0.657534, 0.396365, 0.125153, 0.666420, 0.385823,
84         0.890916, 0.436729, 0.128114, 0.369598, 0.759096, 0.044677, 0.904752,
85         0.088052, 0.621148, 0.005047, 0.452331, 0.162032, 0.494238, 0.523349,
86         0.741829, 0.698450, 0.452316, 0.563487, 0.819776, 0.492160, 0.004210,
87         0.647158, 0.551475, 0.362995, 0.177937, 0.814722, 0.727729, 0.867126,
88         0.997157, 0.108149, 0.085726, 0.796024, 0.665075, 0.362462, 0.323124,
89         0.043718, 0.042357, 0.315030, 0.328954, 0.870845, 0.683186, 0.467922,
90         0.514894, 0.809971, 0.631979, 0.176571, 0.366320, 0.850621, 0.505555,
91         0.749551, 0.750830, 0.401714, 0.481216, 0.438393, 0.508832, 0.867971,
92         0.654581, 0.058204, 0.566454, 0.084124, 0.548539, 0.902690, 0.779571,
93         0.562058, 0.048082, 0.863109, 0.079290, 0.713559, 0.783496, 0.265266,
94         0.672089, 0.786939, 0.143048, 0.086196, 0.876129, 0.408708, 0.229312,
95         0.629995, 0.206665, 0.207308, 0.710079, 0.341704, 0.264921, 0.028748,
96         0.629222, 0.470173, 0.726228, 0.125243, 0.328249, 0.794187, 0.741340,
97         0.489895, 0.189396, 0.724654, 0.092841, 0.039809, 0.860126, 0.247701,
98         0.655331, 0.964121, 0.672536, 0.044522, 0.690567, 0.837238, 0.631520,
99         0.953734, 0.352484, 0.289026, 0.034152, 0.852575, 0.098454, 0.795529,
100         0.452181, 0.826159, 0.186993, 0.820725, 0.440328, 0.922137, 0.704592,
101         0.915437, 0.738183, 0.733461, 0.193798, 0.929213, 0.161390, 0.318547,
102         0.888751, 0.430968, 0.740837, 0.193544, 0.872253, 0.563074, 0.274598,
103         0.347805, 0.666176, 0.449831, 0.800991, 0.588727, 0.052296, 0.714761,
104         0.420620, 0.570325, 0.057550, 0.210888, 0.407312, 0.662848, 0.924382,
105         0.895958, 0.775198, 0.688605, 0.025721, 0.301913, 0.791408, 0.500602,
106         0.831984, 0.828509, 0.642093, 0.494174, 0.525880, 0.446365, 0.440063,
107         0.763114, 0.630358, 0.223943, 0.333806, 0.906033, 0.498306, 0.241278,
108         0.427640, 0.772683, 0.198082, 0.225379, 0.503894, 0.436599, 0.016503,
109         0.803725, 0.189878, 0.291095, 0.499114, 0.151573, 0.079031, 0.904618,
110         0.708535, 0.273900, 0.067419, 0.317124, 0.936499, 0.716511, 0.543845,
111         0.939909, 0.826574, 0.715090, 0.154864, 0.750150, 0.845808, 0.648108,
112         0.556564, 0.644757, 0.140873, 0.799167, 0.632989, 0.444245, 0.471978,
113         0.435910, 0.359793, 0.216241, 0.007633, 0.337236, 0.857863, 0.380247,
114         0.092517, 0.799973, 0.919000, 0.296798, 0.096989, 0.854831, 0.165369,
115         0.568475, 0.216855, 0.020457, 0.835511, 0.538039, 0.999742, 0.620226,
116         0.244053, 0.060399, 0.323007, 0.294874, 0.988899, 0.384919, 0.735655,
117         0.773428, 0.549776, 0.292882, 0.660611, 0.593507, 0.621118, 0.175269,
118         0.682119, 0.794493, 0.868197, 0.632150, 0.807823, 0.509656, 0.482035,
119         0.001780, 0.259126, 0.358002, 0.280263, 0.192985, 0.290367, 0.208111,
120         0.917633, 0.114422, 0.925491, 0.981110, 0.255570, 0.974862, 0.016629,
121         0.552599, 0.575741, 0.612978, 0.615965, 0.803615, 0.772334, 0.089745,
122         0.838812, 0.634542, 0.113709, 0.755832, 0.577589, 0.667489, 0.529834,
123         0.325660, 0.817597, 0.316557, 0.335093, 0.737363, 0.260951, 0.737073,
124         0.049540, 0.735541, 0.988891, 0.299116, 0.147695, 0.417271, 0.940811,
125         0.524160, 0.857968, 0.176403, 0.244835, 0.485759, 0.033353, 0.280319,
126         0.750688, 0.755809, 0.924208, 0.095956, 0.962504, 0.275584, 0.173715,
127         0.942716, 0.706721, 0.078464, 0.576716, 0.804667, 0.559249, 0.900611,
128         0.646904, 0.432111, 0.927885, 0.383277, 0.269973, 0.114244, 0.574867,
129         0.150703, 0.241855, 0.272871, 0.199950, 0.079719, 0.868566, 0.962833,
130         0.789122, 0.320025, 0.905554, 0.234876, 0.991356, 0.061913, 0.732911,
131         0.785960, 0.874074, 0.069035, 0.658632, 0.309901, 0.023676, 0.791603,
132         0.764661, 0.661278, 0.319583, 0.829650, 0.117091, 0.903124, 0.982098,
133         0.161631, 0.193576, 0.670428, 0.857390, 0.003760, 0.572578, 0.222162,
134         0.114551, 0.420118, 0.530404, 0.470682, 0.525527, 0.764281, 0.040596,
135         0.443275, 0.501124, 0.816161, 0.417467, 0.332172, 0.447565, 0.614591,
136         0.559246, 0.805295, 0.226342, 0.155065, 0.714630, 0.160925, 0.760001,
137         0.453456, 0.093869, 0.406092, 0.264801, 0.720370, 0.743388, 0.373269,
138         0.403098, 0.911923, 0.897249, 0.147038, 0.753037, 0.516093, 0.739257,
139         0.175018, 0.045768, 0.735857, 0.801330, 0.927708, 0.240977, 0.591870,
140         0.921831, 0.540733, 0.149100, 0.423152, 0.806876, 0.397081, 0.061100,
141         0.811630, 0.044899, 0.460915, 0.961202, 0.822098, 0.971524, 0.867608,
142         0.773604, 0.226616, 0.686286, 0.926972, 0.411613, 0.267873, 0.081937,
143         0.226124, 0.295664, 0.374594, 0.533240, 0.237876, 0.669629, 0.599083,
144         0.513081, 0.878719, 0.201577, 0.721296, 0.495038, 0.079760, 0.965959,
145         0.233090, 0.052496, 0.714748, 0.887844, 0.308724, 0.972885, 0.723337,
146         0.453089, 0.914474, 0.704063, 0.823198, 0.834769, 0.906561, 0.919600,
147         0.100601, 0.307564, 0.901977, 0.468879, 0.265376, 0.885188, 0.683875,
148         0.868623, 0.081032, 0.466835, 0.199087, 0.663437, 0.812241, 0.311337,
149         0.821361, 0.356628, 0.898054, 0.160781, 0.222539, 0.714889, 0.490287,
150         0.984915, 0.951755, 0.964097, 0.641795, 0.815472, 0.852732, 0.862074,
151         0.051108, 0.440139, 0.323207, 0.517171, 0.562984, 0.115295, 0.743103,
152         0.977914, 0.337596, 0.440694, 0.535879, 0.959427, 0.351427, 0.704361,
153         0.010826, 0.131162, 0.577080, 0.349572, 0.774892, 0.425796, 0.072697,
154         0.500001, 0.267322, 0.909654, 0.206176, 0.223987, 0.937698, 0.323423,
155         0.117501, 0.490308, 0.474372, 0.689943, 0.168671, 0.719417, 0.188928,
156         0.330464, 0.265273, 0.446271, 0.171933, 0.176133, 0.474616, 0.140182,
157         0.114246, 0.905043, 0.713870, 0.555261, 0.951333
158 };
159
160 const unsigned char hash[512] = {
161         0xA2, 0xA0, 0x19, 0x3B, 0xF8, 0xEB, 0xAA, 0xEE, 0xF3, 0x1C, 0x67, 0x28, 0x1D, 0xED, 0x0,  0xDE, 0x95, 0x2E, 0xDC,
162         0x3F, 0x3A, 0x82, 0x35, 0x4D, 0x6C, 0xBA, 0x36, 0xD0, 0xF6, 0xC,  0x79, 0x32, 0xD1, 0x59, 0xF4, 0x8,  0x8B, 0x63,
163         0x89, 0x2F, 0xB8, 0xB4, 0x97, 0x83, 0xF2, 0x8F, 0x18, 0xC7, 0x51, 0x14, 0x65, 0x87, 0x48, 0x20, 0x42, 0xA8, 0x80,
164         0xB5, 0x40, 0x13, 0xB2, 0x22, 0x7E, 0x57, 0xBC, 0x7F, 0x6B, 0x9D, 0x86, 0x4C, 0xC8, 0xDB, 0x7C, 0xD5, 0x25, 0x4E,
165         0x5A, 0x55, 0x74, 0x50, 0xCD, 0xB3, 0x7A, 0xBB, 0xC3, 0xCB, 0xB6, 0xE2, 0xE4, 0xEC, 0xFD, 0x98, 0xB,  0x96, 0xD3,
166         0x9E, 0x5C, 0xA1, 0x64, 0xF1, 0x81, 0x61, 0xE1, 0xC4, 0x24, 0x72, 0x49, 0x8C, 0x90, 0x4B, 0x84, 0x34, 0x38, 0xAB,
167         0x78, 0xCA, 0x1F, 0x1,  0xD7, 0x93, 0x11, 0xC1, 0x58, 0xA9, 0x31, 0xF9, 0x44, 0x6D, 0xBF, 0x33, 0x9C, 0x5F, 0x9,
168         0x94, 0xA3, 0x85, 0x6,  0xC6, 0x9A, 0x1E, 0x7B, 0x46, 0x15, 0x30, 0x27, 0x2B, 0x1B, 0x71, 0x3C, 0x5B, 0xD6, 0x6F,
169         0x62, 0xAC, 0x4F, 0xC2, 0xC0, 0xE,  0xB1, 0x23, 0xA7, 0xDF, 0x47, 0xB0, 0x77, 0x69, 0x5,  0xE9, 0xE6, 0xE7, 0x76,
170         0x73, 0xF,  0xFE, 0x6E, 0x9B, 0x56, 0xEF, 0x12, 0xA5, 0x37, 0xFC, 0xAE, 0xD9, 0x3,  0x8E, 0xDD, 0x10, 0xB9, 0xCE,
171         0xC9, 0x8D, 0xDA, 0x2A, 0xBD, 0x68, 0x17, 0x9F, 0xBE, 0xD4, 0xA,  0xCC, 0xD2, 0xE8, 0x43, 0x3D, 0x70, 0xB7, 0x2,
172         0x7D, 0x99, 0xD8, 0xD,  0x60, 0x8A, 0x4,  0x2C, 0x3E, 0x92, 0xE5, 0xAF, 0x53, 0x7,  0xE0, 0x29, 0xA6, 0xC5, 0xE3,
173         0xF5, 0xF7, 0x4A, 0x41, 0x26, 0x6A, 0x16, 0x5E, 0x52, 0x2D, 0x21, 0xAD, 0xF0, 0x91, 0xFF, 0xEA, 0x54, 0xFA, 0x66,
174         0x1A, 0x45, 0x39, 0xCF, 0x75, 0xA4, 0x88, 0xFB, 0x5D, 0xA2, 0xA0, 0x19, 0x3B, 0xF8, 0xEB, 0xAA, 0xEE, 0xF3, 0x1C,
175         0x67, 0x28, 0x1D, 0xED, 0x0,  0xDE, 0x95, 0x2E, 0xDC, 0x3F, 0x3A, 0x82, 0x35, 0x4D, 0x6C, 0xBA, 0x36, 0xD0, 0xF6,
176         0xC,  0x79, 0x32, 0xD1, 0x59, 0xF4, 0x8,  0x8B, 0x63, 0x89, 0x2F, 0xB8, 0xB4, 0x97, 0x83, 0xF2, 0x8F, 0x18, 0xC7,
177         0x51, 0x14, 0x65, 0x87, 0x48, 0x20, 0x42, 0xA8, 0x80, 0xB5, 0x40, 0x13, 0xB2, 0x22, 0x7E, 0x57, 0xBC, 0x7F, 0x6B,
178         0x9D, 0x86, 0x4C, 0xC8, 0xDB, 0x7C, 0xD5, 0x25, 0x4E, 0x5A, 0x55, 0x74, 0x50, 0xCD, 0xB3, 0x7A, 0xBB, 0xC3, 0xCB,
179         0xB6, 0xE2, 0xE4, 0xEC, 0xFD, 0x98, 0xB,  0x96, 0xD3, 0x9E, 0x5C, 0xA1, 0x64, 0xF1, 0x81, 0x61, 0xE1, 0xC4, 0x24,
180         0x72, 0x49, 0x8C, 0x90, 0x4B, 0x84, 0x34, 0x38, 0xAB, 0x78, 0xCA, 0x1F, 0x1,  0xD7, 0x93, 0x11, 0xC1, 0x58, 0xA9,
181         0x31, 0xF9, 0x44, 0x6D, 0xBF, 0x33, 0x9C, 0x5F, 0x9,  0x94, 0xA3, 0x85, 0x6,  0xC6, 0x9A, 0x1E, 0x7B, 0x46, 0x15,
182         0x30, 0x27, 0x2B, 0x1B, 0x71, 0x3C, 0x5B, 0xD6, 0x6F, 0x62, 0xAC, 0x4F, 0xC2, 0xC0, 0xE,  0xB1, 0x23, 0xA7, 0xDF,
183         0x47, 0xB0, 0x77, 0x69, 0x5,  0xE9, 0xE6, 0xE7, 0x76, 0x73, 0xF,  0xFE, 0x6E, 0x9B, 0x56, 0xEF, 0x12, 0xA5, 0x37,
184         0xFC, 0xAE, 0xD9, 0x3,  0x8E, 0xDD, 0x10, 0xB9, 0xCE, 0xC9, 0x8D, 0xDA, 0x2A, 0xBD, 0x68, 0x17, 0x9F, 0xBE, 0xD4,
185         0xA,  0xCC, 0xD2, 0xE8, 0x43, 0x3D, 0x70, 0xB7, 0x2,  0x7D, 0x99, 0xD8, 0xD,  0x60, 0x8A, 0x4,  0x2C, 0x3E, 0x92,
186         0xE5, 0xAF, 0x53, 0x7,  0xE0, 0x29, 0xA6, 0xC5, 0xE3, 0xF5, 0xF7, 0x4A, 0x41, 0x26, 0x6A, 0x16, 0x5E, 0x52, 0x2D,
187         0x21, 0xAD, 0xF0, 0x91, 0xFF, 0xEA, 0x54, 0xFA, 0x66, 0x1A, 0x45, 0x39, 0xCF, 0x75, 0xA4, 0x88, 0xFB, 0x5D,
188 };
189
190
191 const float hashvectf[768] = {
192         0.33783, 0.715698, -0.611206, -0.944031, -0.326599, -0.045624, -0.101074, -0.416443, -0.903503, 0.799286, 0.49411,
193         -0.341949, -0.854645, 0.518036, 0.033936, 0.42514, -0.437866, -0.792114, -0.358948, 0.597046, 0.717377, -0.985413,
194         0.144714, 0.089294, -0.601776, -0.33728, -0.723907, -0.449921, 0.594513, 0.666382, 0.208313, -0.10791, 0.972076,
195         0.575317, 0.060425, 0.815643, 0.293365, -0.875702, -0.383453, 0.293762, 0.465759, 0.834686, -0.846008, -0.233398,
196         -0.47934, -0.115814, 0.143036, -0.98291, 0.204681, -0.949036, -0.239532, 0.946716, -0.263947, 0.184326, -0.235596,
197         0.573822, 0.784332, 0.203705, -0.372253, -0.905487, 0.756989, -0.651031, 0.055298, 0.497803, 0.814697, -0.297363,
198         -0.16214, 0.063995, -0.98468, -0.329254, 0.834381, 0.441925, 0.703827, -0.527039, -0.476227, 0.956421, 0.266113,
199         0.119781, 0.480133, 0.482849, 0.7323, -0.18631, 0.961212, -0.203125, -0.748474, -0.656921, -0.090393, -0.085052,
200         -0.165253, 0.982544, -0.76947, 0.628174, -0.115234, 0.383148, 0.537659, 0.751068, 0.616486, -0.668488, -0.415924,
201         -0.259979, -0.630005, 0.73175, 0.570953, -0.087952, 0.816223, -0.458008, 0.023254, 0.888611, -0.196167, 0.976563,
202         -0.088287, -0.263885, -0.69812, -0.665527, 0.437134, -0.892273, -0.112793, -0.621674, -0.230438, 0.748566, 0.232422,
203         0.900574, -0.367249, 0.22229, -0.796143, 0.562744, -0.665497, -0.73764, 0.11377, 0.670135, 0.704803, 0.232605,
204         0.895599, 0.429749, -0.114655, -0.11557, -0.474243, 0.872742, 0.621826, 0.604004, -0.498444, -0.832214, 0.012756,
205         0.55426, -0.702484, 0.705994, -0.089661, -0.692017, 0.649292, 0.315399, -0.175995, -0.977997, 0.111877, 0.096954,
206         -0.04953, 0.994019, 0.635284, -0.606689, -0.477783, -0.261261, -0.607422, -0.750153, 0.983276, 0.165436, 0.075958,
207         -0.29837, 0.404083, -0.864655, -0.638672, 0.507721, 0.578156, 0.388214, 0.412079, 0.824249, 0.556183, -0.208832,
208         0.804352, 0.778442, 0.562012, 0.27951, -0.616577, 0.781921, -0.091522, 0.196289, 0.051056, 0.979187, -0.121216,
209         0.207153, -0.970734, -0.173401, -0.384735, 0.906555, 0.161499, -0.723236, -0.671387, 0.178497, -0.006226, -0.983887,
210         -0.126038, 0.15799, 0.97934, 0.830475, -0.024811, 0.556458, -0.510132, -0.76944, 0.384247, 0.81424, 0.200104,
211         -0.544891, -0.112549, -0.393311, -0.912445, 0.56189, 0.152222, -0.813049, 0.198914, -0.254517, -0.946381, -0.41217,
212         0.690979, -0.593811, -0.407257, 0.324524, 0.853668, -0.690186, 0.366119, -0.624115, -0.428345, 0.844147, -0.322296,
213         -0.21228, -0.297546, -0.930756, -0.273071, 0.516113, 0.811798, 0.928314, 0.371643, 0.007233, 0.785828, -0.479218,
214         -0.390778, -0.704895, 0.058929, 0.706818, 0.173248, 0.203583, 0.963562, 0.422211, -0.904297, -0.062469, -0.363312,
215         -0.182465, 0.913605, 0.254028, -0.552307, -0.793945, -0.28891, -0.765747, -0.574554, 0.058319, 0.291382, 0.954803,
216         0.946136, -0.303925, 0.111267, -0.078156, 0.443695, -0.892731, 0.182098, 0.89389, 0.409515, -0.680298, -0.213318,
217         0.701141, 0.062469, 0.848389, -0.525635, -0.72879, -0.641846, 0.238342, -0.88089, 0.427673, 0.202637, -0.532501,
218         -0.21405, 0.818878, 0.948975, -0.305084, 0.07962, 0.925446, 0.374664, 0.055817, 0.820923, 0.565491, 0.079102,
219         0.25882, 0.099792, -0.960724, -0.294617, 0.910522, 0.289978, 0.137115, 0.320038, -0.937408, -0.908386, 0.345276,
220         -0.235718, -0.936218, 0.138763, 0.322754, 0.366577, 0.925934, -0.090637, 0.309296, -0.686829, -0.657684, 0.66983,
221         0.024445, 0.742065, -0.917999, -0.059113, -0.392059, 0.365509, 0.462158, -0.807922, 0.083374, 0.996399, -0.014801,
222         0.593842, 0.253143, -0.763672, 0.974976, -0.165466, 0.148285, 0.918976, 0.137299, 0.369537, 0.294952, 0.694977,
223         0.655731, 0.943085, 0.152618, -0.295319, 0.58783, -0.598236, 0.544495, 0.203796, 0.678223, 0.705994, -0.478821,
224         -0.661011, 0.577667, 0.719055, -0.1698, -0.673828, -0.132172, -0.965332, 0.225006, -0.981873, -0.14502, 0.121979,
225         0.763458, 0.579742, 0.284546, -0.893188, 0.079681, 0.442474, -0.795776, -0.523804, 0.303802, 0.734955, 0.67804,
226         -0.007446, 0.15506, 0.986267, -0.056183, 0.258026, 0.571503, -0.778931, -0.681549, -0.702087, -0.206116, -0.96286,
227         -0.177185, 0.203613, -0.470978, -0.515106, 0.716095, -0.740326, 0.57135, 0.354095, -0.56012, -0.824982, -0.074982,
228         -0.507874, 0.753204, 0.417969, -0.503113, 0.038147, 0.863342, 0.594025, 0.673553, -0.439758, -0.119873, -0.005524,
229         -0.992737, 0.098267, -0.213776, 0.971893, -0.615631, 0.643951, 0.454163, 0.896851, -0.441071, 0.032166, -0.555023,
230         0.750763, -0.358093, 0.398773, 0.304688, 0.864929, -0.722961, 0.303589, 0.620544, -0.63559, -0.621948, -0.457306,
231         -0.293243, 0.072327, 0.953278, -0.491638, 0.661041, -0.566772, -0.304199, -0.572083, -0.761688, 0.908081, -0.398956,
232         0.127014, -0.523621, -0.549683, -0.650848, -0.932922, -0.19986, 0.299408, 0.099426, 0.140869, 0.984985, -0.020325,
233         -0.999756, -0.002319, 0.952667, 0.280853, -0.11615, -0.971893, 0.082581, 0.220337, 0.65921, 0.705292, -0.260651,
234         0.733063, -0.175537, 0.657043, -0.555206, 0.429504, -0.712189, 0.400421, -0.89859, 0.179352, 0.750885, -0.19696,
235         0.630341, 0.785675, -0.569336, 0.241821, -0.058899, -0.464111, 0.883789, 0.129608, -0.94519, 0.299622, -0.357819,
236         0.907654, 0.219238, -0.842133, -0.439117, -0.312927, -0.313477, 0.84433, 0.434479, -0.241211, 0.053253, 0.968994,
237         0.063873, 0.823273, 0.563965, 0.476288, 0.862152, -0.172516, 0.620941, -0.298126, 0.724915, 0.25238, -0.749359,
238         -0.612122, -0.577545, 0.386566, 0.718994, -0.406342, -0.737976, 0.538696, 0.04718, 0.556305, 0.82959, -0.802856,
239         0.587463, 0.101166, -0.707733, -0.705963, 0.026428, 0.374908, 0.68457, 0.625092, 0.472137, 0.208405, -0.856506,
240         -0.703064, -0.581085, -0.409821, -0.417206, -0.736328, 0.532623, -0.447876, -0.20285, -0.870728, 0.086945,
241         -0.990417, 0.107086, 0.183685, 0.018341, -0.982788, 0.560638, -0.428864, 0.708282, 0.296722, -0.952576, -0.0672,
242         0.135773, 0.990265, 0.030243, -0.068787, 0.654724, 0.752686, 0.762604, -0.551758, 0.337585, -0.819611, -0.407684,
243         0.402466, -0.727844, -0.55072, -0.408539, -0.855774, -0.480011, 0.19281, 0.693176, -0.079285, 0.716339, 0.226013,
244         0.650116, -0.725433, 0.246704, 0.953369, -0.173553, -0.970398, -0.239227, -0.03244, 0.136383, -0.394318, 0.908752,
245         0.813232, 0.558167, 0.164368, 0.40451, 0.549042, -0.731323, -0.380249, -0.566711, 0.730865, 0.022156, 0.932739,
246         0.359741, 0.00824, 0.996552, -0.082306, 0.956635, -0.065338, -0.283722, -0.743561, 0.008209, 0.668579, -0.859589,
247         -0.509674, 0.035767, -0.852234, 0.363678, -0.375977, -0.201965, -0.970795, -0.12915, 0.313477, 0.947327, 0.06546,
248         -0.254028, -0.528259, 0.81015, 0.628052, 0.601105, 0.49411, -0.494385, 0.868378, 0.037933, 0.275635, -0.086426,
249         0.957336, -0.197937, 0.468903, -0.860748, 0.895599, 0.399384, 0.195801, 0.560791, 0.825012, -0.069214, 0.304199,
250         -0.849487, 0.43103, 0.096375, 0.93576, 0.339111, -0.051422, 0.408966, -0.911072, 0.330444, 0.942841, -0.042389,
251         -0.452362, -0.786407, 0.420563, 0.134308, -0.933472, -0.332489, 0.80191, -0.566711, -0.188934, -0.987946, -0.105988,
252         0.112518, -0.24408, 0.892242, -0.379791, -0.920502, 0.229095, -0.316376, 0.7789, 0.325958, 0.535706, -0.912872,
253         0.185211, -0.36377, -0.184784, 0.565369, -0.803833, -0.018463, 0.119537, 0.992615, -0.259247, -0.935608, 0.239532,
254         -0.82373, -0.449127, -0.345947, -0.433105, 0.659515, 0.614349, -0.822754, 0.378845, -0.423676, 0.687195, -0.674835,
255         -0.26889, -0.246582, -0.800842, 0.545715, -0.729187, -0.207794, 0.651978, 0.653534, -0.610443, -0.447388, 0.492584,
256         -0.023346, 0.869934, 0.609039, 0.009094, -0.79306, 0.962494, -0.271088, -0.00885, 0.2659, -0.004913, 0.963959,
257         0.651245, 0.553619, -0.518951, 0.280548, -0.84314, 0.458618, -0.175293, -0.983215, 0.049805, 0.035339, -0.979919,
258         0.196045, -0.982941, 0.164307, -0.082245, 0.233734, -0.97226, -0.005005, -0.747253, -0.611328, 0.260437, 0.645599,
259         0.592773, 0.481384, 0.117706, -0.949524, -0.29068, -0.535004, -0.791901, -0.294312, -0.627167, -0.214447, 0.748718,
260         -0.047974, -0.813477, -0.57959, -0.175537, 0.477264, -0.860992, 0.738556, -0.414246, -0.53183, 0.562561, -0.704071,
261         0.433289, -0.754944, 0.64801, -0.100586, 0.114716, 0.044525, -0.992371, 0.966003, 0.244873, -0.082764,
262 };
263
264 /**************************/
265 /*  IMPROVED PERLIN NOISE */
266 /**************************/
267
268 static float lerp(float t, float a, float b)
269 {
270         return (a + t * (b - a));
271 }
272
273 static float npfade(float t)
274 {
275         return (t * t * t * (t * (t * 6.0f - 15.0f) + 10.0f));
276 }
277
278 static float grad(int hash_val, float x, float y, float z)
279 {
280         int h = hash_val & 15;                 /* CONVERT LO 4 BITS OF HASH CODE */
281         float u = h < 8 ? x : y;               /* INTO 12 GRADIENT DIRECTIONS. */
282         float v = h < 4 ? y : h == 12 || h == 14 ? x : z;
283         return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
284 }
285
286 /* instead of adding another permutation array, just use hash table defined above */
287 static float newPerlin(float x, float y, float z)
288 {
289         int A, AA, AB, B, BA, BB;
290         float u = floor(x), v = floor(y), w = floor(z);
291         int X = ((int)u) & 255, Y = ((int)v) & 255, Z = ((int)w) & 255;   /* FIND UNIT CUBE THAT CONTAINS POINT */
292         x -= u;             /* FIND RELATIVE X,Y,Z */
293         y -= v;             /* OF POINT IN CUBE. */
294         z -= w;
295         u = npfade(x);      /* COMPUTE FADE CURVES */
296         v = npfade(y);      /* FOR EACH OF X,Y,Z. */
297         w = npfade(z);
298         A = hash[X    ] + Y;  AA = hash[A] + Z;  AB = hash[A + 1] + Z;      /* HASH COORDINATES OF */
299         B = hash[X + 1] + Y;  BA = hash[B] + Z;  BB = hash[B + 1] + Z;      /* THE 8 CUBE CORNERS, */
300         return lerp(w, lerp(v, lerp(u, grad(hash[AA   ],  x,     y,     z    ),   /* AND ADD */
301                                        grad(hash[BA   ],  x - 1, y,     z    )),  /* BLENDED */
302                                lerp(u, grad(hash[AB   ],  x,     y - 1, z    ),   /* RESULTS */
303                                        grad(hash[BB   ],  x - 1, y - 1, z    ))), /* FROM  8 */
304                        lerp(v, lerp(u, grad(hash[AA + 1], x,     y,     z - 1),   /* CORNERS */
305                                        grad(hash[BA + 1], x - 1, y,     z - 1)),  /* OF CUBE */
306                                lerp(u, grad(hash[AB + 1], x,     y - 1, z - 1),
307                                        grad(hash[BB + 1], x - 1, y - 1, z - 1))));
308 }
309
310 /* for use with BLI_gNoise()/BLI_gTurbulence(), returns unsigned improved perlin noise */
311 static float newPerlinU(float x, float y, float z)
312 {
313         return (0.5f + 0.5f * newPerlin(x, y, z));
314 }
315
316
317 /**************************/
318 /* END OF IMPROVED PERLIN */
319 /**************************/
320
321 /* Was BLI_hnoise(), removed noisesize, so other functions can call it without scaling. */
322 static float orgBlenderNoise(float x, float y, float z)
323 {
324         register float cn1, cn2, cn3, cn4, cn5, cn6, i;
325         register const float *h;
326         float fx, fy, fz, ox, oy, oz, jx, jy, jz;
327         float n = 0.5;
328         int ix, iy, iz, b00, b01, b10, b11, b20, b21;
329
330         fx = floor(x);
331         fy = floor(y);
332         fz = floor(z);
333
334         ox = x - fx;
335         oy = y - fy;
336         oz = z - fz;
337
338         ix = (int)fx;
339         iy = (int)fy;
340         iz = (int)fz;
341
342         jx = ox - 1;
343         jy = oy - 1;
344         jz = oz - 1;
345
346         cn1 = ox * ox; cn2 = oy * oy; cn3 = oz * oz;
347         cn4 = jx * jx; cn5 = jy * jy; cn6 = jz * jz;
348
349         cn1 = 1.0f - 3.0f * cn1 + 2.0f * cn1 * ox;
350         cn2 = 1.0f - 3.0f * cn2 + 2.0f * cn2 * oy;
351         cn3 = 1.0f - 3.0f * cn3 + 2.0f * cn3 * oz;
352         cn4 = 1.0f - 3.0f * cn4 - 2.0f * cn4 * jx;
353         cn5 = 1.0f - 3.0f * cn5 - 2.0f * cn5 * jy;
354         cn6 = 1.0f - 3.0f * cn6 - 2.0f * cn6 * jz;
355
356         b00 = hash[hash[ix & 255] + (iy & 255)];
357         b10 = hash[hash[(ix + 1) & 255] + (iy & 255)];
358         b01 = hash[hash[ix & 255] + ((iy + 1) & 255)];
359         b11 = hash[hash[(ix + 1) & 255] + ((iy + 1) & 255)];
360
361         b20 = iz & 255; b21 = (iz + 1) & 255;
362
363         /* 0 */
364         i = (cn1 * cn2 * cn3);
365         h = hashvectf + 3 * hash[b20 + b00];
366         n += i * (h[0] * ox + h[1] * oy + h[2] * oz);
367         /* 1 */
368         i = (cn1 * cn2 * cn6);
369         h = hashvectf + 3 * hash[b21 + b00];
370         n += i * (h[0] * ox + h[1] * oy + h[2] * jz);
371         /* 2 */
372         i = (cn1 * cn5 * cn3);
373         h = hashvectf + 3 * hash[b20 + b01];
374         n += i * (h[0] * ox + h[1] * jy + h[2] * oz);
375         /* 3 */
376         i = (cn1 * cn5 * cn6);
377         h = hashvectf + 3 * hash[b21 + b01];
378         n += i * (h[0] * ox + h[1] * jy + h[2] * jz);
379         /* 4 */
380         i = cn4 * cn2 * cn3;
381         h = hashvectf + 3 * hash[b20 + b10];
382         n += i * (h[0] * jx + h[1] * oy + h[2] * oz);
383         /* 5 */
384         i = cn4 * cn2 * cn6;
385         h = hashvectf + 3 * hash[b21 + b10];
386         n += i * (h[0] * jx + h[1] * oy + h[2] * jz);
387         /* 6 */
388         i = cn4 * cn5 * cn3;
389         h = hashvectf + 3 * hash[b20 + b11];
390         n +=  i * (h[0] * jx + h[1] * jy + h[2] * oz);
391         /* 7 */
392         i = (cn4 * cn5 * cn6);
393         h = hashvectf + 3 * hash[b21 + b11];
394         n += i * (h[0] * jx + h[1] * jy + h[2] * jz);
395
396         if      (n < 0.0f) n = 0.0f;
397         else if (n > 1.0f) n = 1.0f;
398         return n;
399 }
400
401 /* as orgBlenderNoise(), returning signed noise */
402 static float orgBlenderNoiseS(float x, float y, float z)
403 {
404         return (2.0f * orgBlenderNoise(x, y, z) - 1.0f);
405 }
406
407 /* separated from orgBlenderNoise above, with scaling */
408 float BLI_hnoise(float noisesize, float x, float y, float z)
409 {
410         if (noisesize == 0.0f) return 0.0f;
411         x = (1.0f + x) / noisesize;
412         y = (1.0f + y) / noisesize;
413         z = (1.0f + z) / noisesize;
414         return orgBlenderNoise(x, y, z);
415 }
416
417
418 /* original turbulence functions */
419 float BLI_turbulence(float noisesize, float x, float y, float z, int nr)
420 {
421         float s, d = 0.5, div = 1.0;
422
423         s = BLI_hnoise(noisesize, x, y, z);
424         
425         while (nr > 0) {
426         
427                 s += d * BLI_hnoise(noisesize * d, x, y, z);
428                 div += d;
429                 d *= 0.5f;
430
431                 nr--;
432         }
433         return s / div;
434 }
435
436 float BLI_turbulence1(float noisesize, float x, float y, float z, int nr)
437 {
438         float s, d = 0.5, div = 1.0;
439
440         s = fabsf((-1.0f + 2.0f * BLI_hnoise(noisesize, x, y, z)));
441         
442         while (nr > 0) {
443         
444                 s += fabsf(d * (-1.0f + 2.0f * BLI_hnoise(noisesize * d, x, y, z)));
445                 div += d;
446                 d *= 0.5f;
447                 
448                 nr--;
449         }
450         return s / div;
451 }
452
453 /* ********************* FROM PERLIN HIMSELF: ******************** */
454
455 static const char g_perlin_data_ub[512 + 2] = {
456         0xA2, 0xA0, 0x19, 0x3B, 0xF8, 0xEB, 0xAA, 0xEE, 0xF3, 0x1C, 0x67, 0x28,
457         0x1D, 0xED, 0x0,  0xDE, 0x95, 0x2E, 0xDC, 0x3F, 0x3A, 0x82, 0x35, 0x4D,
458         0x6C, 0xBA, 0x36, 0xD0, 0xF6, 0xC,  0x79, 0x32, 0xD1, 0x59, 0xF4, 0x8,
459         0x8B, 0x63, 0x89, 0x2F, 0xB8, 0xB4, 0x97, 0x83, 0xF2, 0x8F, 0x18, 0xC7,
460         0x51, 0x14, 0x65, 0x87, 0x48, 0x20, 0x42, 0xA8, 0x80, 0xB5, 0x40, 0x13,
461         0xB2, 0x22, 0x7E, 0x57, 0xBC, 0x7F, 0x6B, 0x9D, 0x86, 0x4C, 0xC8, 0xDB,
462         0x7C, 0xD5, 0x25, 0x4E, 0x5A, 0x55, 0x74, 0x50, 0xCD, 0xB3, 0x7A, 0xBB,
463         0xC3, 0xCB, 0xB6, 0xE2, 0xE4, 0xEC, 0xFD, 0x98, 0xB,  0x96, 0xD3, 0x9E,
464         0x5C, 0xA1, 0x64, 0xF1, 0x81, 0x61, 0xE1, 0xC4, 0x24, 0x72, 0x49, 0x8C,
465         0x90, 0x4B, 0x84, 0x34, 0x38, 0xAB, 0x78, 0xCA, 0x1F, 0x1,  0xD7, 0x93,
466         0x11, 0xC1, 0x58, 0xA9, 0x31, 0xF9, 0x44, 0x6D, 0xBF, 0x33, 0x9C, 0x5F,
467         0x9,  0x94, 0xA3, 0x85, 0x6,  0xC6, 0x9A, 0x1E, 0x7B, 0x46, 0x15, 0x30,
468         0x27, 0x2B, 0x1B, 0x71, 0x3C, 0x5B, 0xD6, 0x6F, 0x62, 0xAC, 0x4F, 0xC2,
469         0xC0, 0xE,  0xB1, 0x23, 0xA7, 0xDF, 0x47, 0xB0, 0x77, 0x69, 0x5,  0xE9,
470         0xE6, 0xE7, 0x76, 0x73, 0xF,  0xFE, 0x6E, 0x9B, 0x56, 0xEF, 0x12, 0xA5,
471         0x37, 0xFC, 0xAE, 0xD9, 0x3,  0x8E, 0xDD, 0x10, 0xB9, 0xCE, 0xC9, 0x8D,
472         0xDA, 0x2A, 0xBD, 0x68, 0x17, 0x9F, 0xBE, 0xD4, 0xA,  0xCC, 0xD2, 0xE8,
473         0x43, 0x3D, 0x70, 0xB7, 0x2,  0x7D, 0x99, 0xD8, 0xD,  0x60, 0x8A, 0x4,
474         0x2C, 0x3E, 0x92, 0xE5, 0xAF, 0x53, 0x7,  0xE0, 0x29, 0xA6, 0xC5, 0xE3,
475         0xF5, 0xF7, 0x4A, 0x41, 0x26, 0x6A, 0x16, 0x5E, 0x52, 0x2D, 0x21, 0xAD,
476         0xF0, 0x91, 0xFF, 0xEA, 0x54, 0xFA, 0x66, 0x1A, 0x45, 0x39, 0xCF, 0x75,
477         0xA4, 0x88, 0xFB, 0x5D, 0xA2, 0xA0, 0x19, 0x3B, 0xF8, 0xEB, 0xAA, 0xEE,
478         0xF3, 0x1C, 0x67, 0x28, 0x1D, 0xED, 0x0,  0xDE, 0x95, 0x2E, 0xDC, 0x3F,
479         0x3A, 0x82, 0x35, 0x4D, 0x6C, 0xBA, 0x36, 0xD0, 0xF6, 0xC,  0x79, 0x32,
480         0xD1, 0x59, 0xF4, 0x8,  0x8B, 0x63, 0x89, 0x2F, 0xB8, 0xB4, 0x97, 0x83,
481         0xF2, 0x8F, 0x18, 0xC7, 0x51, 0x14, 0x65, 0x87, 0x48, 0x20, 0x42, 0xA8,
482         0x80, 0xB5, 0x40, 0x13, 0xB2, 0x22, 0x7E, 0x57, 0xBC, 0x7F, 0x6B, 0x9D,
483         0x86, 0x4C, 0xC8, 0xDB, 0x7C, 0xD5, 0x25, 0x4E, 0x5A, 0x55, 0x74, 0x50,
484         0xCD, 0xB3, 0x7A, 0xBB, 0xC3, 0xCB, 0xB6, 0xE2, 0xE4, 0xEC, 0xFD, 0x98,
485         0xB,  0x96, 0xD3, 0x9E, 0x5C, 0xA1, 0x64, 0xF1, 0x81, 0x61, 0xE1, 0xC4,
486         0x24, 0x72, 0x49, 0x8C, 0x90, 0x4B, 0x84, 0x34, 0x38, 0xAB, 0x78, 0xCA,
487         0x1F, 0x1,  0xD7, 0x93, 0x11, 0xC1, 0x58, 0xA9, 0x31, 0xF9, 0x44, 0x6D,
488         0xBF, 0x33, 0x9C, 0x5F, 0x9,  0x94, 0xA3, 0x85, 0x6,  0xC6, 0x9A, 0x1E,
489         0x7B, 0x46, 0x15, 0x30, 0x27, 0x2B, 0x1B, 0x71, 0x3C, 0x5B, 0xD6, 0x6F,
490         0x62, 0xAC, 0x4F, 0xC2, 0xC0, 0xE,  0xB1, 0x23, 0xA7, 0xDF, 0x47, 0xB0,
491         0x77, 0x69, 0x5,  0xE9, 0xE6, 0xE7, 0x76, 0x73, 0xF,  0xFE, 0x6E, 0x9B,
492         0x56, 0xEF, 0x12, 0xA5, 0x37, 0xFC, 0xAE, 0xD9, 0x3,  0x8E, 0xDD, 0x10,
493         0xB9, 0xCE, 0xC9, 0x8D, 0xDA, 0x2A, 0xBD, 0x68, 0x17, 0x9F, 0xBE, 0xD4,
494         0xA,  0xCC, 0xD2, 0xE8, 0x43, 0x3D, 0x70, 0xB7, 0x2,  0x7D, 0x99, 0xD8,
495         0xD,  0x60, 0x8A, 0x4,  0x2C, 0x3E, 0x92, 0xE5, 0xAF, 0x53, 0x7,  0xE0,
496         0x29, 0xA6, 0xC5, 0xE3, 0xF5, 0xF7, 0x4A, 0x41, 0x26, 0x6A, 0x16, 0x5E,
497         0x52, 0x2D, 0x21, 0xAD, 0xF0, 0x91, 0xFF, 0xEA, 0x54, 0xFA, 0x66, 0x1A,
498         0x45, 0x39, 0xCF, 0x75, 0xA4, 0x88, 0xFB, 0x5D, 0xA2, 0xA0
499 };
500
501
502 static const float g_perlin_data_v3[512 + 2][3] = {
503         {0.33783, 0.715698, -0.611206},
504         {-0.944031, -0.326599, -0.045624},
505         {-0.101074, -0.416443, -0.903503},
506         {0.799286, 0.49411, -0.341949},
507         {-0.854645, 0.518036, 0.033936},
508         {0.42514, -0.437866, -0.792114},
509         {-0.358948, 0.597046, 0.717377},
510         {-0.985413, 0.144714, 0.089294},
511         {-0.601776, -0.33728, -0.723907},
512         {-0.449921, 0.594513, 0.666382},
513         {0.208313, -0.10791, 0.972076},
514         {0.575317, 0.060425, 0.815643},
515         {0.293365, -0.875702, -0.383453},
516         {0.293762, 0.465759, 0.834686},
517         {-0.846008, -0.233398, -0.47934},
518         {-0.115814, 0.143036, -0.98291},
519         {0.204681, -0.949036, -0.239532},
520         {0.946716, -0.263947, 0.184326},
521         {-0.235596, 0.573822, 0.784332},
522         {0.203705, -0.372253, -0.905487},
523         {0.756989, -0.651031, 0.055298},
524         {0.497803, 0.814697, -0.297363},
525         {-0.16214, 0.063995, -0.98468},
526         {-0.329254, 0.834381, 0.441925},
527         {0.703827, -0.527039, -0.476227},
528         {0.956421, 0.266113, 0.119781},
529         {0.480133, 0.482849, 0.7323},
530         {-0.18631, 0.961212, -0.203125},
531         {-0.748474, -0.656921, -0.090393},
532         {-0.085052, -0.165253, 0.982544},
533         {-0.76947, 0.628174, -0.115234},
534         {0.383148, 0.537659, 0.751068},
535         {0.616486, -0.668488, -0.415924},
536         {-0.259979, -0.630005, 0.73175},
537         {0.570953, -0.087952, 0.816223},
538         {-0.458008, 0.023254, 0.888611},
539         {-0.196167, 0.976563, -0.088287},
540         {-0.263885, -0.69812, -0.665527},
541         {0.437134, -0.892273, -0.112793},
542         {-0.621674, -0.230438, 0.748566},
543         {0.232422, 0.900574, -0.367249},
544         {0.22229, -0.796143, 0.562744},
545         {-0.665497, -0.73764, 0.11377},
546         {0.670135, 0.704803, 0.232605},
547         {0.895599, 0.429749, -0.114655},
548         {-0.11557, -0.474243, 0.872742},
549         {0.621826, 0.604004, -0.498444},
550         {-0.832214, 0.012756, 0.55426},
551         {-0.702484, 0.705994, -0.089661},
552         {-0.692017, 0.649292, 0.315399},
553         {-0.175995, -0.977997, 0.111877},
554         {0.096954, -0.04953, 0.994019},
555         {0.635284, -0.606689, -0.477783},
556         {-0.261261, -0.607422, -0.750153},
557         {0.983276, 0.165436, 0.075958},
558         {-0.29837, 0.404083, -0.864655},
559         {-0.638672, 0.507721, 0.578156},
560         {0.388214, 0.412079, 0.824249},
561         {0.556183, -0.208832, 0.804352},
562         {0.778442, 0.562012, 0.27951},
563         {-0.616577, 0.781921, -0.091522},
564         {0.196289, 0.051056, 0.979187},
565         {-0.121216, 0.207153, -0.970734},
566         {-0.173401, -0.384735, 0.906555},
567         {0.161499, -0.723236, -0.671387},
568         {0.178497, -0.006226, -0.983887},
569         {-0.126038, 0.15799, 0.97934},
570         {0.830475, -0.024811, 0.556458},
571         {-0.510132, -0.76944, 0.384247},
572         {0.81424, 0.200104, -0.544891},
573         {-0.112549, -0.393311, -0.912445},
574         {0.56189, 0.152222, -0.813049},
575         {0.198914, -0.254517, -0.946381},
576         {-0.41217, 0.690979, -0.593811},
577         {-0.407257, 0.324524, 0.853668},
578         {-0.690186, 0.366119, -0.624115},
579         {-0.428345, 0.844147, -0.322296},
580         {-0.21228, -0.297546, -0.930756},
581         {-0.273071, 0.516113, 0.811798},
582         {0.928314, 0.371643, 0.007233},
583         {0.785828, -0.479218, -0.390778},
584         {-0.704895, 0.058929, 0.706818},
585         {0.173248, 0.203583, 0.963562},
586         {0.422211, -0.904297, -0.062469},
587         {-0.363312, -0.182465, 0.913605},
588         {0.254028, -0.552307, -0.793945},
589         {-0.28891, -0.765747, -0.574554},
590         {0.058319, 0.291382, 0.954803},
591         {0.946136, -0.303925, 0.111267},
592         {-0.078156, 0.443695, -0.892731},
593         {0.182098, 0.89389, 0.409515},
594         {-0.680298, -0.213318, 0.701141},
595         {0.062469, 0.848389, -0.525635},
596         {-0.72879, -0.641846, 0.238342},
597         {-0.88089, 0.427673, 0.202637},
598         {-0.532501, -0.21405, 0.818878},
599         {0.948975, -0.305084, 0.07962},
600         {0.925446, 0.374664, 0.055817},
601         {0.820923, 0.565491, 0.079102},
602         {0.25882, 0.099792, -0.960724},
603         {-0.294617, 0.910522, 0.289978},
604         {0.137115, 0.320038, -0.937408},
605         {-0.908386, 0.345276, -0.235718},
606         {-0.936218, 0.138763, 0.322754},
607         {0.366577, 0.925934, -0.090637},
608         {0.309296, -0.686829, -0.657684},
609         {0.66983, 0.024445, 0.742065},
610         {-0.917999, -0.059113, -0.392059},
611         {0.365509, 0.462158, -0.807922},
612         {0.083374, 0.996399, -0.014801},
613         {0.593842, 0.253143, -0.763672},
614         {0.974976, -0.165466, 0.148285},
615         {0.918976, 0.137299, 0.369537},
616         {0.294952, 0.694977, 0.655731},
617         {0.943085, 0.152618, -0.295319},
618         {0.58783, -0.598236, 0.544495},
619         {0.203796, 0.678223, 0.705994},
620         {-0.478821, -0.661011, 0.577667},
621         {0.719055, -0.1698, -0.673828},
622         {-0.132172, -0.965332, 0.225006},
623         {-0.981873, -0.14502, 0.121979},
624         {0.763458, 0.579742, 0.284546},
625         {-0.893188, 0.079681, 0.442474},
626         {-0.795776, -0.523804, 0.303802},
627         {0.734955, 0.67804, -0.007446},
628         {0.15506, 0.986267, -0.056183},
629         {0.258026, 0.571503, -0.778931},
630         {-0.681549, -0.702087, -0.206116},
631         {-0.96286, -0.177185, 0.203613},
632         {-0.470978, -0.515106, 0.716095},
633         {-0.740326, 0.57135, 0.354095},
634         {-0.56012, -0.824982, -0.074982},
635         {-0.507874, 0.753204, 0.417969},
636         {-0.503113, 0.038147, 0.863342},
637         {0.594025, 0.673553, -0.439758},
638         {-0.119873, -0.005524, -0.992737},
639         {0.098267, -0.213776, 0.971893},
640         {-0.615631, 0.643951, 0.454163},
641         {0.896851, -0.441071, 0.032166},
642         {-0.555023, 0.750763, -0.358093},
643         {0.398773, 0.304688, 0.864929},
644         {-0.722961, 0.303589, 0.620544},
645         {-0.63559, -0.621948, -0.457306},
646         {-0.293243, 0.072327, 0.953278},
647         {-0.491638, 0.661041, -0.566772},
648         {-0.304199, -0.572083, -0.761688},
649         {0.908081, -0.398956, 0.127014},
650         {-0.523621, -0.549683, -0.650848},
651         {-0.932922, -0.19986, 0.299408},
652         {0.099426, 0.140869, 0.984985},
653         {-0.020325, -0.999756, -0.002319},
654         {0.952667, 0.280853, -0.11615},
655         {-0.971893, 0.082581, 0.220337},
656         {0.65921, 0.705292, -0.260651},
657         {0.733063, -0.175537, 0.657043},
658         {-0.555206, 0.429504, -0.712189},
659         {0.400421, -0.89859, 0.179352},
660         {0.750885, -0.19696, 0.630341},
661         {0.785675, -0.569336, 0.241821},
662         {-0.058899, -0.464111, 0.883789},
663         {0.129608, -0.94519, 0.299622},
664         {-0.357819, 0.907654, 0.219238},
665         {-0.842133, -0.439117, -0.312927},
666         {-0.313477, 0.84433, 0.434479},
667         {-0.241211, 0.053253, 0.968994},
668         {0.063873, 0.823273, 0.563965},
669         {0.476288, 0.862152, -0.172516},
670         {0.620941, -0.298126, 0.724915},
671         {0.25238, -0.749359, -0.612122},
672         {-0.577545, 0.386566, 0.718994},
673         {-0.406342, -0.737976, 0.538696},
674         {0.04718, 0.556305, 0.82959},
675         {-0.802856, 0.587463, 0.101166},
676         {-0.707733, -0.705963, 0.026428},
677         {0.374908, 0.68457, 0.625092},
678         {0.472137, 0.208405, -0.856506},
679         {-0.703064, -0.581085, -0.409821},
680         {-0.417206, -0.736328, 0.532623},
681         {-0.447876, -0.20285, -0.870728},
682         {0.086945, -0.990417, 0.107086},
683         {0.183685, 0.018341, -0.982788},
684         {0.560638, -0.428864, 0.708282},
685         {0.296722, -0.952576, -0.0672},
686         {0.135773, 0.990265, 0.030243},
687         {-0.068787, 0.654724, 0.752686},
688         {0.762604, -0.551758, 0.337585},
689         {-0.819611, -0.407684, 0.402466},
690         {-0.727844, -0.55072, -0.408539},
691         {-0.855774, -0.480011, 0.19281},
692         {0.693176, -0.079285, 0.716339},
693         {0.226013, 0.650116, -0.725433},
694         {0.246704, 0.953369, -0.173553},
695         {-0.970398, -0.239227, -0.03244},
696         {0.136383, -0.394318, 0.908752},
697         {0.813232, 0.558167, 0.164368},
698         {0.40451, 0.549042, -0.731323},
699         {-0.380249, -0.566711, 0.730865},
700         {0.022156, 0.932739, 0.359741},
701         {0.00824, 0.996552, -0.082306},
702         {0.956635, -0.065338, -0.283722},
703         {-0.743561, 0.008209, 0.668579},
704         {-0.859589, -0.509674, 0.035767},
705         {-0.852234, 0.363678, -0.375977},
706         {-0.201965, -0.970795, -0.12915},
707         {0.313477, 0.947327, 0.06546},
708         {-0.254028, -0.528259, 0.81015},
709         {0.628052, 0.601105, 0.49411},
710         {-0.494385, 0.868378, 0.037933},
711         {0.275635, -0.086426, 0.957336},
712         {-0.197937, 0.468903, -0.860748},
713         {0.895599, 0.399384, 0.195801},
714         {0.560791, 0.825012, -0.069214},
715         {0.304199, -0.849487, 0.43103},
716         {0.096375, 0.93576, 0.339111},
717         {-0.051422, 0.408966, -0.911072},
718         {0.330444, 0.942841, -0.042389},
719         {-0.452362, -0.786407, 0.420563},
720         {0.134308, -0.933472, -0.332489},
721         {0.80191, -0.566711, -0.188934},
722         {-0.987946, -0.105988, 0.112518},
723         {-0.24408, 0.892242, -0.379791},
724         {-0.920502, 0.229095, -0.316376},
725         {0.7789, 0.325958, 0.535706},
726         {-0.912872, 0.185211, -0.36377},
727         {-0.184784, 0.565369, -0.803833},
728         {-0.018463, 0.119537, 0.992615},
729         {-0.259247, -0.935608, 0.239532},
730         {-0.82373, -0.449127, -0.345947},
731         {-0.433105, 0.659515, 0.614349},
732         {-0.822754, 0.378845, -0.423676},
733         {0.687195, -0.674835, -0.26889},
734         {-0.246582, -0.800842, 0.545715},
735         {-0.729187, -0.207794, 0.651978},
736         {0.653534, -0.610443, -0.447388},
737         {0.492584, -0.023346, 0.869934},
738         {0.609039, 0.009094, -0.79306},
739         {0.962494, -0.271088, -0.00885},
740         {0.2659, -0.004913, 0.963959},
741         {0.651245, 0.553619, -0.518951},
742         {0.280548, -0.84314, 0.458618},
743         {-0.175293, -0.983215, 0.049805},
744         {0.035339, -0.979919, 0.196045},
745         {-0.982941, 0.164307, -0.082245},
746         {0.233734, -0.97226, -0.005005},
747         {-0.747253, -0.611328, 0.260437},
748         {0.645599, 0.592773, 0.481384},
749         {0.117706, -0.949524, -0.29068},
750         {-0.535004, -0.791901, -0.294312},
751         {-0.627167, -0.214447, 0.748718},
752         {-0.047974, -0.813477, -0.57959},
753         {-0.175537, 0.477264, -0.860992},
754         {0.738556, -0.414246, -0.53183},
755         {0.562561, -0.704071, 0.433289},
756         {-0.754944, 0.64801, -0.100586},
757         {0.114716, 0.044525, -0.992371},
758         {0.966003, 0.244873, -0.082764},
759         {0.33783, 0.715698, -0.611206},
760         {-0.944031, -0.326599, -0.045624},
761         {-0.101074, -0.416443, -0.903503},
762         {0.799286, 0.49411, -0.341949},
763         {-0.854645, 0.518036, 0.033936},
764         {0.42514, -0.437866, -0.792114},
765         {-0.358948, 0.597046, 0.717377},
766         {-0.985413, 0.144714, 0.089294},
767         {-0.601776, -0.33728, -0.723907},
768         {-0.449921, 0.594513, 0.666382},
769         {0.208313, -0.10791, 0.972076},
770         {0.575317, 0.060425, 0.815643},
771         {0.293365, -0.875702, -0.383453},
772         {0.293762, 0.465759, 0.834686},
773         {-0.846008, -0.233398, -0.47934},
774         {-0.115814, 0.143036, -0.98291},
775         {0.204681, -0.949036, -0.239532},
776         {0.946716, -0.263947, 0.184326},
777         {-0.235596, 0.573822, 0.784332},
778         {0.203705, -0.372253, -0.905487},
779         {0.756989, -0.651031, 0.055298},
780         {0.497803, 0.814697, -0.297363},
781         {-0.16214, 0.063995, -0.98468},
782         {-0.329254, 0.834381, 0.441925},
783         {0.703827, -0.527039, -0.476227},
784         {0.956421, 0.266113, 0.119781},
785         {0.480133, 0.482849, 0.7323},
786         {-0.18631, 0.961212, -0.203125},
787         {-0.748474, -0.656921, -0.090393},
788         {-0.085052, -0.165253, 0.982544},
789         {-0.76947, 0.628174, -0.115234},
790         {0.383148, 0.537659, 0.751068},
791         {0.616486, -0.668488, -0.415924},
792         {-0.259979, -0.630005, 0.73175},
793         {0.570953, -0.087952, 0.816223},
794         {-0.458008, 0.023254, 0.888611},
795         {-0.196167, 0.976563, -0.088287},
796         {-0.263885, -0.69812, -0.665527},
797         {0.437134, -0.892273, -0.112793},
798         {-0.621674, -0.230438, 0.748566},
799         {0.232422, 0.900574, -0.367249},
800         {0.22229, -0.796143, 0.562744},
801         {-0.665497, -0.73764, 0.11377},
802         {0.670135, 0.704803, 0.232605},
803         {0.895599, 0.429749, -0.114655},
804         {-0.11557, -0.474243, 0.872742},
805         {0.621826, 0.604004, -0.498444},
806         {-0.832214, 0.012756, 0.55426},
807         {-0.702484, 0.705994, -0.089661},
808         {-0.692017, 0.649292, 0.315399},
809         {-0.175995, -0.977997, 0.111877},
810         {0.096954, -0.04953, 0.994019},
811         {0.635284, -0.606689, -0.477783},
812         {-0.261261, -0.607422, -0.750153},
813         {0.983276, 0.165436, 0.075958},
814         {-0.29837, 0.404083, -0.864655},
815         {-0.638672, 0.507721, 0.578156},
816         {0.388214, 0.412079, 0.824249},
817         {0.556183, -0.208832, 0.804352},
818         {0.778442, 0.562012, 0.27951},
819         {-0.616577, 0.781921, -0.091522},
820         {0.196289, 0.051056, 0.979187},
821         {-0.121216, 0.207153, -0.970734},
822         {-0.173401, -0.384735, 0.906555},
823         {0.161499, -0.723236, -0.671387},
824         {0.178497, -0.006226, -0.983887},
825         {-0.126038, 0.15799, 0.97934},
826         {0.830475, -0.024811, 0.556458},
827         {-0.510132, -0.76944, 0.384247},
828         {0.81424, 0.200104, -0.544891},
829         {-0.112549, -0.393311, -0.912445},
830         {0.56189, 0.152222, -0.813049},
831         {0.198914, -0.254517, -0.946381},
832         {-0.41217, 0.690979, -0.593811},
833         {-0.407257, 0.324524, 0.853668},
834         {-0.690186, 0.366119, -0.624115},
835         {-0.428345, 0.844147, -0.322296},
836         {-0.21228, -0.297546, -0.930756},
837         {-0.273071, 0.516113, 0.811798},
838         {0.928314, 0.371643, 0.007233},
839         {0.785828, -0.479218, -0.390778},
840         {-0.704895, 0.058929, 0.706818},
841         {0.173248, 0.203583, 0.963562},
842         {0.422211, -0.904297, -0.062469},
843         {-0.363312, -0.182465, 0.913605},
844         {0.254028, -0.552307, -0.793945},
845         {-0.28891, -0.765747, -0.574554},
846         {0.058319, 0.291382, 0.954803},
847         {0.946136, -0.303925, 0.111267},
848         {-0.078156, 0.443695, -0.892731},
849         {0.182098, 0.89389, 0.409515},
850         {-0.680298, -0.213318, 0.701141},
851         {0.062469, 0.848389, -0.525635},
852         {-0.72879, -0.641846, 0.238342},
853         {-0.88089, 0.427673, 0.202637},
854         {-0.532501, -0.21405, 0.818878},
855         {0.948975, -0.305084, 0.07962},
856         {0.925446, 0.374664, 0.055817},
857         {0.820923, 0.565491, 0.079102},
858         {0.25882, 0.099792, -0.960724},
859         {-0.294617, 0.910522, 0.289978},
860         {0.137115, 0.320038, -0.937408},
861         {-0.908386, 0.345276, -0.235718},
862         {-0.936218, 0.138763, 0.322754},
863         {0.366577, 0.925934, -0.090637},
864         {0.309296, -0.686829, -0.657684},
865         {0.66983, 0.024445, 0.742065},
866         {-0.917999, -0.059113, -0.392059},
867         {0.365509, 0.462158, -0.807922},
868         {0.083374, 0.996399, -0.014801},
869         {0.593842, 0.253143, -0.763672},
870         {0.974976, -0.165466, 0.148285},
871         {0.918976, 0.137299, 0.369537},
872         {0.294952, 0.694977, 0.655731},
873         {0.943085, 0.152618, -0.295319},
874         {0.58783, -0.598236, 0.544495},
875         {0.203796, 0.678223, 0.705994},
876         {-0.478821, -0.661011, 0.577667},
877         {0.719055, -0.1698, -0.673828},
878         {-0.132172, -0.965332, 0.225006},
879         {-0.981873, -0.14502, 0.121979},
880         {0.763458, 0.579742, 0.284546},
881         {-0.893188, 0.079681, 0.442474},
882         {-0.795776, -0.523804, 0.303802},
883         {0.734955, 0.67804, -0.007446},
884         {0.15506, 0.986267, -0.056183},
885         {0.258026, 0.571503, -0.778931},
886         {-0.681549, -0.702087, -0.206116},
887         {-0.96286, -0.177185, 0.203613},
888         {-0.470978, -0.515106, 0.716095},
889         {-0.740326, 0.57135, 0.354095},
890         {-0.56012, -0.824982, -0.074982},
891         {-0.507874, 0.753204, 0.417969},
892         {-0.503113, 0.038147, 0.863342},
893         {0.594025, 0.673553, -0.439758},
894         {-0.119873, -0.005524, -0.992737},
895         {0.098267, -0.213776, 0.971893},
896         {-0.615631, 0.643951, 0.454163},
897         {0.896851, -0.441071, 0.032166},
898         {-0.555023, 0.750763, -0.358093},
899         {0.398773, 0.304688, 0.864929},
900         {-0.722961, 0.303589, 0.620544},
901         {-0.63559, -0.621948, -0.457306},
902         {-0.293243, 0.072327, 0.953278},
903         {-0.491638, 0.661041, -0.566772},
904         {-0.304199, -0.572083, -0.761688},
905         {0.908081, -0.398956, 0.127014},
906         {-0.523621, -0.549683, -0.650848},
907         {-0.932922, -0.19986, 0.299408},
908         {0.099426, 0.140869, 0.984985},
909         {-0.020325, -0.999756, -0.002319},
910         {0.952667, 0.280853, -0.11615},
911         {-0.971893, 0.082581, 0.220337},
912         {0.65921, 0.705292, -0.260651},
913         {0.733063, -0.175537, 0.657043},
914         {-0.555206, 0.429504, -0.712189},
915         {0.400421, -0.89859, 0.179352},
916         {0.750885, -0.19696, 0.630341},
917         {0.785675, -0.569336, 0.241821},
918         {-0.058899, -0.464111, 0.883789},
919         {0.129608, -0.94519, 0.299622},
920         {-0.357819, 0.907654, 0.219238},
921         {-0.842133, -0.439117, -0.312927},
922         {-0.313477, 0.84433, 0.434479},
923         {-0.241211, 0.053253, 0.968994},
924         {0.063873, 0.823273, 0.563965},
925         {0.476288, 0.862152, -0.172516},
926         {0.620941, -0.298126, 0.724915},
927         {0.25238, -0.749359, -0.612122},
928         {-0.577545, 0.386566, 0.718994},
929         {-0.406342, -0.737976, 0.538696},
930         {0.04718, 0.556305, 0.82959},
931         {-0.802856, 0.587463, 0.101166},
932         {-0.707733, -0.705963, 0.026428},
933         {0.374908, 0.68457, 0.625092},
934         {0.472137, 0.208405, -0.856506},
935         {-0.703064, -0.581085, -0.409821},
936         {-0.417206, -0.736328, 0.532623},
937         {-0.447876, -0.20285, -0.870728},
938         {0.086945, -0.990417, 0.107086},
939         {0.183685, 0.018341, -0.982788},
940         {0.560638, -0.428864, 0.708282},
941         {0.296722, -0.952576, -0.0672},
942         {0.135773, 0.990265, 0.030243},
943         {-0.068787, 0.654724, 0.752686},
944         {0.762604, -0.551758, 0.337585},
945         {-0.819611, -0.407684, 0.402466},
946         {-0.727844, -0.55072, -0.408539},
947         {-0.855774, -0.480011, 0.19281},
948         {0.693176, -0.079285, 0.716339},
949         {0.226013, 0.650116, -0.725433},
950         {0.246704, 0.953369, -0.173553},
951         {-0.970398, -0.239227, -0.03244},
952         {0.136383, -0.394318, 0.908752},
953         {0.813232, 0.558167, 0.164368},
954         {0.40451, 0.549042, -0.731323},
955         {-0.380249, -0.566711, 0.730865},
956         {0.022156, 0.932739, 0.359741},
957         {0.00824, 0.996552, -0.082306},
958         {0.956635, -0.065338, -0.283722},
959         {-0.743561, 0.008209, 0.668579},
960         {-0.859589, -0.509674, 0.035767},
961         {-0.852234, 0.363678, -0.375977},
962         {-0.201965, -0.970795, -0.12915},
963         {0.313477, 0.947327, 0.06546},
964         {-0.254028, -0.528259, 0.81015},
965         {0.628052, 0.601105, 0.49411},
966         {-0.494385, 0.868378, 0.037933},
967         {0.275635, -0.086426, 0.957336},
968         {-0.197937, 0.468903, -0.860748},
969         {0.895599, 0.399384, 0.195801},
970         {0.560791, 0.825012, -0.069214},
971         {0.304199, -0.849487, 0.43103},
972         {0.096375, 0.93576, 0.339111},
973         {-0.051422, 0.408966, -0.911072},
974         {0.330444, 0.942841, -0.042389},
975         {-0.452362, -0.786407, 0.420563},
976         {0.134308, -0.933472, -0.332489},
977         {0.80191, -0.566711, -0.188934},
978         {-0.987946, -0.105988, 0.112518},
979         {-0.24408, 0.892242, -0.379791},
980         {-0.920502, 0.229095, -0.316376},
981         {0.7789, 0.325958, 0.535706},
982         {-0.912872, 0.185211, -0.36377},
983         {-0.184784, 0.565369, -0.803833},
984         {-0.018463, 0.119537, 0.992615},
985         {-0.259247, -0.935608, 0.239532},
986         {-0.82373, -0.449127, -0.345947},
987         {-0.433105, 0.659515, 0.614349},
988         {-0.822754, 0.378845, -0.423676},
989         {0.687195, -0.674835, -0.26889},
990         {-0.246582, -0.800842, 0.545715},
991         {-0.729187, -0.207794, 0.651978},
992         {0.653534, -0.610443, -0.447388},
993         {0.492584, -0.023346, 0.869934},
994         {0.609039, 0.009094, -0.79306},
995         {0.962494, -0.271088, -0.00885},
996         {0.2659, -0.004913, 0.963959},
997         {0.651245, 0.553619, -0.518951},
998         {0.280548, -0.84314, 0.458618},
999         {-0.175293, -0.983215, 0.049805},
1000         {0.035339, -0.979919, 0.196045},
1001         {-0.982941, 0.164307, -0.082245},
1002         {0.233734, -0.97226, -0.005005},
1003         {-0.747253, -0.611328, 0.260437},
1004         {0.645599, 0.592773, 0.481384},
1005         {0.117706, -0.949524, -0.29068},
1006         {-0.535004, -0.791901, -0.294312},
1007         {-0.627167, -0.214447, 0.748718},
1008         {-0.047974, -0.813477, -0.57959},
1009         {-0.175537, 0.477264, -0.860992},
1010         {0.738556, -0.414246, -0.53183},
1011         {0.562561, -0.704071, 0.433289},
1012         {-0.754944, 0.64801, -0.100586},
1013         {0.114716, 0.044525, -0.992371},
1014         {0.966003, 0.244873, -0.082764},
1015         {0.33783, 0.715698, -0.611206},
1016         {-0.944031, -0.326599, -0.045624},
1017 };
1018
1019 #define SETUP(val, b0, b1, r0, r1)                                            \
1020         {                                                                         \
1021                 t = val + 10000.0f;                                                   \
1022                 b0 = ((int)t) & 255;                                                  \
1023                 b1 = (b0 + 1) & 255;                                                  \
1024                 r0 = t - floorf(t);                                                   \
1025                 r1 = r0 - 1.0f;                                                       \
1026         } (void)0
1027
1028
1029 static float noise3_perlin(float vec[3])
1030 {
1031         const char *p       = g_perlin_data_ub;
1032         const float (*g)[3] = g_perlin_data_v3;
1033         int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
1034         float rx0, rx1, ry0, ry1, rz0, rz1, sx, sy, sz, a, b, c, d, t, u, v;
1035         const float *q;
1036         register int i, j;
1037
1038
1039         SETUP(vec[0],  bx0, bx1,  rx0, rx1);
1040         SETUP(vec[1],  by0, by1,  ry0, ry1);
1041         SETUP(vec[2],  bz0, bz1,  rz0, rz1);
1042
1043         i = p[bx0];
1044         j = p[bx1];
1045
1046         b00 = p[i + by0];
1047         b10 = p[j + by0];
1048         b01 = p[i + by1];
1049         b11 = p[j + by1];
1050
1051 #define VALUE_AT(rx, ry, rz) ((rx) * q[0] + (ry) * q[1] + (rz) * q[2])
1052 #define SURVE(t) ((t) * (t) * (3.0f - 2.0f * (t)))
1053
1054 /* lerp moved to improved perlin above */
1055
1056         sx = SURVE(rx0);
1057         sy = SURVE(ry0);
1058         sz = SURVE(rz0);
1059
1060
1061         q = g[b00 + bz0];
1062         u = VALUE_AT(rx0, ry0, rz0);
1063         q = g[b10 + bz0];
1064         v = VALUE_AT(rx1, ry0, rz0);
1065         a = lerp(sx, u, v);
1066
1067         q = g[b01 + bz0];
1068         u = VALUE_AT(rx0, ry1, rz0);
1069         q = g[b11 + bz0];
1070         v = VALUE_AT(rx1, ry1, rz0);
1071         b = lerp(sx, u, v);
1072
1073         c = lerp(sy, a, b);          /* interpolate in y at lo x */
1074
1075         q = g[b00 + bz1];
1076         u = VALUE_AT(rx0, ry0, rz1);
1077         q = g[b10 + bz1];
1078         v = VALUE_AT(rx1, ry0, rz1);
1079         a = lerp(sx, u, v);
1080
1081         q = g[b01 + bz1];
1082         u = VALUE_AT(rx0, ry1, rz1);
1083         q = g[b11 + bz1];
1084         v = VALUE_AT(rx1, ry1, rz1);
1085         b = lerp(sx, u, v);
1086
1087         d = lerp(sy, a, b);          /* interpolate in y at hi x */
1088
1089         return 1.5f * lerp(sz, c, d); /* interpolate in z */
1090
1091 #undef VALUE_AT
1092 #undef SURVE
1093 }
1094
1095 #if 0
1096 static float turbulence_perlin(const float point[3], float lofreq, float hifreq)
1097 {
1098         float freq, t, p[3];
1099
1100         p[0] = point[0] + 123.456;
1101         p[1] = point[1];
1102         p[2] = point[2];
1103
1104         t = 0;
1105         for (freq = lofreq; freq < hifreq; freq *= 2.0) {
1106                 t += fabsf(noise3_perlin(p)) / freq;
1107                 p[0] *= 2.0f;
1108                 p[1] *= 2.0f;
1109                 p[2] *= 2.0f;
1110         }
1111         return t - 0.3; /* readjust to make mean value = 0.0 */
1112 }
1113 #endif
1114
1115 /* for use with BLI_gNoise/gTurbulence, returns signed noise */
1116 static float orgPerlinNoise(float x, float y, float z)
1117 {
1118         float v[3];
1119
1120         v[0] = x;
1121         v[1] = y;
1122         v[2] = z;
1123         return noise3_perlin(v);
1124 }
1125
1126 /* for use with BLI_gNoise/gTurbulence, returns unsigned noise */
1127 static float orgPerlinNoiseU(float x, float y, float z)
1128 {
1129         float v[3];
1130
1131         v[0] = x;
1132         v[1] = y;
1133         v[2] = z;
1134         return (0.5f + 0.5f * noise3_perlin(v));
1135 }
1136
1137 /* *************** CALL AS: *************** */
1138
1139 float BLI_hnoisep(float noisesize, float x, float y, float z)
1140 {
1141         float vec[3];
1142
1143         vec[0] = x / noisesize;
1144         vec[1] = y / noisesize;
1145         vec[2] = z / noisesize;
1146
1147         return noise3_perlin(vec);
1148 }
1149
1150 #if 0
1151 static float turbulencep(float noisesize, float x, float y, float z, int nr)
1152 {
1153         float vec[3];
1154
1155         vec[0] = x / noisesize;
1156         vec[1] = y / noisesize;
1157         vec[2] = z / noisesize;
1158         nr++;
1159         return turbulence_perlin(vec, 1.0, (float)(1 << nr));
1160 }
1161 #endif
1162
1163 /******************/
1164 /* VORONOI/WORLEY */
1165 /******************/
1166
1167 /* distance metrics for voronoi, e parameter only used in Minkowski */
1168 /* Camberra omitted, didn't seem useful */
1169
1170 /* distance squared */
1171 static float dist_Squared(float x, float y, float z, float e)
1172 {
1173         (void)e; return (x * x + y * y + z * z);
1174 }
1175 /* real distance */
1176 static float dist_Real(float x, float y, float z, float e)
1177 {
1178         (void)e; return sqrtf(x * x + y * y + z * z);
1179 }
1180 /* manhattan/taxicab/cityblock distance */
1181 static float dist_Manhattan(float x, float y, float z, float e)
1182 {
1183         (void)e; return (fabsf(x) + fabsf(y) + fabsf(z));
1184 }
1185 /* Chebychev */
1186 static float dist_Chebychev(float x, float y, float z, float e)
1187 {
1188         float t;
1189         (void)e;
1190
1191         x = fabsf(x);
1192         y = fabsf(y);
1193         z = fabsf(z);
1194         t = (x > y) ? x : y;
1195         return ((z > t) ? z : t);
1196 }
1197
1198 /* minkowski preset exponent 0.5 */
1199 static float dist_MinkovskyH(float x, float y, float z, float e)
1200 {
1201         float d = sqrtf(fabsf(x)) + sqrtf(fabsf(y)) + sqrtf(fabsf(z));
1202         (void)e;
1203         return (d * d);
1204 }
1205
1206 /* minkowski preset exponent 4 */
1207 static float dist_Minkovsky4(float x, float y, float z, float e)
1208 {
1209         (void)e;
1210         x *= x;
1211         y *= y;
1212         z *= z;
1213         return sqrtf(sqrtf(x * x + y * y + z * z));
1214 }
1215
1216 /* Minkowski, general case, slow, maybe too slow to be useful */
1217 static float dist_Minkovsky(float x, float y, float z, float e)
1218 {
1219         return powf(powf(fabsf(x), e) + powf(fabsf(y), e) + powf(fabsf(z), e), 1.0f / e);
1220 }
1221
1222
1223 /* Not 'pure' Worley, but the results are virtually the same.
1224  * Returns distances in da and point coords in pa */
1225 void voronoi(float x, float y, float z, float *da, float *pa, float me, int dtype)
1226 {
1227         int xx, yy, zz, xi, yi, zi;
1228         float xd, yd, zd, d;
1229
1230         float (*distfunc)(float, float, float, float);
1231         switch (dtype) {
1232                 case 1:
1233                         distfunc = dist_Squared;
1234                         break;
1235                 case 2:
1236                         distfunc = dist_Manhattan;
1237                         break;
1238                 case 3:
1239                         distfunc = dist_Chebychev;
1240                         break;
1241                 case 4:
1242                         distfunc = dist_MinkovskyH;
1243                         break;
1244                 case 5:
1245                         distfunc = dist_Minkovsky4;
1246                         break;
1247                 case 6:
1248                         distfunc = dist_Minkovsky;
1249                         break;
1250                 case 0:
1251                 default:
1252                         distfunc = dist_Real;
1253                         break;
1254         }
1255
1256         xi = (int)(floor(x));
1257         yi = (int)(floor(y));
1258         zi = (int)(floor(z));
1259         da[0] = da[1] = da[2] = da[3] = 1e10f;
1260         for (xx = xi - 1; xx <= xi + 1; xx++) {
1261                 for (yy = yi - 1; yy <= yi + 1; yy++) {
1262                         for (zz = zi - 1; zz <= zi + 1; zz++) {
1263                                 const float *p = HASHPNT(xx, yy, zz);
1264                                 xd = x - (p[0] + xx);
1265                                 yd = y - (p[1] + yy);
1266                                 zd = z - (p[2] + zz);
1267                                 d = distfunc(xd, yd, zd, me);
1268                                 if (d < da[0]) {
1269                                         da[3] = da[2];  da[2] = da[1];  da[1] = da[0];  da[0] = d;
1270                                         pa[9] = pa[6];  pa[10] = pa[7];  pa[11] = pa[8];
1271                                         pa[6] = pa[3];  pa[7] = pa[4];  pa[8] = pa[5];
1272                                         pa[3] = pa[0];  pa[4] = pa[1];  pa[5] = pa[2];
1273                                         pa[0] = p[0] + xx;  pa[1] = p[1] + yy;  pa[2] = p[2] + zz;
1274                                 }
1275                                 else if (d < da[1]) {
1276                                         da[3] = da[2];  da[2] = da[1];  da[1] = d;
1277                                         pa[9] = pa[6];  pa[10] = pa[7];  pa[11] = pa[8];
1278                                         pa[6] = pa[3];  pa[7] = pa[4];  pa[8] = pa[5];
1279                                         pa[3] = p[0] + xx;  pa[4] = p[1] + yy;  pa[5] = p[2] + zz;
1280                                 }
1281                                 else if (d < da[2]) {
1282                                         da[3] = da[2];  da[2] = d;
1283                                         pa[9] = pa[6];  pa[10] = pa[7];  pa[11] = pa[8];
1284                                         pa[6] = p[0] + xx;  pa[7] = p[1] + yy;  pa[8] = p[2] + zz;
1285                                 }
1286                                 else if (d < da[3]) {
1287                                         da[3] = d;
1288                                         pa[9] = p[0] + xx;  pa[10] = p[1] + yy;  pa[11] = p[2] + zz;
1289                                 }
1290                         }
1291                 }
1292         }
1293 }
1294
1295 /* returns different feature points for use in BLI_gNoise() */
1296 static float voronoi_F1(float x, float y, float z)
1297 {
1298         float da[4], pa[12];
1299         voronoi(x, y, z, da, pa, 1, 0);
1300         return da[0];
1301 }
1302
1303 static float voronoi_F2(float x, float y, float z)
1304 {
1305         float da[4], pa[12];
1306         voronoi(x, y, z, da, pa, 1, 0);
1307         return da[1];
1308 }
1309
1310 static float voronoi_F3(float x, float y, float z)
1311 {
1312         float da[4], pa[12];
1313         voronoi(x, y, z, da, pa, 1, 0);
1314         return da[2];
1315 }
1316
1317 static float voronoi_F4(float x, float y, float z)
1318 {
1319         float da[4], pa[12];
1320         voronoi(x, y, z, da, pa, 1, 0);
1321         return da[3];
1322 }
1323
1324 static float voronoi_F1F2(float x, float y, float z)
1325 {
1326         float da[4], pa[12];
1327         voronoi(x, y, z, da, pa, 1, 0);
1328         return (da[1] - da[0]);
1329 }
1330
1331 /* Crackle type pattern, just a scale/clamp of F2-F1 */
1332 static float voronoi_Cr(float x, float y, float z)
1333 {
1334         float t = 10 * voronoi_F1F2(x, y, z);
1335         if (t > 1.f) return 1.f;
1336         return t;
1337 }
1338
1339
1340 /* Signed version of all 6 of the above, just 2x-1, not really correct though (range is potentially (0, sqrt(6)).
1341  * Used in the musgrave functions */
1342 static float voronoi_F1S(float x, float y, float z)
1343 {
1344         float da[4], pa[12];
1345         voronoi(x, y, z, da, pa, 1, 0);
1346         return (2.0f * da[0] - 1.0f);
1347 }
1348
1349 static float voronoi_F2S(float x, float y, float z)
1350 {
1351         float da[4], pa[12];
1352         voronoi(x, y, z, da, pa, 1, 0);
1353         return (2.0f * da[1] - 1.0f);
1354 }
1355
1356 static float voronoi_F3S(float x, float y, float z)
1357 {
1358         float da[4], pa[12];
1359         voronoi(x, y, z, da, pa, 1, 0);
1360         return (2.0f * da[2] - 1.0f);
1361 }
1362
1363 static float voronoi_F4S(float x, float y, float z)
1364 {
1365         float da[4], pa[12];
1366         voronoi(x, y, z, da, pa, 1, 0);
1367         return (2.0f * da[3] - 1.0f);
1368 }
1369
1370 static float voronoi_F1F2S(float x, float y, float z)
1371 {
1372         float da[4], pa[12];
1373         voronoi(x, y, z, da, pa, 1, 0);
1374         return (2.0f * (da[1] - da[0]) - 1.0f);
1375 }
1376
1377 /* Crackle type pattern, just a scale/clamp of F2-F1 */
1378 static float voronoi_CrS(float x, float y, float z)
1379 {
1380         float t = 10 * voronoi_F1F2(x, y, z);
1381         if (t > 1.f) return 1.f;
1382         return (2.0f * t - 1.0f);
1383 }
1384
1385
1386 /***************/
1387 /* voronoi end */
1388 /***************/
1389
1390 /*************/
1391 /* CELLNOISE */
1392 /*************/
1393
1394 /* returns unsigned cellnoise */
1395 static float cellNoiseU(float x, float y, float z)
1396 {
1397         int xi = (int)(floor(x));
1398         int yi = (int)(floor(y));
1399         int zi = (int)(floor(z));
1400         unsigned int n = xi + yi * 1301 + zi * 314159;
1401         n ^= (n << 13);
1402         return ((float)(n * (n * n * 15731 + 789221) + 1376312589) / 4294967296.0f);
1403 }
1404
1405 /* idem, signed */
1406 float cellNoise(float x, float y, float z)
1407 {
1408         return (2.0f * cellNoiseU(x, y, z) - 1.0f);
1409 }
1410
1411 /* returns a vector/point/color in ca, using point hasharray directly */
1412 void cellNoiseV(float x, float y, float z, float ca[3])
1413 {
1414         int xi = (int)(floor(x));
1415         int yi = (int)(floor(y));
1416         int zi = (int)(floor(z));
1417         const float *p = HASHPNT(xi, yi, zi);
1418         ca[0] = p[0];
1419         ca[1] = p[1];
1420         ca[2] = p[2];
1421 }
1422
1423
1424 /*****************/
1425 /* end cellnoise */
1426 /*****************/
1427
1428 /* newnoise: generic noise function for use with different noisebases */
1429 float BLI_gNoise(float noisesize, float x, float y, float z, int hard, int noisebasis)
1430 {
1431         float (*noisefunc)(float, float, float);
1432
1433         switch (noisebasis) {
1434                 case 1:
1435                         noisefunc = orgPerlinNoiseU;
1436                         break;
1437                 case 2:
1438                         noisefunc = newPerlinU;
1439                         break;
1440                 case 3:
1441                         noisefunc = voronoi_F1;
1442                         break;
1443                 case 4:
1444                         noisefunc = voronoi_F2;
1445                         break;
1446                 case 5:
1447                         noisefunc = voronoi_F3;
1448                         break;
1449                 case 6:
1450                         noisefunc = voronoi_F4;
1451                         break;
1452                 case 7:
1453                         noisefunc = voronoi_F1F2;
1454                         break;
1455                 case 8:
1456                         noisefunc = voronoi_Cr;
1457                         break;
1458                 case 14:
1459                         noisefunc = cellNoiseU;
1460                         break;
1461                 case 0:
1462                 default:
1463                 {
1464                         noisefunc = orgBlenderNoise;
1465                         /* add one to make return value same as BLI_hnoise */
1466                         x += 1;
1467                         y += 1;
1468                         z += 1;
1469                         break;
1470                 }
1471         }
1472
1473         if (noisesize != 0.0f) {
1474                 noisesize = 1.0f / noisesize;
1475                 x *= noisesize;
1476                 y *= noisesize;
1477                 z *= noisesize;
1478         }
1479         
1480         if (hard) return fabsf(2.0f * noisefunc(x, y, z) - 1.0f);
1481         return noisefunc(x, y, z);
1482 }
1483
1484 /* newnoise: generic turbulence function for use with different noisebasis */
1485 float BLI_gTurbulence(float noisesize, float x, float y, float z, int oct, int hard, int noisebasis)
1486 {
1487         float (*noisefunc)(float, float, float);
1488         float sum, t, amp = 1, fscale = 1;
1489         int i;
1490         
1491         switch (noisebasis) {
1492                 case 1:
1493                         noisefunc = orgPerlinNoiseU;
1494                         break;
1495                 case 2:
1496                         noisefunc = newPerlinU;
1497                         break;
1498                 case 3:
1499                         noisefunc = voronoi_F1;
1500                         break;
1501                 case 4:
1502                         noisefunc = voronoi_F2;
1503                         break;
1504                 case 5:
1505                         noisefunc = voronoi_F3;
1506                         break;
1507                 case 6:
1508                         noisefunc = voronoi_F4;
1509                         break;
1510                 case 7:
1511                         noisefunc = voronoi_F1F2;
1512                         break;
1513                 case 8:
1514                         noisefunc = voronoi_Cr;
1515                         break;
1516                 case 14:
1517                         noisefunc = cellNoiseU;
1518                         break;
1519                 case 0:
1520                 default:
1521                         noisefunc = orgBlenderNoise;
1522                         x += 1;
1523                         y += 1;
1524                         z += 1;
1525                         break;
1526         }
1527
1528         if (noisesize != 0.0f) {
1529                 noisesize = 1.0f / noisesize;
1530                 x *= noisesize;
1531                 y *= noisesize;
1532                 z *= noisesize;
1533         }
1534
1535         sum = 0;
1536         for (i = 0; i <= oct; i++, amp *= 0.5f, fscale *= 2.0f) {
1537                 t = noisefunc(fscale * x, fscale * y, fscale * z);
1538                 if (hard) t = fabsf(2.0f * t - 1.0f);
1539                 sum += t * amp;
1540         }
1541         
1542         sum *= ((float)(1 << oct) / (float)((1 << (oct + 1)) - 1));
1543
1544         return sum;
1545
1546 }
1547
1548
1549 /*
1550  * The following code is based on Ken Musgrave's explanations and sample
1551  * source code in the book "Texturing and Modeling: A procedural approach"
1552  */
1553
1554 /*
1555  * Procedural fBm evaluated at "point"; returns value stored in "value".
1556  *
1557  * Parameters:
1558  *    ``H''  is the fractal increment parameter
1559  *    ``lacunarity''  is the gap between successive frequencies
1560  *    ``octaves''  is the number of frequencies in the fBm
1561  */
1562 float mg_fBm(float x, float y, float z, float H, float lacunarity, float octaves, int noisebasis)
1563 {
1564         float rmd, value = 0.0, pwr = 1.0, pwHL = powf(lacunarity, -H);
1565         int i;
1566
1567         float (*noisefunc)(float, float, float);
1568         switch (noisebasis) {
1569                 case 1:
1570                         noisefunc = orgPerlinNoise;
1571                         break;
1572                 case 2:
1573                         noisefunc = newPerlin;
1574                         break;
1575                 case 3:
1576                         noisefunc = voronoi_F1S;
1577                         break;
1578                 case 4:
1579                         noisefunc = voronoi_F2S;
1580                         break;
1581                 case 5:
1582                         noisefunc = voronoi_F3S;
1583                         break;
1584                 case 6:
1585                         noisefunc = voronoi_F4S;
1586                         break;
1587                 case 7:
1588                         noisefunc = voronoi_F1F2S;
1589                         break;
1590                 case 8:
1591                         noisefunc = voronoi_CrS;
1592                         break;
1593                 case 14:
1594                         noisefunc = cellNoise;
1595                         break;
1596                 case 0:
1597                 default:
1598                 {
1599                         noisefunc = orgBlenderNoiseS;
1600                         break;
1601                 }
1602         }
1603         
1604         for (i = 0; i < (int)octaves; i++) {
1605                 value += noisefunc(x, y, z) * pwr;
1606                 pwr *= pwHL;
1607                 x *= lacunarity;
1608                 y *= lacunarity;
1609                 z *= lacunarity;
1610         }
1611
1612         rmd = octaves - floorf(octaves);
1613         if (rmd != 0.f) value += rmd * noisefunc(x, y, z) * pwr;
1614
1615         return value;
1616
1617 } /* fBm() */
1618
1619
1620 /*
1621  * Procedural multifractal evaluated at "point";
1622  * returns value stored in "value".
1623  *
1624  * Parameters:
1625  *    ``H''  determines the highest fractal dimension
1626  *    ``lacunarity''  is gap between successive frequencies
1627  *    ``octaves''  is the number of frequencies in the fBm
1628  *    ``offset''  is the zero offset, which determines multifractality (NOT USED??)
1629  */
1630
1631 /* this one is in fact rather confusing,
1632  * there seem to be errors in the original source code (in all three versions of proc.text&mod),
1633  * I modified it to something that made sense to me, so it might be wrong... */
1634 float mg_MultiFractal(float x, float y, float z, float H, float lacunarity, float octaves, int noisebasis)
1635 {
1636         float rmd, value = 1.0, pwr = 1.0, pwHL = powf(lacunarity, -H);
1637         int i;
1638
1639         float (*noisefunc)(float, float, float);
1640         switch (noisebasis) {
1641                 case 1:
1642                         noisefunc = orgPerlinNoise;
1643                         break;
1644                 case 2:
1645                         noisefunc = newPerlin;
1646                         break;
1647                 case 3:
1648                         noisefunc = voronoi_F1S;
1649                         break;
1650                 case 4:
1651                         noisefunc = voronoi_F2S;
1652                         break;
1653                 case 5:
1654                         noisefunc = voronoi_F3S;
1655                         break;
1656                 case 6:
1657                         noisefunc = voronoi_F4S;
1658                         break;
1659                 case 7:
1660                         noisefunc = voronoi_F1F2S;
1661                         break;
1662                 case 8:
1663                         noisefunc = voronoi_CrS;
1664                         break;
1665                 case 14:
1666                         noisefunc = cellNoise;
1667                         break;
1668                 case 0:
1669                 default:
1670                 {
1671                         noisefunc = orgBlenderNoiseS;
1672                         break;
1673                 }
1674         }
1675
1676         for (i = 0; i < (int)octaves; i++) {
1677                 value *= (pwr * noisefunc(x, y, z) + 1.0f);
1678                 pwr *= pwHL;
1679                 x *= lacunarity;
1680                 y *= lacunarity;
1681                 z *= lacunarity;
1682         }
1683         rmd = octaves - floorf(octaves);
1684         if (rmd != 0.0f) value *= (rmd * noisefunc(x, y, z) * pwr + 1.0f);
1685
1686         return value;
1687
1688 } /* multifractal() */
1689
1690 /*
1691  * Heterogeneous procedural terrain function: stats by altitude method.
1692  * Evaluated at "point"; returns value stored in "value".
1693  *
1694  * Parameters:
1695  *       ``H''  determines the fractal dimension of the roughest areas
1696  *       ``lacunarity''  is the gap between successive frequencies
1697  *       ``octaves''  is the number of frequencies in the fBm
1698  *       ``offset''  raises the terrain from `sea level'
1699  */
1700 float mg_HeteroTerrain(float x, float y, float z, float H, float lacunarity, float octaves, float offset, int noisebasis)
1701 {
1702         float value, increment, rmd;
1703         int i;
1704         float pwHL = powf(lacunarity, -H);
1705         float pwr = pwHL;   /* starts with i=1 instead of 0 */
1706
1707         float (*noisefunc)(float, float, float);
1708         switch (noisebasis) {
1709                 case 1:
1710                         noisefunc = orgPerlinNoise;
1711                         break;
1712                 case 2:
1713                         noisefunc = newPerlin;
1714                         break;
1715                 case 3:
1716                         noisefunc = voronoi_F1S;
1717                         break;
1718                 case 4:
1719                         noisefunc = voronoi_F2S;
1720                         break;
1721                 case 5:
1722                         noisefunc = voronoi_F3S;
1723                         break;
1724                 case 6:
1725                         noisefunc = voronoi_F4S;
1726                         break;
1727                 case 7:
1728                         noisefunc = voronoi_F1F2S;
1729                         break;
1730                 case 8:
1731                         noisefunc = voronoi_CrS;
1732                         break;
1733                 case 14:
1734                         noisefunc = cellNoise;
1735                         break;
1736                 case 0:
1737                 default:
1738                 {
1739                         noisefunc = orgBlenderNoiseS;
1740                         break;
1741                 }
1742         }
1743
1744         /* first unscaled octave of function; later octaves are scaled */
1745         value = offset + noisefunc(x, y, z);
1746         x *= lacunarity;
1747         y *= lacunarity;
1748         z *= lacunarity;
1749
1750         for (i = 1; i < (int)octaves; i++) {
1751                 increment = (noisefunc(x, y, z) + offset) * pwr * value;
1752                 value += increment;
1753                 pwr *= pwHL;
1754                 x *= lacunarity;
1755                 y *= lacunarity;
1756                 z *= lacunarity;
1757         }
1758
1759         rmd = octaves - floorf(octaves);
1760         if (rmd != 0.0f) {
1761                 increment = (noisefunc(x, y, z) + offset) * pwr * value;
1762                 value += rmd * increment;
1763         }
1764         return value;
1765 }
1766
1767
1768 /* Hybrid additive/multiplicative multifractal terrain model.
1769  *
1770  * Some good parameter values to start with:
1771  *
1772  *      H:           0.25
1773  *      offset:      0.7
1774  */
1775 float mg_HybridMultiFractal(float x, float y, float z, float H, float lacunarity, float octaves, float offset, float gain, int noisebasis)
1776 {
1777         float result, signal, weight, rmd;
1778         int i;
1779         float pwHL = powf(lacunarity, -H);
1780         float pwr = pwHL;   /* starts with i=1 instead of 0 */
1781         float (*noisefunc)(float, float, float);
1782
1783         switch (noisebasis) {
1784                 case 1:
1785                         noisefunc = orgPerlinNoise;
1786                         break;
1787                 case 2:
1788                         noisefunc = newPerlin;
1789                         break;
1790                 case 3:
1791                         noisefunc = voronoi_F1S;
1792                         break;
1793                 case 4:
1794                         noisefunc = voronoi_F2S;
1795                         break;
1796                 case 5:
1797                         noisefunc = voronoi_F3S;
1798                         break;
1799                 case 6:
1800                         noisefunc = voronoi_F4S;
1801                         break;
1802                 case 7:
1803                         noisefunc = voronoi_F1F2S;
1804                         break;
1805                 case 8:
1806                         noisefunc = voronoi_CrS;
1807                         break;
1808                 case 14:
1809                         noisefunc = cellNoise;
1810                         break;
1811                 case 0:
1812                 default:
1813                 {
1814                         noisefunc = orgBlenderNoiseS;
1815                         break;
1816                 }
1817         }
1818
1819         result = noisefunc(x, y, z) + offset;
1820         weight = gain * result;
1821         x *= lacunarity;
1822         y *= lacunarity;
1823         z *= lacunarity;
1824
1825         for (i = 1; (weight > 0.001f) && (i < (int)octaves); i++) {
1826                 if (weight > 1.0f) weight = 1.0f;
1827                 signal = (noisefunc(x, y, z) + offset) * pwr;
1828                 pwr *= pwHL;
1829                 result += weight * signal;
1830                 weight *= gain * signal;
1831                 x *= lacunarity;
1832                 y *= lacunarity;
1833                 z *= lacunarity;
1834         }
1835
1836         rmd = octaves - floorf(octaves);
1837         if (rmd != 0.f) result += rmd * ((noisefunc(x, y, z) + offset) * pwr);
1838
1839         return result;
1840
1841 } /* HybridMultifractal() */
1842
1843
1844 /* Ridged multifractal terrain model.
1845  *
1846  * Some good parameter values to start with:
1847  *
1848  *      H:           1.0
1849  *      offset:      1.0
1850  *      gain:        2.0
1851  */
1852 float mg_RidgedMultiFractal(float x, float y, float z, float H, float lacunarity, float octaves, float offset, float gain, int noisebasis)
1853 {
1854         float result, signal, weight;
1855         int i;
1856         float pwHL = powf(lacunarity, -H);
1857         float pwr = pwHL;   /* starts with i=1 instead of 0 */
1858         
1859         float (*noisefunc)(float, float, float);
1860         switch (noisebasis) {
1861                 case 1:
1862                         noisefunc = orgPerlinNoise;
1863                         break;
1864                 case 2:
1865                         noisefunc = newPerlin;
1866                         break;
1867                 case 3:
1868                         noisefunc = voronoi_F1S;
1869                         break;
1870                 case 4:
1871                         noisefunc = voronoi_F2S;
1872                         break;
1873                 case 5:
1874                         noisefunc = voronoi_F3S;
1875                         break;
1876                 case 6:
1877                         noisefunc = voronoi_F4S;
1878                         break;
1879                 case 7:
1880                         noisefunc = voronoi_F1F2S;
1881                         break;
1882                 case 8:
1883                         noisefunc = voronoi_CrS;
1884                         break;
1885                 case 14:
1886                         noisefunc = cellNoise;
1887                         break;
1888                 case 0:
1889                 default:
1890                 {
1891                         noisefunc = orgBlenderNoiseS;
1892                         break;
1893                 }
1894         }
1895
1896         signal = offset - fabsf(noisefunc(x, y, z));
1897         signal *= signal;
1898         result = signal;
1899
1900
1901         for (i = 1; i < (int)octaves; i++) {
1902                 x *= lacunarity;
1903                 y *= lacunarity;
1904                 z *= lacunarity;
1905                 weight = signal * gain;
1906                 if      (weight > 1.0f) weight = 1.0f;
1907                 else if (weight < 0.0f) weight = 0.0f;
1908                 signal = offset - fabsf(noisefunc(x, y, z));
1909                 signal *= signal;
1910                 signal *= weight;
1911                 result += signal * pwr;
1912                 pwr *= pwHL;
1913         }
1914
1915         return result;
1916 } /* RidgedMultifractal() */
1917
1918 /* "Variable Lacunarity Noise"
1919  * A distorted variety of Perlin noise.
1920  */
1921 float mg_VLNoise(float x, float y, float z, float distortion, int nbas1, int nbas2)
1922 {
1923         float rv[3];
1924         float (*noisefunc1)(float, float, float);
1925         float (*noisefunc2)(float, float, float);
1926
1927         switch (nbas1) {
1928                 case 1:
1929                         noisefunc1 = orgPerlinNoise;
1930                         break;
1931                 case 2:
1932                         noisefunc1 = newPerlin;
1933                         break;
1934                 case 3:
1935                         noisefunc1 = voronoi_F1S;
1936                         break;
1937                 case 4:
1938                         noisefunc1 = voronoi_F2S;
1939                         break;
1940                 case 5:
1941                         noisefunc1 = voronoi_F3S;
1942                         break;
1943                 case 6:
1944                         noisefunc1 = voronoi_F4S;
1945                         break;
1946                 case 7:
1947                         noisefunc1 = voronoi_F1F2S;
1948                         break;
1949                 case 8:
1950                         noisefunc1 = voronoi_CrS;
1951                         break;
1952                 case 14:
1953                         noisefunc1 = cellNoise;
1954                         break;
1955                 case 0:
1956                 default:
1957                 {
1958                         noisefunc1 = orgBlenderNoiseS;
1959                         break;
1960                 }
1961         }
1962
1963         switch (nbas2) {
1964                 case 1:
1965                         noisefunc2 = orgPerlinNoise;
1966                         break;
1967                 case 2:
1968                         noisefunc2 = newPerlin;
1969                         break;
1970                 case 3:
1971                         noisefunc2 = voronoi_F1S;
1972                         break;
1973                 case 4:
1974                         noisefunc2 = voronoi_F2S;
1975                         break;
1976                 case 5:
1977                         noisefunc2 = voronoi_F3S;
1978                         break;
1979                 case 6:
1980                         noisefunc2 = voronoi_F4S;
1981                         break;
1982                 case 7:
1983                         noisefunc2 = voronoi_F1F2S;
1984                         break;
1985                 case 8:
1986                         noisefunc2 = voronoi_CrS;
1987                         break;
1988                 case 14:
1989                         noisefunc2 = cellNoise;
1990                         break;
1991                 case 0:
1992                 default:
1993                 {
1994                         noisefunc2 = orgBlenderNoiseS;
1995                         break;
1996                 }
1997         }
1998
1999         /* get a random vector and scale the randomization */
2000         rv[0] = noisefunc1(x + 13.5f, y + 13.5f, z + 13.5f) * distortion;
2001         rv[1] = noisefunc1(x, y, z) * distortion;
2002         rv[2] = noisefunc1(x - 13.5f, y - 13.5f, z - 13.5f) * distortion;
2003         return noisefunc2(x + rv[0], y + rv[1], z + rv[2]);   /* distorted-domain noise */
2004 }
2005
2006 /****************/
2007 /* musgrave end */
2008 /****************/