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

Added more vectorize functions

Browse Source
master
Christophe Riccio ago%!(EXTRA string=14 years)
parent e6fded40dc
commit 6eba3a9db9
7 changed files with 175 additions and 721 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. 51
      glm/core/_vectorize.hpp
  2. 2
      glm/core/func_exponential.inl
  3. 2
      glm/core/func_geometric.inl
  4. 1
      glm/core/func_integer.inl
  5. 2
      glm/core/func_matrix.inl
  6. 548
      glm/core/func_trigonometric.inl
  7. 290
      glm/gtc/random.inl

51
glm/core/_vectorize.hpp
Unescape View File

@ -26,7 +26,7 @@
/// @author Christophe Riccio /// @author Christophe Riccio
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
#define VECTORIZE_VEC(func) \ #define VECTORIZE2_VEC(func) \
template <typename T> \ template <typename T> \
GLM_FUNC_QUALIFIER detail::tvec2<T> func( \ GLM_FUNC_QUALIFIER detail::tvec2<T> func( \
detail::tvec2<T> const & v) \ detail::tvec2<T> const & v) \
@ -34,8 +34,9 @@
return detail::tvec2<T>( \ return detail::tvec2<T>( \
func(v.x), \ func(v.x), \
func(v.y)); \ func(v.y)); \
} \ }
\
#define VECTORIZE3_VEC(func) \
template <typename T> \ template <typename T> \
GLM_FUNC_QUALIFIER detail::tvec3<T> func( \ GLM_FUNC_QUALIFIER detail::tvec3<T> func( \
detail::tvec3<T> const & v) \ detail::tvec3<T> const & v) \
@ -44,8 +45,9 @@
func(v.x), \ func(v.x), \
func(v.y), \ func(v.y), \
func(v.z)); \ func(v.z)); \
} \ }
\
#define VECTORIZE4_VEC(func) \
template <typename T> \ template <typename T> \
GLM_FUNC_QUALIFIER detail::tvec4<T> func( \ GLM_FUNC_QUALIFIER detail::tvec4<T> func( \
detail::tvec4<T> const & v) \ detail::tvec4<T> const & v) \
@ -57,7 +59,12 @@
func(v.w)); \ func(v.w)); \
} }
#define VECTORIZE_VEC_SCA(func) \ #define VECTORIZE_VEC(func) \
VECTORIZE2_VEC(func) \
VECTORIZE3_VEC(func) \
VECTORIZE4_VEC(func)
#define VECTORIZE2_VEC_SCA(func) \
template <typename T> \ template <typename T> \
GLM_FUNC_QUALIFIER detail::tvec2<T> func \ GLM_FUNC_QUALIFIER detail::tvec2<T> func \
( \ ( \
@ -68,8 +75,9 @@
return detail::tvec2<T>( \ return detail::tvec2<T>( \
func(x.x, y), \ func(x.x, y), \
func(x.y, y)); \ func(x.y, y)); \
} \ }
\
#define VECTORIZE3_VEC_SCA(func) \
template <typename T> \ template <typename T> \
GLM_FUNC_QUALIFIER detail::tvec3<T> func \ GLM_FUNC_QUALIFIER detail::tvec3<T> func \
( \ ( \
@ -81,8 +89,9 @@
func(x.x, y), \ func(x.x, y), \
func(x.y, y), \ func(x.y, y), \
func(x.z, y)); \ func(x.z, y)); \
} \ }
\
#define VECTORIZE4_VEC_SCA(func) \
template <typename T> \ template <typename T> \
GLM_FUNC_QUALIFIER detail::tvec4<T> func \ GLM_FUNC_QUALIFIER detail::tvec4<T> func \
( \ ( \
@ -97,7 +106,12 @@
func(x.w, y)); \ func(x.w, y)); \
} }
#define VECTORIZE_VEC_VEC(func) \ #define VECTORIZE_VEC_SCA(func) \
VECTORIZE2_VEC_SCA(func) \
VECTORIZE3_VEC_SCA(func) \
VECTORIZE4_VEC_SCA(func)
#define VECTORIZE2_VEC_VEC(func) \
template <typename T> \ template <typename T> \
GLM_FUNC_QUALIFIER detail::tvec2<T> func \ GLM_FUNC_QUALIFIER detail::tvec2<T> func \
( \ ( \
@ -108,8 +122,9 @@
return detail::tvec2<T>( \ return detail::tvec2<T>( \
func(x.x, y.x), \ func(x.x, y.x), \
func(x.y, y.y)); \ func(x.y, y.y)); \
} \ }
\
#define VECTORIZE3_VEC_VEC(func) \
template <typename T> \ template <typename T> \
GLM_FUNC_QUALIFIER detail::tvec3<T> func \ GLM_FUNC_QUALIFIER detail::tvec3<T> func \
( \ ( \
@ -121,8 +136,9 @@
func(x.x, y.x), \ func(x.x, y.x), \
func(x.y, y.y), \ func(x.y, y.y), \
func(x.z, y.z)); \ func(x.z, y.z)); \
} \ }
\
#define VECTORIZE4_VEC_VEC(func) \
template <typename T> \ template <typename T> \
GLM_FUNC_QUALIFIER detail::tvec4<T> func \ GLM_FUNC_QUALIFIER detail::tvec4<T> func \
( \ ( \
@ -136,3 +152,8 @@
func(x.z, y.z), \ func(x.z, y.z), \
func(x.w, y.w)); \ func(x.w, y.w)); \
} }
#define VECTORIZE_VEC_VEC(func) \
VECTORIZE2_VEC_VEC(func) \
VECTORIZE3_VEC_VEC(func) \
VECTORIZE4_VEC_VEC(func)

2
glm/core/func_exponential.inl
Unescape View File

@ -26,6 +26,8 @@
/// @author Christophe Riccio /// @author Christophe Riccio
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
#include "_vectorize.hpp"
namespace glm namespace glm
{ {
// pow // pow

2
glm/core/func_geometric.inl
Unescape View File

@ -26,6 +26,8 @@
/// @author Christophe Riccio /// @author Christophe Riccio
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
#include "_vectorize.hpp"
namespace glm namespace glm
{ {
// length // length

1
glm/core/func_integer.inl
Unescape View File

@ -26,6 +26,7 @@
/// @author Christophe Riccio /// @author Christophe Riccio
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
#include "_vectorize.hpp"
#if(GLM_COMPILER & GLM_COMPILER_VC) #if(GLM_COMPILER & GLM_COMPILER_VC)
#include <intrin.h> #include <intrin.h>
#pragma intrinsic(_BitScanReverse) #pragma intrinsic(_BitScanReverse)

2
glm/core/func_matrix.inl
Unescape View File

@ -26,6 +26,8 @@
/// @author Christophe Riccio /// @author Christophe Riccio
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
#include "_vectorize.hpp"
namespace glm namespace glm
{ {
// matrixCompMult // matrixCompMult

548
glm/core/func_trigonometric.inl
Unescape View File

@ -26,6 +26,8 @@
/// @author Christophe Riccio /// @author Christophe Riccio
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
#include "_vectorize.hpp"
namespace glm namespace glm
{ {
// radians // radians
@ -37,46 +39,12 @@ namespace glm
{ {
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'radians' only accept floating-point input"); GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'radians' only accept floating-point input");
const genType pi = genType(3.1415926535897932384626433832795); genType const pi = genType(3.1415926535897932384626433832795);
return degrees * (pi / genType(180)); return degrees * (pi / genType(180));
} }
template <typename T> VECTORIZE_VEC(radians)
GLM_FUNC_QUALIFIER detail::tvec2<T> radians
(
detail::tvec2<T> const & degrees
)
{
return detail::tvec2<T>(
radians(degrees.x),
radians(degrees.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> radians
(
detail::tvec3<T> const & degrees
)
{
return detail::tvec3<T>(
radians(degrees.x),
radians(degrees.y),
radians(degrees.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> radians
(
detail::tvec4<T> const & degrees
)
{
return detail::tvec4<T>(
radians(degrees.x),
radians(degrees.y),
radians(degrees.z),
radians(degrees.w));
}
// degrees // degrees
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER genType degrees GLM_FUNC_QUALIFIER genType degrees
@ -90,41 +58,7 @@ namespace glm
return radians * (genType(180) / pi); return radians * (genType(180) / pi);
} }
template <typename T> VECTORIZE_VEC(degrees)
GLM_FUNC_QUALIFIER detail::tvec2<T> degrees
(
detail::tvec2<T> const & radians
)
{
return detail::tvec2<T>(
degrees(radians.x),
degrees(radians.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> degrees
(
detail::tvec3<T> const & radians
)
{
return detail::tvec3<T>(
degrees(radians.x),
degrees(radians.y),
degrees(radians.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> degrees
(
detail::tvec4<T> const & radians
)
{
return detail::tvec4<T>(
degrees(radians.x),
degrees(radians.y),
degrees(radians.z),
degrees(radians.w));
}
// sin // sin
template <typename genType> template <typename genType>
@ -138,41 +72,7 @@ namespace glm
return ::std::sin(angle); return ::std::sin(angle);
} }
template <typename T> VECTORIZE_VEC(sin)
GLM_FUNC_QUALIFIER detail::tvec2<T> sin
(
detail::tvec2<T> const & angle
)
{
return detail::tvec2<T>(
sin(angle.x),
sin(angle.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> sin
(
detail::tvec3<T> const & angle
)
{
return detail::tvec3<T>(
sin(angle.x),
sin(angle.y),
sin(angle.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> sin
(
detail::tvec4<T> const & angle
)
{
return detail::tvec4<T>(
sin(angle.x),
sin(angle.y),
sin(angle.z),
sin(angle.w));
}
// cos // cos
template <typename genType> template <typename genType>
@ -183,41 +83,7 @@ namespace glm
return ::std::cos(angle); return ::std::cos(angle);
} }
template <typename T> VECTORIZE_VEC(cos)
GLM_FUNC_QUALIFIER detail::tvec2<T> cos
(
detail::tvec2<T> const & angle
)
{
return detail::tvec2<T>(
cos(angle.x),
cos(angle.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> cos
(
detail::tvec3<T> const & angle
)
{
return detail::tvec3<T>(
cos(angle.x),
cos(angle.y),
cos(angle.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> cos
(
detail::tvec4<T> const & angle
)
{
return detail::tvec4<T>(
cos(angle.x),
cos(angle.y),
cos(angle.z),
cos(angle.w));
}
// tan // tan
template <typename genType> template <typename genType>
@ -231,41 +97,7 @@ namespace glm
return ::std::tan(angle); return ::std::tan(angle);
} }
template <typename T> VECTORIZE_VEC(tan)
GLM_FUNC_QUALIFIER detail::tvec2<T> tan
(
detail::tvec2<T> const & angle
)
{
return detail::tvec2<T>(
tan(angle.x),
tan(angle.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> tan
(
detail::tvec3<T> const & angle
)
{
return detail::tvec3<T>(
tan(angle.x),
tan(angle.y),
tan(angle.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> tan
(
detail::tvec4<T> const & angle
)
{
return detail::tvec4<T>(
tan(angle.x),
tan(angle.y),
tan(angle.z),
tan(angle.w));
}
// asin // asin
template <typename genType> template <typename genType>
@ -279,41 +111,7 @@ namespace glm
return ::std::asin(x); return ::std::asin(x);
} }
template <typename T> VECTORIZE_VEC(asin)
GLM_FUNC_QUALIFIER detail::tvec2<T> asin
(
detail::tvec2<T> const & x
)
{
return detail::tvec2<T>(
asin(x.x),
asin(x.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> asin
(
detail::tvec3<T> const & x
)
{
return detail::tvec3<T>(
asin(x.x),
asin(x.y),
asin(x.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> asin
(
detail::tvec4<T> const & x
)
{
return detail::tvec4<T>(
asin(x.x),
asin(x.y),
asin(x.z),
asin(x.w));
}
// acos // acos
template <typename genType> template <typename genType>
@ -327,41 +125,7 @@ namespace glm
return ::std::acos(x); return ::std::acos(x);
} }
template <typename T> VECTORIZE_VEC(acos)
GLM_FUNC_QUALIFIER detail::tvec2<T> acos
(
detail::tvec2<T> const & x
)
{
return detail::tvec2<T>(
acos(x.x),
acos(x.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> acos
(
detail::tvec3<T> const & x
)
{
return detail::tvec3<T>(
acos(x.x),
acos(x.y),
acos(x.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> acos
(
detail::tvec4<T> const & x
)
{
return detail::tvec4<T>(
acos(x.x),
acos(x.y),
acos(x.z),
acos(x.w));
}
// atan // atan
template <typename genType> template <typename genType>
@ -376,44 +140,7 @@ namespace glm
return ::std::atan2(y, x); return ::std::atan2(y, x);
} }
template <typename T> VECTORIZE_VEC_VEC(atan)
GLM_FUNC_QUALIFIER detail::tvec2<T> atan
(
detail::tvec2<T> const & y,
detail::tvec2<T> const & x
)
{
return detail::tvec2<T>(
atan(y.x, x.x),
atan(y.y, x.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> atan
(
detail::tvec3<T> const & y,
detail::tvec3<T> const & x
)
{
return detail::tvec3<T>(
atan(y.x, x.x),
atan(y.y, x.y),
atan(y.z, x.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> atan
(
detail::tvec4<T> const & y,
detail::tvec4<T> const & x
)
{
return detail::tvec4<T>(
atan(y.x, x.x),
atan(y.y, x.y),
atan(y.z, x.z),
atan(y.w, x.w));
}
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER genType atan GLM_FUNC_QUALIFIER genType atan
@ -426,41 +153,7 @@ namespace glm
return ::std::atan(x); return ::std::atan(x);
} }
template <typename T> VECTORIZE_VEC(atan)
GLM_FUNC_QUALIFIER detail::tvec2<T> atan
(
detail::tvec2<T> const & x
)
{
return detail::tvec2<T>(
atan(x.x),
atan(x.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> atan
(
detail::tvec3<T> const & x
)
{
return detail::tvec3<T>(
atan(x.x),
atan(x.y),
atan(x.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> atan
(
detail::tvec4<T> const & x
)
{
return detail::tvec4<T>(
atan(x.x),
atan(x.y),
atan(x.z),
atan(x.w));
}
// sinh // sinh
template <typename genType> template <typename genType>
@ -474,41 +167,7 @@ namespace glm
return std::sinh(angle); return std::sinh(angle);
} }
template <typename T> VECTORIZE_VEC(sinh)
GLM_FUNC_QUALIFIER detail::tvec2<T> sinh
(
detail::tvec2<T> const & angle
)
{
return detail::tvec2<T>(
sinh(angle.x),
sinh(angle.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> sinh
(
detail::tvec3<T> const & angle
)
{
return detail::tvec3<T>(
sinh(angle.x),
sinh(angle.y),
sinh(angle.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> sinh
(
detail::tvec4<T> const & angle
)
{
return detail::tvec4<T>(
sinh(angle.x),
sinh(angle.y),
sinh(angle.z),
sinh(angle.w));
}
// cosh // cosh
template <typename genType> template <typename genType>
@ -522,41 +181,7 @@ namespace glm
return std::cosh(angle); return std::cosh(angle);
} }
template <typename T> VECTORIZE_VEC(cosh)
GLM_FUNC_QUALIFIER detail::tvec2<T> cosh
(
detail::tvec2<T> const & angle
)
{
return detail::tvec2<T>(
cosh(angle.x),
cosh(angle.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> cosh
(
detail::tvec3<T> const & angle
)
{
return detail::tvec3<T>(
cosh(angle.x),
cosh(angle.y),
cosh(angle.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> cosh
(
detail::tvec4<T> const & angle
)
{
return detail::tvec4<T>(
cosh(angle.x),
cosh(angle.y),
cosh(angle.z),
cosh(angle.w));
}
// tanh // tanh
template <typename genType> template <typename genType>
@ -570,41 +195,7 @@ namespace glm
return std::tanh(angle); return std::tanh(angle);
} }
template <typename T> VECTORIZE_VEC(tanh)
GLM_FUNC_QUALIFIER detail::tvec2<T> tanh
(
detail::tvec2<T> const & angle
)
{
return detail::tvec2<T>(
tanh(angle.x),
tanh(angle.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> tanh
(
detail::tvec3<T> const & angle
)
{
return detail::tvec3<T>(
tanh(angle.x),
tanh(angle.y),
tanh(angle.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> tanh
(
detail::tvec4<T> const & angle
)
{
return detail::tvec4<T>(
tanh(angle.x),
tanh(angle.y),
tanh(angle.z),
tanh(angle.w));
}
// asinh // asinh
template <typename genType> template <typename genType>
@ -618,41 +209,7 @@ namespace glm
return (x < genType(0) ? genType(-1) : (x > genType(0) ? genType(1) : genType(0))) * log(abs(x) + sqrt(genType(1) + x * x)); return (x < genType(0) ? genType(-1) : (x > genType(0) ? genType(1) : genType(0))) * log(abs(x) + sqrt(genType(1) + x * x));
} }
template <typename T> VECTORIZE_VEC(asinh)
GLM_FUNC_QUALIFIER detail::tvec2<T> asinh
(
detail::tvec2<T> const & x
)
{
return detail::tvec2<T>(
asinh(x.x),
asinh(x.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> asinh
(
detail::tvec3<T> const & x
)
{
return detail::tvec3<T>(
asinh(x.x),
asinh(x.y),
asinh(x.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> asinh
(
detail::tvec4<T> const & x
)
{
return detail::tvec4<T>(
asinh(x.x),
asinh(x.y),
asinh(x.z),
asinh(x.w));
}
// acosh // acosh
template <typename genType> template <typename genType>
@ -668,41 +225,7 @@ namespace glm
return log(x + sqrt(x * x - genType(1))); return log(x + sqrt(x * x - genType(1)));
} }
template <typename T> VECTORIZE_VEC(acosh)
GLM_FUNC_QUALIFIER detail::tvec2<T> acosh
(
detail::tvec2<T> const & x
)
{
return detail::tvec2<T>(
acosh(x.x),
acosh(x.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> acosh
(
detail::tvec3<T> const & x
)
{
return detail::tvec3<T>(
acosh(x.x),
acosh(x.y),
acosh(x.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> acosh
(
detail::tvec4<T> const & x
)
{
return detail::tvec4<T>(
acosh(x.x),
acosh(x.y),
acosh(x.z),
acosh(x.w));
}
// atanh // atanh
template <typename genType> template <typename genType>
@ -718,39 +241,6 @@ namespace glm
return genType(0.5) * log((genType(1) + x) / (genType(1) - x)); return genType(0.5) * log((genType(1) + x) / (genType(1) - x));
} }
template <typename T> VECTORIZE_VEC(atanh)
GLM_FUNC_QUALIFIER detail::tvec2<T> atanh
(
detail::tvec2<T> const & x
)
{
return detail::tvec2<T>(
atanh(x.x),
atanh(x.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> atanh
(
detail::tvec3<T> const & x
)
{
return detail::tvec3<T>(
atanh(x.x),
atanh(x.y),
atanh(x.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> atanh
(
detail::tvec4<T> const & x
)
{
return detail::tvec4<T>(
atanh(x.x),
atanh(x.y),
atanh(x.z),
atanh(x.w));
}
}//namespace glm }//namespace glm

290
glm/gtc/random.inl
Unescape View File

@ -9,200 +9,136 @@
#include <ctime> #include <ctime>
#include <cassert> #include <cassert>
#include "../core/_vectorize.hpp"
namespace glm{ namespace glm{
namespace detail
template <>
GLM_FUNC_QUALIFIER glm::half linearRand
(
glm::half const & Min,
glm::half const & Max
)
{
return glm::half(float(std::rand()) / float(RAND_MAX) * (float(Max) - float(Min)) + float(Min));
}
template <>
GLM_FUNC_QUALIFIER float linearRand
(
float const & Min,
float const & Max
)
{
return float(std::rand()) / float(RAND_MAX) * (Max - Min) + Min;
}
template <>
GLM_FUNC_QUALIFIER double linearRand
(
double const & Min,
double const & Max
)
{
return double(std::rand()) / double(RAND_MAX) * (Max - Min) + Min;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> linearRand
(
detail::tvec2<T> const & Min,
detail::tvec2<T> const & Max
)
{
return detail::tvec2<T>(
linearRand(Min.x, Max.x),
linearRand(Min.y, Max.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> linearRand
(
detail::tvec3<T> const & Min,
detail::tvec3<T> const & Max
)
{ {
return detail::tvec3<T>( struct compute_linearRand
linearRand(Min.x, Max.x), {
linearRand(Min.y, Max.y), template <typename T>
linearRand(Min.z, Max.z)); GLM_FUNC_QUALIFIER T operator() (T const & Min, T const & Max) const
} {
GLM_STATIC_ASSERT(0, "'linearRand' invalid template parameter type. GLM_GTC_random only supports floating-point template types.");
return Min;
}
};
template <typename T> template <>
GLM_FUNC_QUALIFIER detail::tvec4<T> linearRand GLM_FUNC_QUALIFIER half compute_linearRand::operator()<half> (half const & Min, half const & Max) const
( {
detail::tvec4<T> const & Min, return half(float(std::rand()) / float(RAND_MAX) * (float(Max) - float(Min)) + float(Min));
detail::tvec4<T> const & Max }
)
{
return detail::tvec4<T>(
linearRand(Min.x, Max.x),
linearRand(Min.y, Max.y),
linearRand(Min.z, Max.z),
linearRand(Min.w, Max.w));
}
template <typename genType> template <>
GLM_FUNC_QUALIFIER genType gaussRand GLM_FUNC_QUALIFIER float compute_linearRand::operator()<float> (float const & Min, float const & Max) const
( {
genType const & Mean, return float(std::rand()) / float(RAND_MAX) * (Max - Min) + Min;
genType const & Deviation }
)
{ template <>
genType w, x1, x2; GLM_FUNC_QUALIFIER double compute_linearRand::operator()<double> (double const & Min, double const & Max) const
{
return double(std::rand()) / double(RAND_MAX) * (Max - Min) + Min;
}
}//namespace detail
template <typename genType>
GLM_FUNC_QUALIFIER genType linearRand
(
genType const & Min,
genType const & Max
)
{
return detail::compute_linearRand()(Min, Max);
}
VECTORIZE_VEC_VEC(linearRand)
template <typename genType>
GLM_FUNC_QUALIFIER genType gaussRand
(
genType const & Mean,
genType const & Deviation
)
{
genType w, x1, x2;
do do
{ {
x1 = linearRand(genType(-1), genType(1)); x1 = linearRand(genType(-1), genType(1));
x2 = linearRand(genType(-1), genType(1)); x2 = linearRand(genType(-1), genType(1));
w = x1 * x1 + x2 * x2; w = x1 * x1 + x2 * x2;
} while(w > genType(1)); } while(w > genType(1));
return x2 * Deviation * Deviation * sqrt((genType(-2) * log(w)) / w) + Mean; return x2 * Deviation * Deviation * sqrt((genType(-2) * log(w)) / w) + Mean;
} }
template <typename T> VECTORIZE_VEC_VEC(gaussRand)
GLM_FUNC_QUALIFIER detail::tvec2<T> gaussRand
( template <typename T>
detail::tvec2<T> const & Mean, GLM_FUNC_QUALIFIER detail::tvec2<T> diskRand
detail::tvec2<T> const & Deviation (
) T const & Radius
{ )
return detail::tvec2<T>( {
gaussRand(Mean.x, Deviation.x), detail::tvec2<T> Result(T(0));
gaussRand(Mean.y, Deviation.y)); T LenRadius(T(0));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> gaussRand
(
detail::tvec3<T> const & Mean,
detail::tvec3<T> const & Deviation
)
{
return detail::tvec3<T>(
gaussRand(Mean.x, Deviation.x),
gaussRand(Mean.y, Deviation.y),
gaussRand(Mean.z, Deviation.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> gaussRand
(
detail::tvec4<T> const & Mean,
detail::tvec4<T> const & Deviation
)
{
return detail::tvec4<T>(
gaussRand(Mean.x, Deviation.x),
gaussRand(Mean.y, Deviation.y),
gaussRand(Mean.z, Deviation.z),
gaussRand(Mean.w, Deviation.w));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> diskRand
(
T const & Radius
)
{
detail::tvec2<T> Result(T(0));
T LenRadius(T(0));
do do
{ {
Result = linearRand(detail::tvec2<T>(-Radius), detail::tvec2<T>(Radius)); Result = linearRand(detail::tvec2<T>(-Radius), detail::tvec2<T>(Radius));
LenRadius = length(Result); LenRadius = length(Result);
} }
while(LenRadius > Radius); while(LenRadius > Radius);
return Result; return Result;
} }
template <typename T> template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> ballRand GLM_FUNC_QUALIFIER detail::tvec3<T> ballRand
( (
T const & Radius T const & Radius
) )
{ {
detail::tvec3<T> Result(T(0)); detail::tvec3<T> Result(T(0));
T LenRadius(T(0)); T LenRadius(T(0));
do do
{ {
Result = linearRand(detail::tvec3<T>(-Radius), detail::tvec3<T>(Radius)); Result = linearRand(detail::tvec3<T>(-Radius), detail::tvec3<T>(Radius));
LenRadius = length(Result); LenRadius = length(Result);
} }
while(LenRadius > Radius); while(LenRadius > Radius);
return Result; return Result;
} }
template <typename T> template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> circularRand GLM_FUNC_QUALIFIER detail::tvec2<T> circularRand
( (
T const & Radius T const & Radius
) )
{ {
T a = linearRand(T(0), T(6.283185307179586476925286766559f)); T a = linearRand(T(0), T(6.283185307179586476925286766559f));
return detail::tvec2<T>(cos(a), sin(a)) * Radius; return detail::tvec2<T>(cos(a), sin(a)) * Radius;
} }
template <typename T> template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> sphericalRand GLM_FUNC_QUALIFIER detail::tvec3<T> sphericalRand
( (
T const & Radius T const & Radius
) )
{ {
T z = linearRand(T(-1), T(1)); T z = linearRand(T(-1), T(1));
T a = linearRand(T(0), T(6.283185307179586476925286766559f)); T a = linearRand(T(0), T(6.283185307179586476925286766559f));
T r = sqrt(T(1) - z * z); T r = sqrt(T(1) - z * z);
T x = r * cos(a); T x = r * cos(a);
T y = r * sin(a); T y = r * sin(a);
return detail::tvec3<T>(x, y, z) * Radius; return detail::tvec3<T>(x, y, z) * Radius;
} }
}//namespace glm }//namespace glm

Write Preview
Loading…
Cancel
Save