mirror/glm
1
0
Fork 0
mirror of https://github.com/g-truc/glm.git synced 2024-11-23 01:14:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch '0.9.3' into swizzle

Browse Source
This commit is contained in:
Christophe Riccio 2011-09-23 20:39:46 +01:00
commit 42cfff00a1
3 changed files with 231 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
glm/gtc/random.hpp
View File

@ -65,21 +65,46 @@ namespace glm
genType const & Max);
/// Generate random numbers in the interval [Min, Max], according a gaussian distribution
/// (From GLM_GTX_random extension)
template <typename T, template <typename> class vecType>
vecType<T> gaussRand(
vecType<T> const & Mean,
vecType<T> const & Deviation);
///
/// @param Mean
/// @param Deviation
/// @see gtc_random
template <typename genType>
genType gaussRand(
genType const & Mean,
genType const & Deviation);
/// Generate a random 2D vector which coordinates are regulary distributed on a circle of a given radius
/// (From GLM_GTX_random extension)
///
/// @param Radius
/// @see gtc_random
template <typename T>
detail::tvec2<T> circularRand(T const & Radius);
detail::tvec2<T> circularRand(
T const & Radius);
/// Generate a random 3D vector which coordinates are regulary distributed on a sphere of a given radius
/// (From GLM_GTX_random extension)
///
/// @param Radius
/// @see gtc_random
template <typename T>
detail::tvec3<T> sphericalRand(T const & Radius);
detail::tvec3<T> sphericalRand(
T const & Radius);
/// Generate a random 2D vector which coordinates are regulary distributed within the area of a disk of a given radius
///
/// @param Radius
/// @see gtc_random
template <typename T>
detail::tvec2<T> diskRand(
T const & Radius);
/// Generate a random 3D vector which coordinates are regulary distributed within the volume of a ball of a given radius
///
/// @param Radius
/// @see gtc_random
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> ballRand(
T const & Radius);
/// @}
}//namespace glm

192
glm/gtc/random.inl
View File

@ -12,5 +12,197 @@
namespace glm{
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>(
linearRand(Min.x, Max.x),
linearRand(Min.y, Max.y),
linearRand(Min.z, Max.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> linearRand
(
detail::tvec4<T> const & 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>
GLM_FUNC_QUALIFIER genType gaussRand
(
genType const & Mean,
genType const & Deviation
)
{
genType w, x1, x2;
do
{
x1 = compRand1(genType(-1), genType(1));
x2 = compRand1(genType(-1), genType(1));
w = x1 * x1 + x2 * x2;
} while(w > genType(1));
return x2 * std_deviation * std_deviation * sqrt((genType(-2) * log(w)) / w) + mean;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> gaussRand
(
detail::tvec2<T> const & Min,
detail::tvec2<T> const & Max
)
{
return detail::tvec2<T>(
gaussRand(Min.x, Max.x),
gaussRand(Min.y, Max.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> gaussRand
(
detail::tvec3<T> const & Min,
detail::tvec3<T> const & Max
)
{
return detail::tvec3<T>(
gaussRand(Min.x, Max.x),
gaussRand(Min.y, Max.y),
gaussRand(Min.z, Max.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> gaussRand
(
detail::tvec4<T> const & Min,
detail::tvec4<T> const & Max
)
{
return detail::tvec4<T>(
gaussRand(Min.x, Max.x),
gaussRand(Min.y, Max.y),
gaussRand(Min.z, Max.z),
gaussRand(Min.w, Max.w));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> diskRand
(
T const & Radius
)
{
detail::tvec2<T> Result(T(0));
T LenRadius(T(0));
do
{
Result = compRand2(-Radius, Radius);
LenRadius = length(Result);
}
while(LenRadius > Radius);
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> ballRand
(
T const & Radius
)
{
detail::tvec3<T> Result(T(0));
T LenRadius(T(0));
do
{
Result = compRand3(-Radius, Radius);
LenRadius = length(Result);
}
while(LenRadius > Radius);
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> circularRand
(
T const & Radius
)
{
T a = compRand1<T>(T(0), T(6.283185307179586476925286766559f));
return detail::tvec2<T>(cos(a), sin(a)) * Radius;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> sphericalRand
(
T const & Radius
)
{
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) * Radius;
}
}//namespace glm

10
test/gtc/gtc_random.cpp
View File

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