server/include/noise.h

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 * 
 * Copyright (©) 2010,2011 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
 * 
 * Deliantra is free software: you can redistribute it and/or modify it under
 * the terms of the Affero GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the Affero GNU General Public License
 * and the GNU General Public License along with this program. If not, see
 * <http://www.gnu.org/licenses/>.
 * 
 * The authors can be reached via e-mail to <support@deliantra.net>
 */

#ifndef NOISE_H_
#define NOISE_H_

#include <blitz/tinyvec.h>
#include <blitz/tinyvec-et.h>

#include "global.h"

typedef blitz::TinyVector<float,2> vec2d;
typedef blitz::TinyVector<float,3> vec3d;

/////////////////////////////////////////////////////////////////////////////

template<int N, typename T = uint8_t>
struct permutation
{
  T pmap[N];

  template<class random_generator>
  void seed (random_generator &rng);

  T operator ()(T v)
  {
    return pmap[v & (N - 1)];
  }
};

template<class vec_t>
struct noise_gen;

// modelled after 2d/3d kensler noise without projection
template<>
struct noise_gen<vec2d>
{
  static vec2d::T_numtype abs_avg() { return 0.2231; } // avg(abs(noise))

  permutation<256, uint8_t> rvmap[2];

  noise_gen<vec2d> (uint32_t seed);
  vec2d::T_numtype operator() (vec2d P);
};

template<>
struct noise_gen<vec3d>
{
  static vec3d::T_numtype abs_avg() { return 0.415; } // avg(abs(noise))

  permutation<256, uint8_t> rvmap[3];

  noise_gen<vec3d> (uint32_t seed);
  vec2d::T_numtype operator() (vec3d P);

  // noise projected on a surface with normal n
  vec2d::T_numtype operator() (vec3d P, vec3d N);
};

template<class vec_t, int a, int b>
struct rotate_nn
{
  typename vec_t::T_numtype s, c;

  void set (typename vec_t::T_numtype angle)
  {
    s = sin (angle);
    c = cos (angle);
  }

  void operator ()(vec_t &P) const
  {
    vec_t o = P;

    P[a] = o[a] * c - o[b] * s;
    P[b] = o[a] * s + o[b] * c;
  }
};

template<class vec_t>
struct rotate_xy : rotate_nn<vec_t, 0, 1>
{
};

template<class vec_t>
struct rotate_xz : rotate_nn<vec_t, 0, 2>
{
};

template<class vec_t>
struct rotate_yz : rotate_nn<vec_t, 1, 2>
{
};

template<class vec_t>
struct frac_gen
: noise_gen<vec_t>
{
  enum { MAX_OCTAVES = 32 };

  typedef typename vec_t::T_numtype value_t;

  value_t h, lac, ex[MAX_OCTAVES];
  value_t fbm_mul[MAX_OCTAVES];
  rotate_xy<vec_t> rot[MAX_OCTAVES];

  value_t noise (vec_t P)
  {
    return operator() (P);
  }

  frac_gen (value_t hurst_expo = .5, value_t lacunarity = 2);

  value_t fBm (vec_t P, int octaves);
  value_t turbulence (vec_t P, int octaves);
  value_t multifractal (vec_t P, int octaves, value_t offset = 1);
  value_t heterofractal (vec_t P, int octaves, value_t offset = 1);
  value_t hybridfractal (vec_t P, int octaves, value_t offset = 1, value_t gain = 1);
  value_t ridgedmultifractal (vec_t P, int octaves, value_t offset = 1, value_t gain = 8);
  value_t billowfractal (vec_t P, int octaves, value_t offset = 1, value_t gain = 2);
  value_t terrain (vec_t P, int octaves);
  value_t terrain2 (vec_t P, int octaves);
};

#endif

Revision:	1.8
Committed:	Tue Apr 26 03:18:07 2011 UTC (13 years, 1 month ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.7:	+8 -4 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	/*
2			* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3			*
4	root	1.6	* Copyright (©) 2010,2011 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	root	1.1	*
6			* Deliantra is free software: you can redistribute it and/or modify it under
7			* the terms of the Affero GNU General Public License as published by the
8			* Free Software Foundation, either version 3 of the License, or (at your
9			* option) any later version.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the Affero GNU General Public License
17			* and the GNU General Public License along with this program. If not, see
18			* <http://www.gnu.org/licenses/>.
19			*
20			* The authors can be reached via e-mail to <support@deliantra.net>
21			*/
22
23			#ifndef NOISE_H_
24			#define NOISE_H_
25
26	root	1.5	#include <blitz/tinyvec.h>
27			#include <blitz/tinyvec-et.h>
28
29	root	1.1	#include "global.h"
30
31	root	1.5	typedef blitz::TinyVector<float,2> vec2d;
32			typedef blitz::TinyVector<float,3> vec3d;
33	root	1.3
34			/////////////////////////////////////////////////////////////////////////////
35
36	root	1.1	template<int N, typename T = uint8_t>
37			struct permutation
38			{
39	root	1.5	T pmap[N];
40	root	1.1
41	root	1.7	template<class random_generator>
42			void seed (random_generator &rng);
43	root	1.1
44			T operator ()(T v)
45			{
46	root	1.5	return pmap[v & (N - 1)];
47	root	1.1	}
48			};
49
50	root	1.5	template<class vec_t>
51			struct noise_gen;
52
53	root	1.3	// modelled after 2d/3d kensler noise without projection
54	root	1.5	template<>
55			struct noise_gen<vec2d>
56	root	1.1	{
57	root	1.8	static vec2d::T_numtype abs_avg() { return 0.2231; } // avg(abs(noise))
58
59	root	1.1	permutation<256, uint8_t> rvmap[2];
60
61	root	1.5	noise_gen<vec2d> (uint32_t seed);
62			vec2d::T_numtype operator() (vec2d P);
63	root	1.1	};
64
65	root	1.5	template<>
66			struct noise_gen<vec3d>
67	root	1.3	{
68	root	1.8	static vec3d::T_numtype abs_avg() { return 0.415; } // avg(abs(noise))
69
70	root	1.3	permutation<256, uint8_t> rvmap[3];
71
72	root	1.5	noise_gen<vec3d> (uint32_t seed);
73			vec2d::T_numtype operator() (vec3d P);
74	root	1.3
75			// noise projected on a surface with normal n
76	root	1.5	vec2d::T_numtype operator() (vec3d P, vec3d N);
77	root	1.3	};
78
79	root	1.5	template<class vec_t, int a, int b>
80			struct rotate_nn
81	root	1.1	{
82	root	1.5	typename vec_t::T_numtype s, c;
83	root	1.1
84	root	1.5	void set (typename vec_t::T_numtype angle)
85	root	1.1	{
86	root	1.5	s = sin (angle);
87			c = cos (angle);
88	root	1.1	}
89
90	root	1.5	void operator ()(vec_t &P) const
91	root	1.1	{
92	root	1.5	vec_t o = P;
93	root	1.1
94	root	1.5	P[a] = o[a] * c - o[b] * s;
95			P[b] = o[a] * s + o[b] * c;
96	root	1.1	}
97			};
98
99	root	1.5	template<class vec_t>
100			struct rotate_xy : rotate_nn<vec_t, 0, 1>
101			{
102			};
103
104			template<class vec_t>
105			struct rotate_xz : rotate_nn<vec_t, 0, 2>
106			{
107			};
108
109			template<class vec_t>
110			struct rotate_yz : rotate_nn<vec_t, 1, 2>
111			{
112			};
113
114			template<class vec_t>
115	root	1.1	struct frac_gen
116	root	1.5	: noise_gen<vec_t>
117	root	1.1	{
118	root	1.8	enum { MAX_OCTAVES = 32 };
119	root	1.1
120	root	1.5	typedef typename vec_t::T_numtype value_t;
121
122			value_t h, lac, ex[MAX_OCTAVES];
123			value_t fbm_mul[MAX_OCTAVES];
124			rotate_xy<vec_t> rot[MAX_OCTAVES];
125
126			value_t noise (vec_t P)
127			{
128			return operator() (P);
129			}
130
131	root	1.8	frac_gen (value_t hurst_expo = .5, value_t lacunarity = 2);
132	root	1.5
133			value_t fBm (vec_t P, int octaves);
134			value_t turbulence (vec_t P, int octaves);
135			value_t multifractal (vec_t P, int octaves, value_t offset = 1);
136			value_t heterofractal (vec_t P, int octaves, value_t offset = 1);
137			value_t hybridfractal (vec_t P, int octaves, value_t offset = 1, value_t gain = 1);
138	root	1.8	value_t ridgedmultifractal (vec_t P, int octaves, value_t offset = 1, value_t gain = 8);
139			value_t billowfractal (vec_t P, int octaves, value_t offset = 1, value_t gain = 2);
140	root	1.5	value_t terrain (vec_t P, int octaves);
141			value_t terrain2 (vec_t P, int octaves);
142	root	1.1	};
143
144			#endif
145	root	1.5