//////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2008 G-Truc Creation (www.g-truc.net)
//////////////////////////////////////////////////////////////////////////////////
// Created : 2006-01-16
// Updated : 2006-01-16
// Licence : This source is under MIT License
// File    : glm/gtx/random.inl
//////////////////////////////////////////////////////////////////////////////////

#include <ctime>
#include <cassert>

namespace glm
{
    template <>
	inline float signedRand1GTX()
	{
		#if(GLM_COMPILER == GLM_COMPILER_VC80)
		#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 <>
	inline double signedRand1GTX()
	{
		return double(signedRand1GTX<float>());
	}

	template <typename T>
	inline detail::tvec2<T> signedRand2GTX()
	{
		return detail::tvec2<T>(
			signedRand1GTX<float>(),
			signedRand1GTX<float>());
	}

	template <typename T>
	inline detail::tvec3<T> signedRand3GTX()
	{
		return detail::tvec3<T>(
			signedRand1GTX<float>(),
			signedRand1GTX<float>(),
			signedRand1GTX<float>());
	}

	template <typename T>
	inline detail::tvec4<T> signedRand4GTX()
	{
		return detail::tvec4<T>(
			signedRand1GTX<float>(),
			signedRand1GTX<float>(),
			signedRand1GTX<float>(),
			signedRand1GTX<float>());
	}

    template <typename T>
    inline detail::tvec2<T> normalizedRand2GTX()
    {
        T a = compRand1GTX<T>(T(0), T(6.283185307179586476925286766559f));
        return detail::tvec2<T>(cos(a), sin(a));
    }

	template <typename T>
    inline detail::tvec3<T> normalizedRand3GTX()
    {
	    T z = compRand1GTX(T(-1), T(1));
	    T a = compRand1GTX(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>
    inline detail::tvec3<T> normalizedRand3GTX(T Min, T Max)
    {
        return normalizedRand3GTX<T>() * compRand1GTX(Min, Max);
    }

	template <>
	inline float compRand1GTX()
	{
		return float(std::rand()) / float(RAND_MAX);
	}

	template <>
	inline double compRand1GTX()
	{
		return double(std::rand()) / double(RAND_MAX);
	}

	template <typename T>
	inline T compRand1GTX(T Min, T Max)
	{
		return compRand1GTX<T>() * (Max - Min) + Min;
	}

	template <typename T>
	inline detail::tvec2<T> compRand2GTX(T Min, T Max)
	{
		return detail::tvec2<T>(
			compRand1GTX(Min, Max),
			compRand1GTX(Min, Max));
	}

	template <typename T>
	inline detail::tvec3<T> compRand3GTX(T Min, T Max)
	{
		return detail::tvec3<T>(
			compRand1GTX(Min, Max),
			compRand1GTX(Min, Max),
			compRand1GTX(Min, Max));
	}

	template <typename T>
	inline detail::tvec4<T> compRand4GTX(T Min, T Max)
	{
		return detail::tvec4<T>(
			compRand1GTX(Min, Max),
			compRand1GTX(Min, Max),
			compRand1GTX(Min, Max),
			compRand1GTX(Min, Max));
	}

	template <typename T>
	inline detail::tvec2<T> compRand2GTX(T Min, const detail::tvec2<T>& Max)
	{
		return detail::tvec2<T>(
			compRand1GTX(Min.x, Max.x),
			compRand1GTX(Min.y, Max.y));
	}

	template <typename T>
	inline detail::tvec3<T> compRand3GTX(T Min, const detail::tvec3<T>& Max)
	{
		return detail::tvec3<T>(
			compRand1GTX(Min.x, Max.x),
			compRand1GTX(Min.y, Max.y),
			compRand1GTX(Min.z, Max.z));
	}

	template <typename T>
	inline detail::tvec4<T> compRand4GTX(T Min, const detail::tvec4<T>& Max)
	{
		return detail::tvec4<T>(
			compRand1GTX(Min.x, Max.x),
			compRand1GTX(Min.y, Max.y),
			compRand1GTX(Min.z, Max.z),
			compRand1GTX(Min.w, Max.w));
	}

	template <typename T>
	inline detail::tvec2<T> compRand2GTX(const detail::tvec2<T>& Min, T Max)
	{
		return detail::tvec2<T>(
			compRand1GTX(Min.x, Max.x),
			compRand1GTX(Min.y, Max.y));
	}

	template <typename T>
	inline detail::tvec3<T> compRand3GTX(const detail::tvec3<T>& Min, T Max)
	{
		return detail::tvec3<T>(
			compRand1GTX(Min.x, Max.x),
			compRand1GTX(Min.y, Max.y),
			compRand1GTX(Min.z, Max.z));
	}

	template <typename T>
	inline detail::tvec4<T> compRand4GTX(const detail::tvec4<T>& Min, T Max)
	{
		return detail::tvec4<T>(
			compRand1GTX(Min.x, Max.x),
			compRand1GTX(Min.y, Max.y),
			compRand1GTX(Min.z, Max.z),
			compRand1GTX(Min.w, Max.w));
	}

	template <typename T>
	inline detail::tvec2<T> compRand2GTX(const detail::tvec2<T>& Min, const detail::tvec2<T>& Max)
	{
		return detail::tvec2<T>(
			compRand1GTX(Min.x, Max.x),
			compRand1GTX(Min.y, Max.y));
	}

	template <typename T>
	inline detail::tvec3<T> compRand3GTX(const detail::tvec3<T>& Min, const detail::tvec3<T>& Max)
	{
		return detail::tvec3<T>(
			compRand1GTX(Min.x, Max.x),
			compRand1GTX(Min.y, Max.y),
			compRand1GTX(Min.z, Max.z));
	}

	template <typename T>
	inline detail::tvec4<T> compRand4GTX(const detail::tvec4<T>& Min, const detail::tvec4<T>& Max)
	{
		return detail::tvec4<T>(
			compRand1GTX(Min.x, Max.x),
			compRand1GTX(Min.y, Max.y),
			compRand1GTX(Min.z, Max.z),
			compRand1GTX(Min.w, Max.w));
	}

	template <typename T>
    inline detail::tvec2<float> vecRand2GTX()
    {
		detail::tvec2<float> result(float(0));
		do
		{
			result = compRand2GTX(float(-1), float(1));
		} while (length(result) > float(1));

        return result;
    }

	template <typename T>
    inline detail::tvec2<double> vecRand2GTX()
    {
		detail::tvec2<double> result(double(0));
		do
		{
			result = compRand2GTX(double(-1), double(1));
		} while (length(result) > double(1));

        return result;
    }

	template <typename T>
    inline detail::tvec2<T> vecRand2GTX(T MinRadius, T MaxRadius)
    {
		assert(MinRadius <= MaxRadius);

		detail::tvec2<T> Result(T(0));
		T LenRadius(0);

		do
		{
			Result = compRand2GTX(-MaxRadius, MaxRadius);
			LenRadius = length(Result);
		}
		while(LenRadius > MaxRadius || LenRadius < MinRadius);

        return Result;
    }

	template <typename T>
    inline detail::tvec3<T> vecRand3GTX()
    {
		detail::tvec3<T> Result(T(0));
		do
		{
			Result = compRand3GTX(T(-1), T(1));
		}
		while(length(Result) > T(1));

        return Result;
    }

	template <typename T>
    inline detail::tvec3<T> vecRand3GTX(T MinRadius, T MaxRadius)
    {
		assert(MinRadius <= MaxRadius);

		detail::tvec3<T> Result(0);
		T LenRadius(0);

		do
		{
			Result = compRand3GTX(-MaxRadius, MaxRadius);
			LenRadius = length(Result);
		}
		while(LenRadius > MaxRadius || LenRadius < MinRadius);

        return Result;
    }

	template <typename T>
    inline detail::tvec4<float> vecRand4GTX()
    {
		detail::tvec4<float> result(float(0));
		do
		{
			result = compRand4GTX(float(-1), float(1));
		} while (length(result) > float(1));

        return result;
    }

	template <typename T>
    inline detail::tvec4<double> vecRand4GTX()
    {
		detail::tvec4<double> result(double(0));
		do
		{
			result = compRand4GTX(double(-1), double(1));
		} while (length(result) > double(1));

        return result;
    }

	template <typename T>
    inline detail::tvec4<T> vecRand4GTX(T MinRadius, T MaxRadius)
    {
		assert(MinRadius <= MaxRadius);

		detail::tvec4<T> Result(T(0));
		T LenRadius(T(0));

		do
		{
			Result = compRand4GTX(-MaxRadius, MaxRadius);
			LenRadius = length(Result);
		}
		while(LenRadius > MaxRadius || LenRadius < MinRadius);

        return Result;
    }

    template <typename T>
    inline T gaussRand1GTX(T mean, T std_deviation)
    {
        T w, x1, x2;

        do
        {
            x1 = compRand1GTX(T(-1), T(1));
            x2 = compRand1GTX(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>
    inline detail::tvec2<T> gaussRand2GTX(T mean, T std_deviation)
    {
        return detail::tvec2<T>(
            gaussRand1GTX(mean, std_deviation),
            gaussRand1GTX(mean, std_deviation));
    }

    template <typename T>
    inline detail::tvec3<T> gaussRand3GTX(T mean, T std_deviation)
    {
        return detail::tvec3<T>(
            gaussRand1GTX(mean, std_deviation),
            gaussRand1GTX(mean, std_deviation),
            gaussRand1GTX(mean, std_deviation));
    }

    template <typename T>
    inline detail::tvec4<T> gaussRand4GTX(T mean, T std_deviation)
    {
        return detail::tvec4<T>(
            gaussRand1GTX(mean, std_deviation),
            gaussRand1GTX(mean, std_deviation),
            gaussRand1GTX(mean, std_deviation),
            gaussRand1GTX(mean, std_deviation));
    }

    template <typename T>
    inline detail::tvec2<T> gaussRand2GTX(T mean, const detail::tvec2<T>& std_deviation)
    {
        return detail::tvec2<T>(
            gaussRand1GTX(mean, std_deviation.x),
            gaussRand1GTX(mean, std_deviation.y));
    }

    template <typename T>
    inline detail::tvec3<T> gaussRand3GTX(T mean, const detail::tvec3<T>& std_deviation)
    {
        return detail::tvec3<T>(
            gaussRand1GTX(mean, std_deviation.x),
            gaussRand1GTX(mean, std_deviation.y),
            gaussRand1GTX(mean, std_deviation.z));
    }

    template <typename T>
    inline detail::tvec4<T> gaussRand4GTX(T mean, const detail::tvec4<T>& std_deviation)
    {
        return detail::tvec4<T>(
            gaussRand1GTX(mean, std_deviation.x),
            gaussRand1GTX(mean, std_deviation.y),
            gaussRand1GTX(mean, std_deviation.z),
            gaussRand1GTX(mean, std_deviation.w));
    }

    template <typename T>
    inline detail::tvec2<T> gaussRand2GTX(const detail::tvec2<T>& mean, T std_deviation)
    {
        return detail::tvec2<T>(
            gaussRand1GTX(mean.x, std_deviation),
            gaussRand1GTX(mean.y, std_deviation));
    }

    template <typename T>
    inline detail::tvec3<T> gaussRand3GTX(const detail::tvec3<T>& mean, T std_deviation)
    {
        return detail::tvec3<T>(
            gaussRand1GTX(mean.x, std_deviation),
            gaussRand1GTX(mean.y, std_deviation),
            gaussRand1GTX(mean.z, std_deviation));
    }

    template <typename T>
    inline detail::tvec4<T> gaussRand4GTX(const detail::tvec4<T>& mean, T std_deviation)
    {
        return detail::tvec4<T>(
            gaussRand1GTX(mean.x, std_deviation),
            gaussRand1GTX(mean.y, std_deviation),
            gaussRand1GTX(mean.z, std_deviation),
            gaussRand1GTX(mean.w, std_deviation));
    }

    template <typename T>
    inline detail::tvec2<T> gaussRand2GTX(const detail::tvec2<T>& mean, const detail::tvec2<T>& std_deviation)
    {
        return detail::tvec2<T>(
            gaussRand1GTX(mean.x, std_deviation.x),
            gaussRand1GTX(mean.y, std_deviation.y));
    }

    template <typename T>
    inline detail::tvec3<T> gaussRand3GTX(const detail::tvec3<T>& mean, const detail::tvec3<T>& std_deviation)
    {
        return detail::tvec3<T>(
            gaussRand1GTX(mean.x, std_deviation.x),
            gaussRand1GTX(mean.y, std_deviation.y),
            gaussRand1GTX(mean.z, std_deviation.z));
    }

    template <typename T>
    inline detail::tvec4<T> gaussRand4GTX(const detail::tvec4<T>& mean, const detail::tvec4<T>& std_deviation)
    {
        return detail::tvec4<T>(
            gaussRand1GTX(mean.x, std_deviation.x),
            gaussRand1GTX(mean.y, std_deviation.y),
            gaussRand1GTX(mean.z, std_deviation.z),
            gaussRand1GTX(mean.w, std_deviation.w));
    }
}
