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