Merge branch '0.9.3' into swizzle

glm/gtc/random.hpp

@@ -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

glm/gtc/random.inl

@@ -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

test/gtc/gtc_random.cpp

@@ -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();