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

Fixed duplicated implementation of random functions

Browse Source
master
Christophe Riccio ago%!(EXTRA string=14 years)
parent 4f2051728c
commit 3160fbf58c
5 changed files with 30 additions and 566 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. 4
      glm/core/func_vector_relational.hpp
  2. 43
      glm/gtc/random.hpp
  3. 516
      glm/gtc/random.inl
  4. 27
      glm/gtx/random.inl
  5. 6
      test/gtc/gtc_random.cpp

4
glm/core/func_vector_relational.hpp
Unescape View File

@ -80,8 +80,8 @@ namespace glm
//! //!
/// @see - <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/equal.xml">GLSL equal man page</a> /// @see - <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/equal.xml">GLSL equal man page</a>
/// @see - <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7</a> /// @see - <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7</a>
template <typename T, template <typename> class vecType> //template <typename T, template <typename> class vecType>
GLM_FUNC_QUALIFIER typename vecType<T>::bool_type equal(vecType<T> const & x, vecType<T> const & y); //GLM_FUNC_QUALIFIER typename vecType<T>::bool_type equal(vecType<T> const & x, vecType<T> const & y);
//! Returns the component-wise comparison of result x != y. //! Returns the component-wise comparison of result x != y.
//! //!

43
glm/gtc/random.hpp
Unescape View File

@ -56,49 +56,6 @@ namespace glm
/// Generate a random number in the interval [-1, 1], according a linear distribution. /// Generate a random number in the interval [-1, 1], according a linear distribution.
/// From GLM_GTC_random extension. /// From GLM_GTC_random extension.
template <typename T> T signedRand1(); template <typename T> T signedRand1();
template <> float signedRand1(); //!< \brief Generate a random number in the interval [-1, 1], according a linear distribution (From GLM_GTX_random extension)
template <> double signedRand1(); //!< \brief Generate a random number in the interval [-1, 1], according a linear distribution (From GLM_GTX_random extension)
template <typename T> detail::tvec2<T> signedRand2(); //!< \brief Generate 2 random numbers in the interval [-1, 1], according a linear distribution (From GLM_GTX_random extension)
template <typename T> detail::tvec3<T> signedRand3(); //!< \brief Generate 3 random numbers in the interval [-1, 1], according a linear distribution (From GLM_GTX_random extension)
template <typename T> detail::tvec4<T> signedRand4(); //!< \brief Generate 4 random numbers in the interval [-1, 1], according a linear distribution (From GLM_GTX_random extension)
template <typename T> detail::tvec2<T> normalizedRand2(); //!< \brief Generate a normalized 2D vector regulary distribute on a circle (From GLM_GTX_random extension)
template <typename T> detail::tvec2<T> normalizedRand2(T Min, T Max); //!< \brief Generate a scaled and normalized 2D vector regulary distribute on a circle (From GLM_GTX_random extension)
template <typename T> detail::tvec3<T> normalizedRand3(); //!< \brief Generate a normalized 3D vector regulary distribute on a sphere (From GLM_GTX_random extension)
template <typename T> detail::tvec3<T> normalizedRand3(T Min, T Max); //!< \brief Generate a scaled and normalized 3D vector regulary distribute on a sphere (From GLM_GTX_random extension)
template <typename T> T compRand1(); //!< \brief Generate a random number in the interval [0, 1], according a linear distribution (From GLM_GTX_random extension)
template <> float compRand1(); //!< \brief Generate a random number in the interval [0, 1], according a linear distribution (From GLM_GTX_random extension)
template <> double compRand1(); //!< \brief Generate a random number in the interval [0, 1], according a linear distribution (From GLM_GTX_random extension)
template <typename T> T compRand1(T Min, T Max); //!< \brief Generate a random number in the interval [Min, Max], according a linear distribution (From GLM_GTX_random extension)
template <typename T> detail::tvec2<T> compRand2(T Min, T Max); //!< \brief Generate 2 random numbers in the interval [Min, Max], according a linear distribution (From GLM_GTX_random extension)
template <typename T> detail::tvec3<T> compRand3(T Min, T Max); //!< \brief Generate 3 random numbers in the interval [Min, Max], according a linear distribution (From GLM_GTX_random extension)
template <typename T> detail::tvec4<T> compRand4(T Min, T Max); //!< \brief Generate 4 random numbers in the interval [Min, Max], according a linear distribution (From GLM_GTX_random extension)
template <typename T> detail::tvec2<T> compRand2(const detail::tvec2<T>& Min, const detail::tvec2<T>& Max); //!< \brief Generate 2 random numbers in the interval [Min, Max], according a linear distribution (From GLM_GTX_random extension)
template <typename T> detail::tvec3<T> compRand3(const detail::tvec3<T>& Min, const detail::tvec3<T>& Max); //!< \brief Generate 3 random numbers in the interval [Min, Max], according a linear distribution (From GLM_GTX_random extension)
template <typename T> detail::tvec3<T> compRand4(const detail::tvec4<T>& Min, const detail::tvec4<T>& Max); //!< \brief Generate 4 random numbers in the interval [Min, Max], according a linear distribution (From GLM_GTX_random extension)
template <typename T> detail::tvec2<T> vecRand2(); //!< \brief Generate a random normalized 2 component vector. It's a spherical uniform distribution. (From GLM_GTX_random extension)
template <typename T> detail::tvec2<T> vecRand2(T MinRadius, T MaxRadius); //!< \brief Generate a random normalized 2 component vector. It's a spherical uniform distribution. (From GLM_GTX_random extension)
template <typename T> detail::tvec3<T> vecRand3(); //!< \brief Generate a random normalized 3 component vector. It's a spherical uniform distribution. (From GLM_GTX_random extension)
template <typename T> detail::tvec3<T> vecRand3(T MinRadius, T MaxRadius); //!< \brief Generate a random normalized 3 component vector. It's a spherical uniform distribution. (From GLM_GTX_random extension)
template <typename T> detail::tvec4<T> vecRand4(); //!< \brief Generate a random normalized 4 component vector. It's a spherical uniform distribution. (From GLM_GTX_random extension)
template <typename T> detail::tvec4<T> vecRand4(T MinRadius, T MaxRadius); //!< \brief Generate a random normalized 4 component vector. It's a spherical uniform distribution. (From GLM_GTX_random extension)
template <typename T> T gaussRand1(T mean, T std_deviation); //!< \brief Gererate a random floating number according a Gauss distribution. (From GLM_GTX_random extension)
template <typename T> detail::tvec2<T> gaussRand2(T mean, T std_deviation); //!< \brief Gererate 2 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
template <typename T> detail::tvec3<T> gaussRand3(T mean, T std_deviation); //!< \brief Gererate 3 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
template <typename T> detail::tvec4<T> gaussRand4(T mean, T std_deviation); //!< \brief Gererate 4 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
template <typename T> detail::tvec2<T> gaussRand2(const detail::tvec2<T>& mean, T std_deviation); //!< \brief Gererate 2 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
template <typename T> detail::tvec3<T> gaussRand3(const detail::tvec3<T>& mean, T std_deviation); //!< \brief Gererate 3 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
template <typename T> detail::tvec4<T> gaussRand4(const detail::tvec4<T>& mean, T std_deviation); //!< \brief Gererate 4 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
template <typename T> detail::tvec2<T> gaussRand2(T mean, const detail::tvec2<T>& std_deviation); //!< \brief Gererate 2 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
template <typename T> detail::tvec3<T> gaussRand3(T mean, const detail::tvec3<T>& std_deviation); //!< \brief Gererate 3 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
template <typename T> detail::tvec4<T> gaussRand4(T mean, const detail::tvec4<T>& std_deviation); //!< \brief Gererate 4 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
template <typename T> detail::tvec2<T> gaussRand2(const detail::tvec2<T>& mean, const detail::tvec2<T>& std_deviation); //!< \brief Gererate 2 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
template <typename T> detail::tvec3<T> gaussRand3(const detail::tvec3<T>& mean, const detail::tvec3<T>& std_deviation); //!< \brief Gererate 3 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
template <typename T> detail::tvec4<T> gaussRand4(const detail::tvec4<T>& mean, const detail::tvec4<T>& std_deviation); //!< \brief Gererate 4 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
/// @} /// @}
}//namespace glm }//namespace glm

516
glm/gtc/random.inl
Unescape View File

@ -12,521 +12,5 @@
namespace glm{ namespace glm{
template <>
GLM_FUNC_QUALIFIER float signedRand1()
{
#if(GLM_COMPILER & GLM_COMPILER_VC)// && (GLM_COMPILER < GLM_COMPILER_VC2010)
#define RAND_SHIFT_NUM 5
#else
#define RAND_SHIFT_NUM 0
#endif
return float((std::rand() - (RAND_MAX >> 1) - 1) << 1) / float(RAND_MAX - RAND_SHIFT_NUM);
}
template <>
GLM_FUNC_QUALIFIER double signedRand1()
{
return double(signedRand1<float>());
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> signedRand2()
{
return detail::tvec2<T>(
signedRand1<float>(),
signedRand1<float>());
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> signedRand3()
{
return detail::tvec3<T>(
signedRand1<float>(),
signedRand1<float>(),
signedRand1<float>());
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> signedRand4()
{
return detail::tvec4<T>(
signedRand1<float>(),
signedRand1<float>(),
signedRand1<float>(),
signedRand1<float>());
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> normalizedRand2()
{
T a = compRand1<T>(T(0), T(6.283185307179586476925286766559f));
return detail::tvec2<T>(cos(a), sin(a));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> normalizedRand3()
{
T z = compRand1(T(-1), T(1));
T a = compRand1(T(0), T(6.283185307179586476925286766559f));
T r = sqrt(T(1) - z * z);
T x = r * cos(a);
T y = r * sin(a);
return detail::tvec3<T>(x, y, z);
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> normalizedRand3(
T Min,
T Max)
{
return normalizedRand3<T>() * compRand1(Min, Max);
}
template <>
GLM_FUNC_QUALIFIER float compRand1()
{
return float(std::rand()) / float(RAND_MAX);
}
template <>
GLM_FUNC_QUALIFIER double compRand1()
{
return double(std::rand()) / double(RAND_MAX);
}
GLM_FUNC_QUALIFIER detail::thalf compRand1(
detail::thalf Min,
detail::thalf Max)
{
return compRand1<detail::thalf>() * (Max - Min) + Min;
}
GLM_FUNC_QUALIFIER float compRand1(
float Min,
float Max)
{
return compRand1<float>() * (Max - Min) + Min;
}
GLM_FUNC_QUALIFIER double compRand1(
double Min,
double Max)
{
return compRand1<double>() * (Max - Min) + Min;
}
template <typename T>
GLM_FUNC_QUALIFIER T compRand1(
T Min,
T Max)
{
return T(compRand1<double>() * double(Max - Min) + double(Min));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> compRand2(
T Min,
T Max)
{
return detail::tvec2<T>(
compRand1(Min, Max),
compRand1(Min, Max));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> compRand3(
T Min,
T Max)
{
return detail::tvec3<T>(
compRand1(Min, Max),
compRand1(Min, Max),
compRand1(Min, Max));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> compRand4(
T Min,
T Max)
{
return detail::tvec4<T>(
compRand1(Min, Max),
compRand1(Min, Max),
compRand1(Min, Max),
compRand1(Min, Max));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> compRand2(
T Min,
const detail::tvec2<T>& Max)
{
return detail::tvec2<T>(
compRand1(Min.x, Max.x),
compRand1(Min.y, Max.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> compRand3(
T Min,
const detail::tvec3<T>& Max)
{
return detail::tvec3<T>(
compRand1(Min.x, Max.x),
compRand1(Min.y, Max.y),
compRand1(Min.z, Max.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> compRand4(
T Min,
const detail::tvec4<T>& Max)
{
return detail::tvec4<T>(
compRand1(Min.x, Max.x),
compRand1(Min.y, Max.y),
compRand1(Min.z, Max.z),
compRand1(Min.w, Max.w));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> compRand2(
const detail::tvec2<T>& Min,
T Max)
{
return detail::tvec2<T>(
compRand1(Min.x, Max.x),
compRand1(Min.y, Max.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> compRand3(
const detail::tvec3<T>& Min,
T Max)
{
return detail::tvec3<T>(
compRand1(Min.x, Max.x),
compRand1(Min.y, Max.y),
compRand1(Min.z, Max.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> compRand4(
const detail::tvec4<T>& Min,
T Max)
{
return detail::tvec4<T>(
compRand1(Min.x, Max.x),
compRand1(Min.y, Max.y),
compRand1(Min.z, Max.z),
compRand1(Min.w, Max.w));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> compRand2(
const detail::tvec2<T>& Min,
const detail::tvec2<T>& Max)
{
return detail::tvec2<T>(
compRand1(Min.x, Max.x),
compRand1(Min.y, Max.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> compRand3(
const detail::tvec3<T>& Min,
const detail::tvec3<T>& Max)
{
return detail::tvec3<T>(
compRand1(Min.x, Max.x),
compRand1(Min.y, Max.y),
compRand1(Min.z, Max.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> compRand4(
const detail::tvec4<T>& Min,
const detail::tvec4<T>& Max)
{
return detail::tvec4<T>(
compRand1(Min.x, Max.x),
compRand1(Min.y, Max.y),
compRand1(Min.z, Max.z),
compRand1(Min.w, Max.w));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<float> vecRand2()
{
detail::tvec2<float> result(float(0));
do
{
result = compRand2(float(-1), float(1));
} while (length(result) > float(1));
return result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<double> vecRand2()
{
detail::tvec2<double> result(double(0));
do
{
result = compRand2(double(-1), double(1));
} while (length(result) > double(1));
return result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> vecRand2(
T MinRadius,
T MaxRadius)
{
assert(MinRadius <= MaxRadius);
detail::tvec2<T> Result(T(0));
T LenRadius(0);
do
{
Result = compRand2(-MaxRadius, MaxRadius);
LenRadius = length(Result);
}
while(LenRadius > MaxRadius || LenRadius < MinRadius);
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> vecRand3()
{
detail::tvec3<T> Result(T(0));
do
{
Result = compRand3(T(-1), T(1));
}
while(length(Result) > T(1));
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> vecRand3(
T MinRadius,
T MaxRadius)
{
assert(MinRadius <= MaxRadius);
detail::tvec3<T> Result(0);
T LenRadius(0);
do
{
Result = compRand3(-MaxRadius, MaxRadius);
LenRadius = length(Result);
}
while(LenRadius > MaxRadius || LenRadius < MinRadius);
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<float> vecRand4()
{
detail::tvec4<float> result(float(0));
do
{
result = compRand4(float(-1), float(1));
} while (length(result) > float(1));
return result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<double> vecRand4()
{
detail::tvec4<double> result(double(0));
do
{
result = compRand4(double(-1), double(1));
} while (length(result) > double(1));
return result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> vecRand4(
T MinRadius,
T MaxRadius)
{
assert(MinRadius <= MaxRadius);
detail::tvec4<T> Result(T(0));
T LenRadius(T(0));
do
{
Result = compRand4(-MaxRadius, MaxRadius);
LenRadius = length(Result);
}
while(LenRadius > MaxRadius || LenRadius < MinRadius);
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER T gaussRand1(
T mean,
T std_deviation)
{
T w, x1, x2;
do
{
x1 = compRand1(T(-1), T(1));
x2 = compRand1(T(-1), T(1));
w = x1 * x1 + x2 * x2;
} while(w > T(1));
return x2 * std_deviation * std_deviation * sqrt((T(-2) * log(w)) / w) + mean;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> gaussRand2(
T mean,
T std_deviation)
{
return detail::tvec2<T>(
gaussRand1(mean, std_deviation),
gaussRand1(mean, std_deviation));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> gaussRand3(
T mean,
T std_deviation)
{
return detail::tvec3<T>(
gaussRand1(mean, std_deviation),
gaussRand1(mean, std_deviation),
gaussRand1(mean, std_deviation));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> gaussRand4(
T mean,
T std_deviation)
{
return detail::tvec4<T>(
gaussRand1(mean, std_deviation),
gaussRand1(mean, std_deviation),
gaussRand1(mean, std_deviation),
gaussRand1(mean, std_deviation));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> gaussRand2(
T mean,
const detail::tvec2<T>& std_deviation)
{
return detail::tvec2<T>(
gaussRand1(mean, std_deviation.x),
gaussRand1(mean, std_deviation.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> gaussRand3(
T mean,
const detail::tvec3<T>& std_deviation)
{
return detail::tvec3<T>(
gaussRand1(mean, std_deviation.x),
gaussRand1(mean, std_deviation.y),
gaussRand1(mean, std_deviation.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> gaussRand4(
T mean,
const detail::tvec4<T>& std_deviation)
{
return detail::tvec4<T>(
gaussRand1(mean, std_deviation.x),
gaussRand1(mean, std_deviation.y),
gaussRand1(mean, std_deviation.z),
gaussRand1(mean, std_deviation.w));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> gaussRand2(
const detail::tvec2<T>& mean,
T std_deviation)
{
return detail::tvec2<T>(
gaussRand1(mean.x, std_deviation),
gaussRand1(mean.y, std_deviation));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> gaussRand3(
const detail::tvec3<T>& mean,
T std_deviation)
{
return detail::tvec3<T>(
gaussRand1(mean.x, std_deviation),
gaussRand1(mean.y, std_deviation),
gaussRand1(mean.z, std_deviation));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> gaussRand4(
const detail::tvec4<T>& mean,
T std_deviation)
{
return detail::tvec4<T>(
gaussRand1(mean.x, std_deviation),
gaussRand1(mean.y, std_deviation),
gaussRand1(mean.z, std_deviation),
gaussRand1(mean.w, std_deviation));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> gaussRand2(
const detail::tvec2<T>& mean,
const detail::tvec2<T>& std_deviation)
{
return detail::tvec2<T>(
gaussRand1(mean.x, std_deviation.x),
gaussRand1(mean.y, std_deviation.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> gaussRand3(
const detail::tvec3<T>& mean,
const detail::tvec3<T>& std_deviation)
{
return detail::tvec3<T>(
gaussRand1(mean.x, std_deviation.x),
gaussRand1(mean.y, std_deviation.y),
gaussRand1(mean.z, std_deviation.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> gaussRand4(
const detail::tvec4<T>& mean,
const detail::tvec4<T>& std_deviation)
{
return detail::tvec4<T>(
gaussRand1(mean.x, std_deviation.x),
gaussRand1(mean.y, std_deviation.y),
gaussRand1(mean.z, std_deviation.z),
gaussRand1(mean.w, std_deviation.w));
}
}//namespace glm }//namespace glm

27
glm/gtx/random.inl
Unescape View File

@ -56,11 +56,34 @@ GLM_FUNC_QUALIFIER detail::tvec4<T> signedRand4()
signedRand1<float>()); signedRand1<float>());
} }
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> normalizedRand2(
T Min,
T Max)
{
return normalizedRand2<T>() * compRand1(Min, Max);
}
template <typename T> template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> normalizedRand2() GLM_FUNC_QUALIFIER detail::tvec2<T> normalizedRand2()
{ {
T a = compRand1<T>(T(0), T(6.283185307179586476925286766559f)); T z = compRand1(T(-1), T(1));
return detail::tvec2<T>(cos(a), sin(a)); T a = compRand1(T(0), T(6.283185307179586476925286766559f));
T r = sqrt(T(1) - z * z);
T x = r * cos(a);
T y = r * sin(a);
return detail::tvec2<T>(x, y);
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> normalizedRand3(
T Min,
T Max)
{
return normalizedRand3<T>() * compRand1(Min, Max);
} }
template <typename T> template <typename T>

6
test/gtc/gtc_random.cpp
Unescape View File

@ -8,7 +8,7 @@
/////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////
#include <glm/glm.hpp> #include <glm/glm.hpp>
#include <glm/gtc/random.hpp> #include <glm/gtx/random.hpp>
#include <glm/gtx/epsilon.hpp> #include <glm/gtx/epsilon.hpp>
#include <iostream> #include <iostream>
@ -21,8 +21,8 @@ int test_signedRand1()
double ResultDouble = 0.0f; double ResultDouble = 0.0f;
for(std::size_t i = 0; i < 100000; ++i) for(std::size_t i = 0; i < 100000; ++i)
{ {
ResultFloat += glm::signedRand1(-1.0f, 1.0f); ResultFloat += glm::signedRand1<float>(/*-1.0f, 1.0f*/);
ResultDouble += glm::signedRand1(-1.0, 1.0); ResultDouble += glm::signedRand1<double>(/*-1.0, 1.0*/);
} }
Error += glm::equalEpsilon(ResultFloat, 0.0f, 0.0001f); Error += glm::equalEpsilon(ResultFloat, 0.0f, 0.0001f);

Write Preview
Loading…
Cancel
Save