ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/include/noise.h
(Generate patch)

Comparing deliantra/server/include/noise.h (file contents):
Revision 1.4 by root, Fri Apr 22 07:56:47 2011 UTC vs.
Revision 1.5 by root, Sat Apr 23 04:46:26 2011 UTC

… …
21 */ 21 */
22 22
23#ifndef NOISE_H_ 23#ifndef NOISE_H_
24#define NOISE_H_ 24#define NOISE_H_
25 25
26#include <blitz/tinyvec.h>
27#include <blitz/tinyvec-et.h>
28
26#include "global.h" 29#include "global.h"
27 30
28template<int N, typename T = float> 31typedef blitz::TinyVector<float,2> vec2d;
29struct gen_vec_base 32typedef blitz::TinyVector<float,3> vec3d;
30{
31 enum { D = N };
32 T v[N];
33
34 T &operator [](int n)
35 {
36 return v[n];
37 }
38
39 template<typename U>
40 const gen_vec_base<N,T> &operator =(gen_vec_base<N,U> v)
41 {
42 for (int i = 0; i < N; ++i)
43 this->v[i] = v.v[i];
44
45 return *this;
46 }
47};
48
49template<int N, typename T>
50gen_vec_base<N,T> floor (gen_vec_base<N,T> v)
51{
52 for (int i = 0; i < N; ++i)
53 v[i] = floor (v[i]);
54
55 return v;
56}
57
58template<int N, typename T, typename U>
59gen_vec_base<N,T> operator +(gen_vec_base<N,T> a, gen_vec_base<N,U> b)
60{
61 gen_vec_base<N,T> c;
62
63 for (int i = 0; i < N; ++i)
64 c[i] = a[i] + b[i];
65
66 return c;
67}
68
69template<int N, typename T, typename U>
70gen_vec_base<N,T> operator -(gen_vec_base<N,T> a, gen_vec_base<N,U> b)
71{
72 gen_vec_base<N,T> c;
73
74 for (int i = 0; i < N; ++i)
75 c[i] = a[i] - b[i];
76
77 return c;
78}
79
80template<int N, typename T, typename U>
81T operator *(gen_vec_base<N,T> a, gen_vec_base<N,U> b)
82{
83 T v = 0;
84
85 for (int i = 0; i < N; ++i)
86 v += a[i] * b[i];
87
88 return v;
89}
90
91template<int N, typename T = float>
92struct gen_vec;
93
94template<typename T>
95struct gen_vec<2,T> : gen_vec_base<2,T>
96{
97 using gen_vec_base<2,T>::operator =;
98
99 gen_vec ()
100 {
101 }
102
103 gen_vec (T x, T y)
104 {
105 this->v[0] = x;
106 this->v[1] = y;
107 }
108
109 template<typename U>
110 gen_vec (gen_vec_base<2,U> v)
111 {
112 *this = v;
113 }
114};
115
116template<typename T>
117struct gen_vec<3,T> : gen_vec_base<3,T>
118{
119 gen_vec ()
120 {
121 }
122
123 gen_vec (T x, T y, T z)
124 {
125 this->v[0] = x;
126 this->v[1] = y;
127 this->v[2] = z;
128 }
129
130 template<typename U>
131 gen_vec (gen_vec_base<3,U> v)
132 {
133 *this = v;
134 }
135};
136
137typedef gen_vec<2> vec2d;
138typedef gen_vec<3> vec3d;
139
140template<int N, typename T = float>
141struct space
142{
143 enum { D = N };
144 typedef gen_vec<N,T> vec;
145};
146
147typedef space<2> space2d;
148typedef space<3> space3d;
149 33
150///////////////////////////////////////////////////////////////////////////// 34/////////////////////////////////////////////////////////////////////////////
151 35
152template<int N, typename T = uint8_t> 36template<int N, typename T = uint8_t>
153struct permutation 37struct permutation
154{ 38{
155 T pmap [N]; 39 T pmap[N];
156 40
157 template<class generator> 41 template<class generator>
158 void seed (generator &rng) 42 void seed (generator &rng)
159 { 43 {
160 for (int i = 0; i < N; ++i) 44 for (int i = 0; i < N; ++i)
161 pmap [i] = i; 45 pmap[i] = i;
162 46
163 // fisher-yates to randomly perturb 47 // fisher-yates to randomly perturb
164 for (int i = N; --i; ) 48 for (int i = N; --i; )
165 ::swap (pmap [i], pmap [::rmg_rndm (i + 1)]); 49 ::swap (pmap[i], pmap[rng (i + 1)]);
166 } 50 }
167 51
168 T operator ()(T v) 52 T operator ()(T v)
169 { 53 {
170 return pmap [v & (N - 1)]; 54 return pmap[v & (N - 1)];
171 } 55 }
172}; 56};
173 57
58template<class vec_t>
59struct noise_gen;
60
174// modelled after 2d/3d kensler noise without projection 61// modelled after 2d/3d kensler noise without projection
62template<>
175struct noise2d 63struct noise_gen<vec2d>
176{ 64{
177 permutation<256, uint8_t> rvmap[2]; 65 permutation<256, uint8_t> rvmap[2];
178 vec2d rvec[256]; // random unit vectors 66 vec2d rvec[256]; // random unit vectors
179 67
180 noise2d (uint32_t seed); 68 noise_gen<vec2d> (uint32_t seed);
181 float noise (float x, float y); 69 vec2d::T_numtype operator() (vec2d P);
182}; 70};
183 71
72template<>
184struct noise3d 73struct noise_gen<vec3d>
185{ 74{
186 permutation<256, uint8_t> rvmap[3]; 75 permutation<256, uint8_t> rvmap[3];
187 float rvec[256][3]; // random unit vectors
188 76
189 noise3d (uint32_t seed); 77 noise_gen<vec3d> (uint32_t seed);
190 float noise (float x, float y, float z); 78 vec2d::T_numtype operator() (vec3d P);
191 79
192 // noise projected on a surface with normal n 80 // noise projected on a surface with normal n
193 float noise (float x, float y, float z, float nx, float ny, float nz); 81 vec2d::T_numtype operator() (vec3d P, vec3d N);
194}; 82};
195 83
84template<class vec_t, int a, int b>
196struct rotate 85struct rotate_nn
197{ 86{
198 float s, c; 87 typename vec_t::T_numtype s, c;
199 88
200 void set (float angle) 89 void set (typename vec_t::T_numtype angle)
201 { 90 {
202 s = sinf (angle); 91 s = sin (angle);
203 c = cosf (angle); 92 c = cos (angle);
204 } 93 }
205 94
206 void operator ()(float &x, float &y) const 95 void operator ()(vec_t &P) const
207 { 96 {
208 float xr = x * c - y * s; 97 vec_t o = P;
209 float yr = x * s + y * c;
210 98
211 x = xr; 99 P[a] = o[a] * c - o[b] * s;
212 y = yr; 100 P[b] = o[a] * s + o[b] * c;
213 } 101 }
214}; 102};
215 103
104template<class vec_t>
105struct rotate_xy : rotate_nn<vec_t, 0, 1>
106{
107};
108
109template<class vec_t>
110struct rotate_xz : rotate_nn<vec_t, 0, 2>
111{
112};
113
114template<class vec_t>
115struct rotate_yz : rotate_nn<vec_t, 1, 2>
116{
117};
118
119template<class vec_t>
216struct frac_gen 120struct frac_gen
217: noise2d 121: noise_gen<vec_t>
218{ 122{
219 enum { MAX_OCTAVES = 64 }; 123 enum { MAX_OCTAVES = 64 };
220 124
221 float h, lac, ex [MAX_OCTAVES]; 125 typedef typename vec_t::T_numtype value_t;
222 float fbm_mul [MAX_OCTAVES];
223 rotate rot [MAX_OCTAVES];
224 126
225 frac_gen (float hurst_expo = .5f, float lacunarity = 2.f); 127 value_t h, lac, ex[MAX_OCTAVES];
128 value_t fbm_mul[MAX_OCTAVES];
129 rotate_xy<vec_t> rot[MAX_OCTAVES];
226 130
227 float fBm (float x, float y, int octaves); 131 value_t noise (vec_t P)
228 float turbulence (float x, float y, int octaves); 132 {
229 float multifractal (float x, float y, int octaves, float offset = 1); 133 return operator() (P);
230 float heterofractal (float x, float y, int octaves, float offset = 1); 134 }
135
136 frac_gen (value_t hurst_expo = .5f, value_t lacunarity = 2.f);
137
138 value_t fBm (vec_t P, int octaves);
139 value_t turbulence (vec_t P, int octaves);
140 value_t multifractal (vec_t P, int octaves, value_t offset = 1);
141 value_t heterofractal (vec_t P, int octaves, value_t offset = 1);
231 float hybridfractal (float x, float y, int octaves, float offset = 1, float gain = 1); 142 value_t hybridfractal (vec_t P, int octaves, value_t offset = 1, value_t gain = 1);
232 float terrain (float x, float y, int octaves); 143 value_t terrain (vec_t P, int octaves);
233 float terrain2 (float x, float y, int octaves); 144 value_t terrain2 (vec_t P, int octaves);
234 float ridgedmultifractal (float x, float y, int octaves, float offset = 1, float gain = 8); 145 value_t ridgedmultifractal (vec_t P, int octaves, value_t offset = 1, value_t gain = 8);
235}; 146};
236 147
237#endif 148#endif
149

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines