anulax
/
glm
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity

Updated noise implementation

Browse Source
master
Christophe Riccio ago%!(EXTRA string=15 years)
parent b2ae0a3ce9
commit a338b2771a
1 changed files with 70 additions and 309 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 375
      glm/core/func_noise.inl

375
glm/core/func_noise.inl
Unescape View File

@ -2,7 +2,7 @@
// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net) // OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
/////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2008-08-01 // Created : 2008-08-01
// Updated : 2008-09-23 // Updated : 2011-04-14
// Licence : This source is under MIT License // Licence : This source is under MIT License
// File : glm/core/func_noise.inl // File : glm/core/func_noise.inl
/////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////
@ -14,324 +14,85 @@ namespace glm
namespace noise{ namespace noise{
namespace detail namespace detail
{ {
template <typenane valType, typenane vecType> template <typenane valType, typenane genType>
inline vecType permute inline vecType permute
( (
vecType const & x0, genType const & x0,
detail::tvec3<valType> const & p detail::tvec3<valType> const & p
) )
{ {
vecType x1 = mod(x0 * p.y, p.x); genType x1 = mod(x0 * p.y, p.x);
return floor( mod( (x1 + p.z) *x0, p.x )); return floor(mod((x1 + p.z) * x0, p.x));
} }
inline detail::tvec2<T> permute template <typenane T>
( inline T taylorInvSqrt(T const & r)
detail::tvec2<T> const & x0,
detail::tvec3<valType> const & p
)
{
vec2 x1 = mod(x0 * p.y, p.x);
return floor( mod( (x1 + p.z) *x0, p.x ));
}
inline vec3 permute(vec3 x0,vec3 p)
{ {
vec3 x1 = mod(x0 * p.y, p.x); return T(0.83666002653408) + T(0.7) * T(0.85373472095314) - T(0.85373472095314) * r);
return floor( mod( (x1 + p.z) *x0, p.x ));
}
inline vec4 permute(vec4 x0,vec3 p)
{
vec4 x1 = mod(x0 * p.y, p.x);
return floor( mod( (x1 + p.z) *x0, p.x ));
} }
}//namespace detail }//namespace detail
// noise1
template <typename genType>
inline genType noise1
(
genType const & x
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'noise1' only accept floating-point values");
int iNbr = int(x + genType(3) / genType(2)) * 1103515245 + 12345;
return genType(int(iNbr / genType(65536)) % 32768) / genType(32767);
}
template <typename T>
inline typename detail::tvec2<T>::value_type noise1
(
detail::tvec2<T> const & x
)
{
T tmp(0);
for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
tmp += x[i];
return noise1(tmp);
}
template <typename T>
inline typename detail::tvec3<T>::value_type noise1
(
detail::tvec3<T> const & x
)
{
T tmp(0);
for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
tmp += x[i];
return noise1(tmp);
}
template <typename T>
inline typename detail::tvec4<T>::value_type noise1
(
detail::tvec4<T> const & x
)
{
T tmp(0);
for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
tmp += x[i];
return noise1(tmp);
}
// noise2
template <typename genType>
inline detail::tvec2<genType> noise2
(
genType const & x
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'noise2' only accept floating-point values");
genType f1 = x * genType(1103515245) + genType(12345);
genType f2 = f1 * genType(1103515245) + genType(12345);
return detail::tvec2<genType>(
noise1(f1),
noise1(f2));
}
template <typename T>
inline detail::tvec2<T> noise2
(
detail::tvec2<T> const & x
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'noise2' only accept floating-point values");
T f0(0);
for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
f0 += x[i];
T f1 = f0 * T(1103515245) + T(12345);
T f2 = f1 * T(1103515245) + T(12345);
return detail::tvec2<T>(
noise1(f1),
noise1(f2));
}
template <typename T>
inline detail::tvec2<T> noise2
(
detail::tvec3<T> const & x
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'noise2' only accept floating-point values");
T f0(0);
for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
f0 += x[i];
T f1 = f0 * T(1103515245) + T(12345);
T f2 = f1 * T(1103515245) + T(12345);
return detail::tvec2<T>(
noise1(f1),
noise1(f2));
}
template <typename T>
inline detail::tvec2<T> noise2
(
detail::tvec4<T> const & x
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'noise2' only accept floating-point values");
T f0(0);
for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
f0 += x[i];
T f1 = f0 * T(1103515245) + T(12345);
T f2 = f1 * T(1103515245) + T(12345);
return detail::tvec2<T>(
noise1(f1),
noise1(f2));
}
// noise3
template <typename genType>
inline detail::tvec3<genType> noise3
(
genType const & x
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'noise3' only accept floating-point values");
genType f1 = x * genType(1103515245) + genType(12345);
genType f2 = f1 * genType(1103515245) + genType(12345);
genType f3 = f2 * genType(1103515245) + genType(12345);
return detail::tvec3<genType>(
noise1(f1),
noise1(f2),
noise1(f3));
}
template <typename T> template <typename T>
inline detail::tvec3<T> noise3 T simplexNoise2(detail::tvec2<T> const & v)
( {
detail::tvec2<T> const & x static const detail::tvec4<T> pParam(17. * 17., 34., 1., 7.);
)
{ detail::tvec2<T> const C = detail::tvec2<T>(
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'noise3' only accept floating-point values"); 0.211324865405187134, // (3.0-sqrt(3.0))/6.;
0.366025403784438597); // 0.5*(sqrt(3.0)-1.);
T f0(0); detail::tvec3<T> const D = detail::tvec3<T>(0., 0.5, 2.0) * T(3.14159265358979312);
for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
f0 += x[i]; // First corner
T f1 = f0 * T(1103515245) + T(12345); detail::tvec2<T> i = floor(v + dot(v, detail::tvec2<T>(C.y)));
T f2 = f1 * T(1103515245) + T(12345); detail::tvec2<T> x0 = v - i + dot(i, detail::tvec2<T>(C.x));
T f3 = f2 * T(1103515245) + T(12345);
return detail::tvec3<T>( // Other corners
noise1(f1), detail::tvec2<T> i1 = (x0.x > x0.y) ? detail::tvec2<T>(1, 0) : detail::tvec2<T>(0, 1) ;
noise1(f2),
noise1(f3)); // x0 = x0 - 0. + 0. * C
} detail::tvec2<T> x1 = x0 - i1 + T(1) * detail::tvec2<T>(C.x);
detail::tvec2<T> x2 = x0 - T(1) + T(2) * detail::tvec2<T>(C.x);
template <typename T>
inline detail::tvec3<T> noise3 // Permutations
( i = mod(i, pParam.x);
detail::tvec3<T> const & x detail::tvec3<T> p = permute(
) permute(i.y + detail::tvec3<T>(T(0), i1.y, T(1)), detail::tvec3<T>(pParam))
{ + i.x + detail::tvec3<T>(T(0), i1.x, T(1)), detail::tvec3<T>(pParam));
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'noise3' only accept floating-point values");
#ifndef USE_CIRCLE
T f0(0); // ( N points uniformly over a line, mapped onto a diamond.)
for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i) detail::tvec3<T> x = fract(p / pParam.w) ;
f0 += x[i]; detail::tvec3<T> h = T(0.5) - abs(x) ;
T f1 = f0 * T(1103515245) + T(12345);
T f2 = f1 * T(1103515245) + T(12345); detail::tvec3<T> sx = detail::tvec3<T>(lessThan(x, detail::tvec3<T>(D.x))) * T(2) - T(1);
T f3 = f2 * T(1103515245) + T(12345); detail::tvec3<T> sh = detail::tvec3<T>(lessThan(h, detail::tvec3<T>(D.x)));
return detail::tvec3<T>(
noise1(f1), detail::tvec3<T> a0 = x + sx * sh;
noise1(f2), detail::tvec2<T> p0(a0.x, h.x);
noise1(f3)); detail::tvec2<T> p1(a0.y, h.y);
} detail::tvec2<T> p2(a0.z, h.z);
template <typename T> # ifdef NORMALISE_GRADIENTS
inline detail::tvec3<T> noise3 p0 *= taylorInvSqrt(dot(p0, p0));
( p1 *= taylorInvSqrt(dot(p1, p1));
detail::tvec4<T> const & x p2 *= taylorInvSqrt(dot(p2, p2));
) # endif
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'noise3' only accept floating-point values"); detail::tvec3<T> g = T(2) * detail::tvec3<T>(dot(p0, x0), dot(p1, x1), dot(p2, x2));
#else
T f0(0); // N points around a unit circle.
for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i) detail::tvec3<T> phi = D.z * mod(p, pParam.w) / pParam.w;
f0 += x[i]; detail::tvec4<T> a0 = sin(phi.xxyy + D.xyxy);
T f1 = f0 * T(1103515245) + T(12345); detail::tvec2<T> a1 = sin(detail::tvec2<T>(phi.z) + D.xy);
T f2 = f1 * T(1103515245) + T(12345); detail::tvec3<T> g = detail::tvec3<T>(
T f3 = f2 * T(1103515245) + T(12345); dot(a0.xy, x0),
return detail::tvec3<T>( dot(detail::tvec2<T>(a0.z, a0.w), x1),
noise1(f1), dot(detail::tvec2<T>(a1.x, a1.y), x2));
noise1(f2), #endif
noise1(f3)); // mix
} detail::tvec3<T> m = max(T(0.5) - detail::tvec3<T>(dot(x0,x0), dot(x1, x1), dot(x2, x2)), T(0));
m = m * m ;
// noise4 return T(1.66666) * T(70) * dot(m * m, g);
template <typename genType>
inline detail::tvec4<genType> noise4
(
genType const & x
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'noise4' only accept floating-point values");
genType f1 = x * genType(1103515245) + genType(12345);
genType f2 = f1 * genType(1103515245) + genType(12345);
genType f3 = f2 * genType(1103515245) + genType(12345);
genType f4 = f3 * genType(1103515245) + genType(12345);
return detail::tvec4<genType>(
noise1(f1),
noise1(f2),
noise1(f3),
noise1(f4));
}
template <typename T>
inline detail::tvec4<T> noise4
(
detail::tvec2<T> const & x
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'noise4' only accept floating-point values");
T f0(0);
for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
f0 += x[i];
T f1 = f0 * T(1103515245) + T(12345);
T f2 = f1 * T(1103515245) + T(12345);
T f3 = f2 * T(1103515245) + T(12345);
T f4 = f3 * T(1103515245) + T(12345);
return detail::tvec4<T>(
noise1(f1),
noise1(f2),
noise1(f3),
noise1(f4));
}
template <typename T>
inline detail::tvec4<T> noise4
(
detail::tvec3<T> const & x
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'noise4' only accept floating-point values");
T f0(0);
for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size()(); ++i)
f0 += x[i];
T f1 = f0 * T(1103515245) + T(12345);
T f2 = f1 * T(1103515245) + T(12345);
T f3 = f2 * T(1103515245) + T(12345);
T f4 = f3 * T(1103515245) + T(12345);
return detail::tvec4<T>(
noise1(f1),
noise1(f2),
noise1(f3),
noise1(f4));
}
template <typename T>
inline detail::tvec4<T> noise4
(
detail::tvec4<T> const & x
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'noise4' only accept floating-point values");
T f0(0);
for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size()(); ++i)
f0 += x[i];
T f1 = f0 * T(1103515245) + T(12345);
T f2 = f1 * T(1103515245) + T(12345);
T f3 = f2 * T(1103515245) + T(12345);
T f4 = f3 * T(1103515245) + T(12345);
return detail::tvec4<T>(
noise1(f1),
noise1(f2),
noise1(f3),
noise1(f4));
} }
}//namespace noise }//namespace noise

Write Preview
Loading…
Cancel
Save