Cleanup: spelling
[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 p[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[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         int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
1032         float rx0, rx1, ry0, ry1, rz0, rz1, sx, sy, sz, a, b, c, d, t, u, v;
1033         const float *q;
1034         register int i, j;
1035
1036
1037         SETUP(vec[0],  bx0, bx1,  rx0, rx1);
1038         SETUP(vec[1],  by0, by1,  ry0, ry1);
1039         SETUP(vec[2],  bz0, bz1,  rz0, rz1);
1040
1041         i = p[bx0];
1042         j = p[bx1];
1043
1044         b00 = p[i + by0];
1045         b10 = p[j + by0];
1046         b01 = p[i + by1];
1047         b11 = p[j + by1];
1048
1049 #define VALUE_AT(rx, ry, rz) (rx * q[0] + ry * q[1] + rz * q[2])
1050 #define SURVE(t) (t * t * (3.0f - 2.0f * t))
1051
1052 /* lerp moved to improved perlin above */
1053
1054         sx = SURVE(rx0);
1055         sy = SURVE(ry0);
1056         sz = SURVE(rz0);
1057
1058
1059         q = g[b00 + bz0];
1060         u = VALUE_AT(rx0, ry0, rz0);
1061         q = g[b10 + bz0];
1062         v = VALUE_AT(rx1, ry0, rz0);
1063         a = lerp(sx, u, v);
1064
1065         q = g[b01 + bz0];
1066         u = VALUE_AT(rx0, ry1, rz0);
1067         q = g[b11 + bz0];
1068         v = VALUE_AT(rx1, ry1, rz0);
1069         b = lerp(sx, u, v);
1070
1071         c = lerp(sy, a, b);          /* interpolate in y at lo x */
1072
1073         q = g[b00 + bz1];
1074         u = VALUE_AT(rx0, ry0, rz1);
1075         q = g[b10 + bz1];
1076         v = VALUE_AT(rx1, ry0, rz1);
1077         a = lerp(sx, u, v);
1078
1079         q = g[b01 + bz1];
1080         u = VALUE_AT(rx0, ry1, rz1);
1081         q = g[b11 + bz1];
1082         v = VALUE_AT(rx1, ry1, rz1);
1083         b = lerp(sx, u, v);
1084
1085         d = lerp(sy, a, b);          /* interpolate in y at hi x */
1086
1087         return 1.5f * lerp(sz, c, d); /* interpolate in z */
1088
1089 #undef VALUE_AT
1090 #undef SURVE
1091 }
1092
1093 #if 0
1094 static float turbulence_perlin(const float point[3], float lofreq, float hifreq)
1095 {
1096         float freq, t, p[3];
1097
1098         p[0] = point[0] + 123.456;
1099         p[1] = point[1];
1100         p[2] = point[2];
1101
1102         t = 0;
1103         for (freq = lofreq; freq < hifreq; freq *= 2.0) {
1104                 t += fabsf(noise3_perlin(p)) / freq;
1105                 p[0] *= 2.0f;
1106                 p[1] *= 2.0f;
1107                 p[2] *= 2.0f;
1108         }
1109         return t - 0.3; /* readjust to make mean value = 0.0 */
1110 }
1111 #endif
1112
1113 /* for use with BLI_gNoise/gTurbulence, returns signed noise */
1114 static float orgPerlinNoise(float x, float y, float z)
1115 {
1116         float v[3];
1117
1118         v[0] = x;
1119         v[1] = y;
1120         v[2] = z;
1121         return noise3_perlin(v);
1122 }
1123
1124 /* for use with BLI_gNoise/gTurbulence, returns unsigned noise */
1125 static float orgPerlinNoiseU(float x, float y, float z)
1126 {
1127         float v[3];
1128
1129         v[0] = x;
1130         v[1] = y;
1131         v[2] = z;
1132         return (0.5f + 0.5f * noise3_perlin(v));
1133 }
1134
1135 /* *************** CALL AS: *************** */
1136
1137 float BLI_hnoisep(float noisesize, float x, float y, float z)
1138 {
1139         float vec[3];
1140
1141         vec[0] = x / noisesize;
1142         vec[1] = y / noisesize;
1143         vec[2] = z / noisesize;
1144
1145         return noise3_perlin(vec);
1146 }
1147
1148 #if 0
1149 static float turbulencep(float noisesize, float x, float y, float z, int nr)
1150 {
1151         float vec[3];
1152
1153         vec[0] = x / noisesize;
1154         vec[1] = y / noisesize;
1155         vec[2] = z / noisesize;
1156         nr++;
1157         return turbulence_perlin(vec, 1.0, (float)(1 << nr));
1158 }
1159 #endif
1160
1161 /******************/
1162 /* VORONOI/WORLEY */
1163 /******************/
1164
1165 /* distance metrics for voronoi, e parameter only used in Minkowski */
1166 /* Camberra omitted, didn't seem useful */
1167
1168 /* distance squared */
1169 static float dist_Squared(float x, float y, float z, float e)
1170 {
1171         (void)e; return (x * x + y * y + z * z);
1172 }
1173 /* real distance */
1174 static float dist_Real(float x, float y, float z, float e)
1175 {
1176         (void)e; return sqrtf(x * x + y * y + z * z);
1177 }
1178 /* manhattan/taxicab/cityblock distance */
1179 static float dist_Manhattan(float x, float y, float z, float e)
1180 {
1181         (void)e; return (fabsf(x) + fabsf(y) + fabsf(z));
1182 }
1183 /* Chebychev */
1184 static float dist_Chebychev(float x, float y, float z, float e)
1185 {
1186         float t;
1187         (void)e;
1188
1189         x = fabsf(x);
1190         y = fabsf(y);
1191         z = fabsf(z);
1192         t = (x > y) ? x : y;
1193         return ((z > t) ? z : t);
1194 }
1195
1196 /* minkowski preset exponent 0.5 */
1197 static float dist_MinkovskyH(float x, float y, float z, float e)
1198 {
1199         float d = sqrtf(fabsf(x)) + sqrtf(fabsf(y)) + sqrtf(fabsf(z));
1200         (void)e;
1201         return (d * d);
1202 }
1203
1204 /* minkowski preset exponent 4 */
1205 static float dist_Minkovsky4(float x, float y, float z, float e)
1206 {
1207         (void)e;
1208         x *= x;
1209         y *= y;
1210         z *= z;
1211         return sqrtf(sqrtf(x * x + y * y + z * z));
1212 }
1213
1214 /* Minkowski, general case, slow, maybe too slow to be useful */
1215 static float dist_Minkovsky(float x, float y, float z, float e)
1216 {
1217         return powf(powf(fabsf(x), e) + powf(fabsf(y), e) + powf(fabsf(z), e), 1.0f / e);
1218 }
1219
1220
1221 /* Not 'pure' Worley, but the results are virtually the same.
1222  * Returns distances in da and point coords in pa */
1223 void voronoi(float x, float y, float z, float *da, float *pa, float me, int dtype)
1224 {
1225         int xx, yy, zz, xi, yi, zi;
1226         float xd, yd, zd, d;
1227
1228         float (*distfunc)(float, float, float, float);
1229         switch (dtype) {
1230                 case 1:
1231                         distfunc = dist_Squared;
1232                         break;
1233                 case 2:
1234                         distfunc = dist_Manhattan;
1235                         break;
1236                 case 3:
1237                         distfunc = dist_Chebychev;
1238                         break;
1239                 case 4:
1240                         distfunc = dist_MinkovskyH;
1241                         break;
1242                 case 5:
1243                         distfunc = dist_Minkovsky4;
1244                         break;
1245                 case 6:
1246                         distfunc = dist_Minkovsky;
1247                         break;
1248                 case 0:
1249                 default:
1250                         distfunc = dist_Real;
1251                         break;
1252         }
1253
1254         xi = (int)(floor(x));
1255         yi = (int)(floor(y));
1256         zi = (int)(floor(z));
1257         da[0] = da[1] = da[2] = da[3] = 1e10f;
1258         for (xx = xi - 1; xx <= xi + 1; xx++) {
1259                 for (yy = yi - 1; yy <= yi + 1; yy++) {
1260                         for (zz = zi - 1; zz <= zi + 1; zz++) {
1261                                 const float *p = HASHPNT(xx, yy, zz);
1262                                 xd = x - (p[0] + xx);
1263                                 yd = y - (p[1] + yy);
1264                                 zd = z - (p[2] + zz);
1265                                 d = distfunc(xd, yd, zd, me);
1266                                 if (d < da[0]) {
1267                                         da[3] = da[2];  da[2] = da[1];  da[1] = da[0];  da[0] = d;
1268                                         pa[9] = pa[6];  pa[10] = pa[7];  pa[11] = pa[8];
1269                                         pa[6] = pa[3];  pa[7] = pa[4];  pa[8] = pa[5];
1270                                         pa[3] = pa[0];  pa[4] = pa[1];  pa[5] = pa[2];
1271                                         pa[0] = p[0] + xx;  pa[1] = p[1] + yy;  pa[2] = p[2] + zz;
1272                                 }
1273                                 else if (d < da[1]) {
1274                                         da[3] = da[2];  da[2] = da[1];  da[1] = d;
1275                                         pa[9] = pa[6];  pa[10] = pa[7];  pa[11] = pa[8];
1276                                         pa[6] = pa[3];  pa[7] = pa[4];  pa[8] = pa[5];
1277                                         pa[3] = p[0] + xx;  pa[4] = p[1] + yy;  pa[5] = p[2] + zz;
1278                                 }
1279                                 else if (d < da[2]) {
1280                                         da[3] = da[2];  da[2] = d;
1281                                         pa[9] = pa[6];  pa[10] = pa[7];  pa[11] = pa[8];
1282                                         pa[6] = p[0] + xx;  pa[7] = p[1] + yy;  pa[8] = p[2] + zz;
1283                                 }
1284                                 else if (d < da[3]) {
1285                                         da[3] = d;
1286                                         pa[9] = p[0] + xx;  pa[10] = p[1] + yy;  pa[11] = p[2] + zz;
1287                                 }
1288                         }
1289                 }
1290         }
1291 }
1292
1293 /* returns different feature points for use in BLI_gNoise() */
1294 static float voronoi_F1(float x, float y, float z)
1295 {
1296         float da[4], pa[12];
1297         voronoi(x, y, z, da, pa, 1, 0);
1298         return da[0];
1299 }
1300
1301 static float voronoi_F2(float x, float y, float z)
1302 {
1303         float da[4], pa[12];
1304         voronoi(x, y, z, da, pa, 1, 0);
1305         return da[1];
1306 }
1307
1308 static float voronoi_F3(float x, float y, float z)
1309 {
1310         float da[4], pa[12];
1311         voronoi(x, y, z, da, pa, 1, 0);
1312         return da[2];
1313 }
1314
1315 static float voronoi_F4(float x, float y, float z)
1316 {
1317         float da[4], pa[12];
1318         voronoi(x, y, z, da, pa, 1, 0);
1319         return da[3];
1320 }
1321
1322 static float voronoi_F1F2(float x, float y, float z)
1323 {
1324         float da[4], pa[12];
1325         voronoi(x, y, z, da, pa, 1, 0);
1326         return (da[1] - da[0]);
1327 }
1328
1329 /* Crackle type pattern, just a scale/clamp of F2-F1 */
1330 static float voronoi_Cr(float x, float y, float z)
1331 {
1332         float t = 10 * voronoi_F1F2(x, y, z);
1333         if (t > 1.f) return 1.f;
1334         return t;
1335 }
1336
1337
1338 /* Signed version of all 6 of the above, just 2x-1, not really correct though (range is potentially (0, sqrt(6)).
1339  * Used in the musgrave functions */
1340 static float voronoi_F1S(float x, float y, float z)
1341 {
1342         float da[4], pa[12];
1343         voronoi(x, y, z, da, pa, 1, 0);
1344         return (2.0f * da[0] - 1.0f);
1345 }
1346
1347 static float voronoi_F2S(float x, float y, float z)
1348 {
1349         float da[4], pa[12];
1350         voronoi(x, y, z, da, pa, 1, 0);
1351         return (2.0f * da[1] - 1.0f);
1352 }
1353
1354 static float voronoi_F3S(float x, float y, float z)
1355 {
1356         float da[4], pa[12];
1357         voronoi(x, y, z, da, pa, 1, 0);
1358         return (2.0f * da[2] - 1.0f);
1359 }
1360
1361 static float voronoi_F4S(float x, float y, float z)
1362 {
1363         float da[4], pa[12];
1364         voronoi(x, y, z, da, pa, 1, 0);
1365         return (2.0f * da[3] - 1.0f);
1366 }
1367
1368 static float voronoi_F1F2S(float x, float y, float z)
1369 {
1370         float da[4], pa[12];
1371         voronoi(x, y, z, da, pa, 1, 0);
1372         return (2.0f * (da[1] - da[0]) - 1.0f);
1373 }
1374
1375 /* Crackle type pattern, just a scale/clamp of F2-F1 */
1376 static float voronoi_CrS(float x, float y, float z)
1377 {
1378         float t = 10 * voronoi_F1F2(x, y, z);
1379         if (t > 1.f) return 1.f;
1380         return (2.0f * t - 1.0f);
1381 }
1382
1383
1384 /***************/
1385 /* voronoi end */
1386 /***************/
1387
1388 /*************/
1389 /* CELLNOISE */
1390 /*************/
1391
1392 /* returns unsigned cellnoise */
1393 static float cellNoiseU(float x, float y, float z)
1394 {
1395         int xi = (int)(floor(x));
1396         int yi = (int)(floor(y));
1397         int zi = (int)(floor(z));
1398         unsigned int n = xi + yi * 1301 + zi * 314159;
1399         n ^= (n << 13);
1400         return ((float)(n * (n * n * 15731 + 789221) + 1376312589) / 4294967296.0f);
1401 }
1402
1403 /* idem, signed */
1404 float cellNoise(float x, float y, float z)
1405 {
1406         return (2.0f * cellNoiseU(x, y, z) - 1.0f);
1407 }
1408
1409 /* returns a vector/point/color in ca, using point hasharray directly */
1410 void cellNoiseV(float x, float y, float z, float ca[3])
1411 {
1412         int xi = (int)(floor(x));
1413         int yi = (int)(floor(y));
1414         int zi = (int)(floor(z));
1415         const float *p = HASHPNT(xi, yi, zi);
1416         ca[0] = p[0];
1417         ca[1] = p[1];
1418         ca[2] = p[2];
1419 }
1420
1421
1422 /*****************/
1423 /* end cellnoise */
1424 /*****************/
1425
1426 /* newnoise: generic noise function for use with different noisebases */
1427 float BLI_gNoise(float noisesize, float x, float y, float z, int hard, int noisebasis)
1428 {
1429         float (*noisefunc)(float, float, float);
1430
1431         switch (noisebasis) {
1432                 case 1:
1433                         noisefunc = orgPerlinNoiseU;
1434                         break;
1435                 case 2:
1436                         noisefunc = newPerlinU;
1437                         break;
1438                 case 3:
1439                         noisefunc = voronoi_F1;
1440                         break;
1441                 case 4:
1442                         noisefunc = voronoi_F2;
1443                         break;
1444                 case 5:
1445                         noisefunc = voronoi_F3;
1446                         break;
1447                 case 6:
1448                         noisefunc = voronoi_F4;
1449                         break;
1450                 case 7:
1451                         noisefunc = voronoi_F1F2;
1452                         break;
1453                 case 8:
1454                         noisefunc = voronoi_Cr;
1455                         break;
1456                 case 14:
1457                         noisefunc = cellNoiseU;
1458                         break;
1459                 case 0:
1460                 default:
1461                 {
1462                         noisefunc = orgBlenderNoise;
1463                         /* add one to make return value same as BLI_hnoise */
1464                         x += 1;
1465                         y += 1;
1466                         z += 1;
1467                         break;
1468                 }
1469         }
1470
1471         if (noisesize != 0.0f) {
1472                 noisesize = 1.0f / noisesize;
1473                 x *= noisesize;
1474                 y *= noisesize;
1475                 z *= noisesize;
1476         }
1477         
1478         if (hard) return fabsf(2.0f * noisefunc(x, y, z) - 1.0f);
1479         return noisefunc(x, y, z);
1480 }
1481
1482 /* newnoise: generic turbulence function for use with different noisebasis */
1483 float BLI_gTurbulence(float noisesize, float x, float y, float z, int oct, int hard, int noisebasis)
1484 {
1485         float (*noisefunc)(float, float, float);
1486         float sum, t, amp = 1, fscale = 1;
1487         int i;
1488         
1489         switch (noisebasis) {
1490                 case 1:
1491                         noisefunc = orgPerlinNoiseU;
1492                         break;
1493                 case 2:
1494                         noisefunc = newPerlinU;
1495                         break;
1496                 case 3:
1497                         noisefunc = voronoi_F1;
1498                         break;
1499                 case 4:
1500                         noisefunc = voronoi_F2;
1501                         break;
1502                 case 5:
1503                         noisefunc = voronoi_F3;
1504                         break;
1505                 case 6:
1506                         noisefunc = voronoi_F4;
1507                         break;
1508                 case 7:
1509                         noisefunc = voronoi_F1F2;
1510                         break;
1511                 case 8:
1512                         noisefunc = voronoi_Cr;
1513                         break;
1514                 case 14:
1515                         noisefunc = cellNoiseU;
1516                         break;
1517                 case 0:
1518                 default:
1519                         noisefunc = orgBlenderNoise;
1520                         x += 1;
1521                         y += 1;
1522                         z += 1;
1523                         break;
1524         }
1525
1526         if (noisesize != 0.0f) {
1527                 noisesize = 1.0f / noisesize;
1528                 x *= noisesize;
1529                 y *= noisesize;
1530                 z *= noisesize;
1531         }
1532
1533         sum = 0;
1534         for (i = 0; i <= oct; i++, amp *= 0.5f, fscale *= 2.0f) {
1535                 t = noisefunc(fscale * x, fscale * y, fscale * z);
1536                 if (hard) t = fabsf(2.0f * t - 1.0f);
1537                 sum += t * amp;
1538         }
1539         
1540         sum *= ((float)(1 << oct) / (float)((1 << (oct + 1)) - 1));
1541
1542         return sum;
1543
1544 }
1545
1546
1547 /*
1548  * The following code is based on Ken Musgrave's explanations and sample
1549  * source code in the book "Texturing and Modeling: A procedural approach"
1550  */
1551
1552 /*
1553  * Procedural fBm evaluated at "point"; returns value stored in "value".
1554  *
1555  * Parameters:
1556  *    ``H''  is the fractal increment parameter
1557  *    ``lacunarity''  is the gap between successive frequencies
1558  *    ``octaves''  is the number of frequencies in the fBm
1559  */
1560 float mg_fBm(float x, float y, float z, float H, float lacunarity, float octaves, int noisebasis)
1561 {
1562         float rmd, value = 0.0, pwr = 1.0, pwHL = powf(lacunarity, -H);
1563         int i;
1564
1565         float (*noisefunc)(float, float, float);
1566         switch (noisebasis) {
1567                 case 1:
1568                         noisefunc = orgPerlinNoise;
1569                         break;
1570                 case 2:
1571                         noisefunc = newPerlin;
1572                         break;
1573                 case 3:
1574                         noisefunc = voronoi_F1S;
1575                         break;
1576                 case 4:
1577                         noisefunc = voronoi_F2S;
1578                         break;
1579                 case 5:
1580                         noisefunc = voronoi_F3S;
1581                         break;
1582                 case 6:
1583                         noisefunc = voronoi_F4S;
1584                         break;
1585                 case 7:
1586                         noisefunc = voronoi_F1F2S;
1587                         break;
1588                 case 8:
1589                         noisefunc = voronoi_CrS;
1590                         break;
1591                 case 14:
1592                         noisefunc = cellNoise;
1593                         break;
1594                 case 0:
1595                 default:
1596                 {
1597                         noisefunc = orgBlenderNoiseS;
1598                         break;
1599                 }
1600         }
1601         
1602         for (i = 0; i < (int)octaves; i++) {
1603                 value += noisefunc(x, y, z) * pwr;
1604                 pwr *= pwHL;
1605                 x *= lacunarity;
1606                 y *= lacunarity;
1607                 z *= lacunarity;
1608         }
1609
1610         rmd = octaves - floorf(octaves);
1611         if (rmd != 0.f) value += rmd * noisefunc(x, y, z) * pwr;
1612
1613         return value;
1614
1615 } /* fBm() */
1616
1617
1618 /*
1619  * Procedural multifractal evaluated at "point";
1620  * returns value stored in "value".
1621  *
1622  * Parameters:
1623  *    ``H''  determines the highest fractal dimension
1624  *    ``lacunarity''  is gap between successive frequencies
1625  *    ``octaves''  is the number of frequencies in the fBm
1626  *    ``offset''  is the zero offset, which determines multifractality (NOT USED??)
1627  */
1628
1629 /* this one is in fact rather confusing,
1630  * there seem to be errors in the original source code (in all three versions of proc.text&mod),
1631  * I modified it to something that made sense to me, so it might be wrong... */
1632 float mg_MultiFractal(float x, float y, float z, float H, float lacunarity, float octaves, int noisebasis)
1633 {
1634         float rmd, value = 1.0, pwr = 1.0, pwHL = powf(lacunarity, -H);
1635         int i;
1636
1637         float (*noisefunc)(float, float, float);
1638         switch (noisebasis) {
1639                 case 1:
1640                         noisefunc = orgPerlinNoise;
1641                         break;
1642                 case 2:
1643                         noisefunc = newPerlin;
1644                         break;
1645                 case 3:
1646                         noisefunc = voronoi_F1S;
1647                         break;
1648                 case 4:
1649                         noisefunc = voronoi_F2S;
1650                         break;
1651                 case 5:
1652                         noisefunc = voronoi_F3S;
1653                         break;
1654                 case 6:
1655                         noisefunc = voronoi_F4S;
1656                         break;
1657                 case 7:
1658                         noisefunc = voronoi_F1F2S;
1659                         break;
1660                 case 8:
1661                         noisefunc = voronoi_CrS;
1662                         break;
1663                 case 14:
1664                         noisefunc = cellNoise;
1665                         break;
1666                 case 0:
1667                 default:
1668                 {
1669                         noisefunc = orgBlenderNoiseS;
1670                         break;
1671                 }
1672         }
1673
1674         for (i = 0; i < (int)octaves; i++) {
1675                 value *= (pwr * noisefunc(x, y, z) + 1.0f);
1676                 pwr *= pwHL;
1677                 x *= lacunarity;
1678                 y *= lacunarity;
1679                 z *= lacunarity;
1680         }
1681         rmd = octaves - floorf(octaves);
1682         if (rmd != 0.0f) value *= (rmd * noisefunc(x, y, z) * pwr + 1.0f);
1683
1684         return value;
1685
1686 } /* multifractal() */
1687
1688 /*
1689  * Heterogeneous procedural terrain function: stats by altitude method.
1690  * Evaluated at "point"; returns value stored in "value".
1691  *
1692  * Parameters:
1693  *       ``H''  determines the fractal dimension of the roughest areas
1694  *       ``lacunarity''  is the gap between successive frequencies
1695  *       ``octaves''  is the number of frequencies in the fBm
1696  *       ``offset''  raises the terrain from `sea level'
1697  */
1698 float mg_HeteroTerrain(float x, float y, float z, float H, float lacunarity, float octaves, float offset, int noisebasis)
1699 {
1700         float value, increment, rmd;
1701         int i;
1702         float pwHL = powf(lacunarity, -H);
1703         float pwr = pwHL;   /* starts with i=1 instead of 0 */
1704
1705         float (*noisefunc)(float, float, float);
1706         switch (noisebasis) {
1707                 case 1:
1708                         noisefunc = orgPerlinNoise;
1709                         break;
1710                 case 2:
1711                         noisefunc = newPerlin;
1712                         break;
1713                 case 3:
1714                         noisefunc = voronoi_F1S;
1715                         break;
1716                 case 4:
1717                         noisefunc = voronoi_F2S;
1718                         break;
1719                 case 5:
1720                         noisefunc = voronoi_F3S;
1721                         break;
1722                 case 6:
1723                         noisefunc = voronoi_F4S;
1724                         break;
1725                 case 7:
1726                         noisefunc = voronoi_F1F2S;
1727                         break;
1728                 case 8:
1729                         noisefunc = voronoi_CrS;
1730                         break;
1731                 case 14:
1732                         noisefunc = cellNoise;
1733                         break;
1734                 case 0:
1735                 default:
1736                 {
1737                         noisefunc = orgBlenderNoiseS;
1738                         break;
1739                 }
1740         }
1741
1742         /* first unscaled octave of function; later octaves are scaled */
1743         value = offset + noisefunc(x, y, z);
1744         x *= lacunarity;
1745         y *= lacunarity;
1746         z *= lacunarity;
1747
1748         for (i = 1; i < (int)octaves; i++) {
1749                 increment = (noisefunc(x, y, z) + offset) * pwr * value;
1750                 value += increment;
1751                 pwr *= pwHL;
1752                 x *= lacunarity;
1753                 y *= lacunarity;
1754                 z *= lacunarity;
1755         }
1756
1757         rmd = octaves - floorf(octaves);
1758         if (rmd != 0.0f) {
1759                 increment = (noisefunc(x, y, z) + offset) * pwr * value;
1760                 value += rmd * increment;
1761         }
1762         return value;
1763 }
1764
1765
1766 /* Hybrid additive/multiplicative multifractal terrain model.
1767  *
1768  * Some good parameter values to start with:
1769  *
1770  *      H:           0.25
1771  *      offset:      0.7
1772  */
1773 float mg_HybridMultiFractal(float x, float y, float z, float H, float lacunarity, float octaves, float offset, float gain, int noisebasis)
1774 {
1775         float result, signal, weight, rmd;
1776         int i;
1777         float pwHL = powf(lacunarity, -H);
1778         float pwr = pwHL;   /* starts with i=1 instead of 0 */
1779         float (*noisefunc)(float, float, float);
1780
1781         switch (noisebasis) {
1782                 case 1:
1783                         noisefunc = orgPerlinNoise;
1784                         break;
1785                 case 2:
1786                         noisefunc = newPerlin;
1787                         break;
1788                 case 3:
1789                         noisefunc = voronoi_F1S;
1790                         break;
1791                 case 4:
1792                         noisefunc = voronoi_F2S;
1793                         break;
1794                 case 5:
1795                         noisefunc = voronoi_F3S;
1796                         break;
1797                 case 6:
1798                         noisefunc = voronoi_F4S;
1799                         break;
1800                 case 7:
1801                         noisefunc = voronoi_F1F2S;
1802                         break;
1803                 case 8:
1804                         noisefunc = voronoi_CrS;
1805                         break;
1806                 case 14:
1807                         noisefunc = cellNoise;
1808                         break;
1809                 case 0:
1810                 default:
1811                 {
1812                         noisefunc = orgBlenderNoiseS;
1813                         break;
1814                 }
1815         }
1816
1817         result = noisefunc(x, y, z) + offset;
1818         weight = gain * result;
1819         x *= lacunarity;
1820         y *= lacunarity;
1821         z *= lacunarity;
1822
1823         for (i = 1; (weight > 0.001f) && (i < (int)octaves); i++) {
1824                 if (weight > 1.0f) weight = 1.0f;
1825                 signal = (noisefunc(x, y, z) + offset) * pwr;
1826                 pwr *= pwHL;
1827                 result += weight * signal;
1828                 weight *= gain * signal;
1829                 x *= lacunarity;
1830                 y *= lacunarity;
1831                 z *= lacunarity;
1832         }
1833
1834         rmd = octaves - floorf(octaves);
1835         if (rmd != 0.f) result += rmd * ((noisefunc(x, y, z) + offset) * pwr);
1836
1837         return result;
1838
1839 } /* HybridMultifractal() */
1840
1841
1842 /* Ridged multifractal terrain model.
1843  *
1844  * Some good parameter values to start with:
1845  *
1846  *      H:           1.0
1847  *      offset:      1.0
1848  *      gain:        2.0
1849  */
1850 float mg_RidgedMultiFractal(float x, float y, float z, float H, float lacunarity, float octaves, float offset, float gain, int noisebasis)
1851 {
1852         float result, signal, weight;
1853         int i;
1854         float pwHL = powf(lacunarity, -H);
1855         float pwr = pwHL;   /* starts with i=1 instead of 0 */
1856         
1857         float (*noisefunc)(float, float, float);
1858         switch (noisebasis) {
1859                 case 1:
1860                         noisefunc = orgPerlinNoise;
1861                         break;
1862                 case 2:
1863                         noisefunc = newPerlin;
1864                         break;
1865                 case 3:
1866                         noisefunc = voronoi_F1S;
1867                         break;
1868                 case 4:
1869                         noisefunc = voronoi_F2S;
1870                         break;
1871                 case 5:
1872                         noisefunc = voronoi_F3S;
1873                         break;
1874                 case 6:
1875                         noisefunc = voronoi_F4S;
1876                         break;
1877                 case 7:
1878                         noisefunc = voronoi_F1F2S;
1879                         break;
1880                 case 8:
1881                         noisefunc = voronoi_CrS;
1882                         break;
1883                 case 14:
1884                         noisefunc = cellNoise;
1885                         break;
1886                 case 0:
1887                 default:
1888                 {
1889                         noisefunc = orgBlenderNoiseS;
1890                         break;
1891                 }
1892         }
1893
1894         signal = offset - fabsf(noisefunc(x, y, z));
1895         signal *= signal;
1896         result = signal;
1897
1898
1899         for (i = 1; i < (int)octaves; i++) {
1900                 x *= lacunarity;
1901                 y *= lacunarity;
1902                 z *= lacunarity;
1903                 weight = signal * gain;
1904                 if      (weight > 1.0f) weight = 1.0f;
1905                 else if (weight < 0.0f) weight = 0.0f;
1906                 signal = offset - fabsf(noisefunc(x, y, z));
1907                 signal *= signal;
1908                 signal *= weight;
1909                 result += signal * pwr;
1910                 pwr *= pwHL;
1911         }
1912
1913         return result;
1914 } /* RidgedMultifractal() */
1915
1916 /* "Variable Lacunarity Noise"
1917  * A distorted variety of Perlin noise.
1918  */
1919 float mg_VLNoise(float x, float y, float z, float distortion, int nbas1, int nbas2)
1920 {
1921         float rv[3];
1922         float (*noisefunc1)(float, float, float);
1923         float (*noisefunc2)(float, float, float);
1924
1925         switch (nbas1) {
1926                 case 1:
1927                         noisefunc1 = orgPerlinNoise;
1928                         break;
1929                 case 2:
1930                         noisefunc1 = newPerlin;
1931                         break;
1932                 case 3:
1933                         noisefunc1 = voronoi_F1S;
1934                         break;
1935                 case 4:
1936                         noisefunc1 = voronoi_F2S;
1937                         break;
1938                 case 5:
1939                         noisefunc1 = voronoi_F3S;
1940                         break;
1941                 case 6:
1942                         noisefunc1 = voronoi_F4S;
1943                         break;
1944                 case 7:
1945                         noisefunc1 = voronoi_F1F2S;
1946                         break;
1947                 case 8:
1948                         noisefunc1 = voronoi_CrS;
1949                         break;
1950                 case 14:
1951                         noisefunc1 = cellNoise;
1952                         break;
1953                 case 0:
1954                 default:
1955                 {
1956                         noisefunc1 = orgBlenderNoiseS;
1957                         break;
1958                 }
1959         }
1960
1961         switch (nbas2) {
1962                 case 1:
1963                         noisefunc2 = orgPerlinNoise;
1964                         break;
1965                 case 2:
1966                         noisefunc2 = newPerlin;
1967                         break;
1968                 case 3:
1969                         noisefunc2 = voronoi_F1S;
1970                         break;
1971                 case 4:
1972                         noisefunc2 = voronoi_F2S;
1973                         break;
1974                 case 5:
1975                         noisefunc2 = voronoi_F3S;
1976                         break;
1977                 case 6:
1978                         noisefunc2 = voronoi_F4S;
1979                         break;
1980                 case 7:
1981                         noisefunc2 = voronoi_F1F2S;
1982                         break;
1983                 case 8:
1984                         noisefunc2 = voronoi_CrS;
1985                         break;
1986                 case 14:
1987                         noisefunc2 = cellNoise;
1988                         break;
1989                 case 0:
1990                 default:
1991                 {
1992                         noisefunc2 = orgBlenderNoiseS;
1993                         break;
1994                 }
1995         }
1996
1997         /* get a random vector and scale the randomization */
1998         rv[0] = noisefunc1(x + 13.5f, y + 13.5f, z + 13.5f) * distortion;
1999         rv[1] = noisefunc1(x, y, z) * distortion;
2000         rv[2] = noisefunc1(x - 13.5f, y - 13.5f, z - 13.5f) * distortion;
2001         return noisefunc2(x + rv[0], y + rv[1], z + rv[2]);   /* distorted-domain noise */
2002 }
2003
2004 /****************/
2005 /* musgrave end */
2006 /****************/