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

Removed gtx extension namespace

Browse Source
This commit is contained in:
Christophe Riccio 2011-06-07 11:48:54 +01:00
parent cda4a8e6c0
commit 1205927b89
32 changed files with 68 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
glm/gtx/color_cast.hpp
View File

@ -56,7 +56,7 @@ namespace gtx
template <typename T> gtc::uint64 u64_bgra_cast(const detail::tvec4<T>& c); //!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::uint64 u64_abgr_cast(const detail::tvec4<T>& c); //!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtx::number_precision::f16vec1 f16_channel_cast(T a); //!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
template <typename T> gtx::f16vec1 f16_channel_cast(T a); //!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::f16vec3 f16_rgbx_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::f16vec3 f16_xrgb_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
@ -68,7 +68,7 @@ namespace gtx
template <typename T> gtc::f16vec4 f16_bgra_cast(T c); //!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::f16vec4 f16_abgr_cast(T c); //!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtx::number_precision::f32vec1 f32_channel_cast(T a); //!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
template <typename T> gtx::f32vec1 f32_channel_cast(T a); //!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::f32vec3 f32_rgbx_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::f32vec3 f32_xrgb_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
@ -80,7 +80,7 @@ namespace gtx
template <typename T> gtc::f32vec4 f32_bgra_cast(T c); //!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::f32vec4 f32_abgr_cast(T c); //!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtx::number_precision::f64vec1 f64_channel_cast(T a); //!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
template <typename T> gtx::f64vec1 f64_channel_cast(T a); //!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::f64vec3 f64_rgbx_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::f64vec3 f64_xrgb_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)

3
glm/gtx/color_cast.inl
View File

@ -9,8 +9,6 @@
namespace glm{
namespace gtx{
//! GLM_GTX_color_cast extension: Conversion between two color types
namespace color_cast{
template <typename T>
GLM_FUNC_QUALIFIER gtc::uint8 u8channel_cast(T a)
@ -734,6 +732,5 @@ GLM_FUNC_QUALIFIER detail::tvec4<double> f64_abgr_cast<uint64>(uint64 color)
return result;
}
}//namespace color_space
}//namespace gtx
}//namespace glm

8
glm/gtx/gradient_paint.inl
View File

@ -19,11 +19,11 @@ namespace gtx{
{
glm::detail::tvec2<valType> F = Focal - Center;
glm::detail::tvec2<valType> D = Position - Focal;
valType Radius2 = gtx::optimum_pow::pow2(Radius);
valType Fx2 = gtx::optimum_pow::pow2(F.x);
valType Fy2 = gtx::optimum_pow::pow2(F.y);
valType Radius2 = gtx::pow2(Radius);
valType Fx2 = gtx::pow2(F.x);
valType Fy2 = gtx::pow2(F.y);
valType Numerator = (D.x * F.x + D.y * F.y) + glm::sqrt(Radius2 * (gtx::optimum_pow::pow2(D.x) + gtx::optimum_pow::pow2(D.y)) - gtx::optimum_pow::pow2(D.x * F.y - D.y * F.x));
valType Numerator = (D.x * F.x + D.y * F.y) + glm::sqrt(Radius2 * (gtx::pow2(D.x) + gtx::pow2(D.y)) - gtx::pow2(D.x * F.y - D.y * F.x));
valType Denominator = Radius2 - (Fx2 + Fy2);
return Numerator / Denominator;
}

2
glm/gtx/matrix_operation.hpp
View File

@ -86,6 +86,4 @@ namespace gtx
#include "matrix_operation.inl"
namespace glm{using namespace gtx::matrix_operation;}
#endif//glm_gtx_matrix_operation

8
glm/gtx/normalize_dot.inl
View File

@ -71,7 +71,7 @@ GLM_FUNC_QUALIFIER genType fastNormalizeDot
{
return
glm::dot(x, y) *
glm::gtx::fast_square_root::fastInverseSqrt(glm::dot(x, x) *
glm::gtx::fastInverseSqrt(glm::dot(x, x) *
glm::dot(y, y));
}
@ -84,7 +84,7 @@ GLM_FUNC_QUALIFIER valType fastNormalizeDot
{
return
glm::dot(x, y) *
glm::gtx::fast_square_root::fastInverseSqrt(glm::dot(x, x) *
glm::gtx::fastInverseSqrt(glm::dot(x, x) *
glm::dot(y, y));
}
@ -97,7 +97,7 @@ GLM_FUNC_QUALIFIER valType fastNormalizeDot
{
return
glm::dot(x, y) *
glm::gtx::fast_square_root::fastInverseSqrt(glm::dot(x, x) *
glm::gtx::fastInverseSqrt(glm::dot(x, x) *
glm::dot(y, y));
}
@ -110,7 +110,7 @@ GLM_FUNC_QUALIFIER valType fastNormalizeDot
{
return
glm::dot(x, y) *
glm::gtx::fast_square_root::fastInverseSqrt(glm::dot(x, x) *
glm::gtx::fastInverseSqrt(glm::dot(x, x) *
glm::dot(y, y));
}

6
glm/gtx/perpendicular.inl
View File

@ -15,7 +15,7 @@ GLM_FUNC_QUALIFIER detail::tvec2<T> perp(
detail::tvec2<T> const & x,
detail::tvec2<T> const & Normal)
{
return x - projection::proj(x, Normal);
return x - proj(x, Normal);
}
template <typename T>
@ -23,7 +23,7 @@ GLM_FUNC_QUALIFIER detail::tvec3<T> perp(
detail::tvec3<T> const & x,
detail::tvec3<T> const & Normal)
{
return x - projection::proj(x, Normal);
return x - proj(x, Normal);
}
template <typename T>
@ -31,7 +31,7 @@ GLM_FUNC_QUALIFIER detail::tvec4<T> perp(
detail::tvec4<T> const & x,
detail::tvec4<T> const & Normal)
{
return x - projection::proj(x, Normal);
return x - proj(x, Normal);
}
}//namespace gtx

1
glm/gtx/raw_data.hpp
View File

@ -44,7 +44,6 @@ namespace gtx
typedef uint64 qword;
/// @}
}// namespace raw_data
}// namespace gtx
}// namespace glm

6
glm/gtx/rotate_vector.inl
View File

@ -29,7 +29,7 @@ namespace gtx{
T const & angle,
const detail::tvec3<T> & normal)
{
return detail::tmat3x3<T>(glm::gtx::transform::rotate(angle, normal)) * v;
return detail::tmat3x3<T>(glm::gtx::rotate(angle, normal)) * v;
}
/*
template <typename T>
@ -49,7 +49,7 @@ namespace gtx{
T const & angle,
detail::tvec3<T> const & normal)
{
return glm::gtx::transform::rotate(angle, normal) * v;
return glm::gtx::rotate(angle, normal) * v;
}
template <typename T>
@ -140,7 +140,7 @@ namespace gtx{
detail::tvec3<T> RotationAxis = cross(Up, Normal);
T Angle = degrees(acos(dot(Normal, Up)));
return glm::gtx::transform::rotate(Angle, RotationAxis);
return glm::gtx::rotate(Angle, RotationAxis);
}
}//namespace gtx

10
glm/gtx/spline.hpp
View File

@ -22,12 +22,9 @@
#endif
namespace glm{
namespace gtx{
namespace spline ///< GLM_GTX_spline extension: Spline functions
namespace gtx
{
using namespace gtx::optimum_pow;
/// \addtogroup gtx_spline
/// @addtogroup gtx_spline
/// @{
//! Return a point from a catmull rom curve.
@ -61,13 +58,10 @@ namespace spline ///< GLM_GTX_spline extension: Spline functions
typename genType::value_type const & s);
/// @}
}//namespace spline
}//namespace gtx
}//namespace glm
#include "spline.inl"
namespace glm{using namespace gtx::spline;}
#endif//glm_gtx_spline

12
glm/gtx/spline.inl
View File

@ -8,8 +8,7 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace gtx{
namespace spline
namespace gtx
{
template <typename genType>
GLM_FUNC_QUALIFIER genType catmullRom
@ -22,8 +21,8 @@ namespace spline
)
{
typename genType::value_type s1 = s;
typename genType::value_type s2 = optimum_pow::pow2(s);
typename genType::value_type s3 = optimum_pow::pow3(s);
typename genType::value_type s2 = pow2(s);
typename genType::value_type s3 = pow3(s);
typename genType::value_type f1 = -s3 + typename genType::value_type(2) * s2 - s;
typename genType::value_type f2 = typename genType::value_type(3) * s3 - typename genType::value_type(5) * s2 + typename genType::value_type(2);
@ -45,8 +44,8 @@ namespace spline
)
{
typename genType::value_type s1 = s;
typename genType::value_type s2 = optimum_pow::pow2(s);
typename genType::value_type s3 = optimum_pow::pow3(s);
typename genType::value_type s2 = pow2(s);
typename genType::value_type s3 = pow3(s);
typename genType::value_type f1 = typename genType::value_type(2) * s3 - typename genType::value_type(3) * s2 + typename genType::value_type(1);
typename genType::value_type f2 = typename genType::value_type(-2) * s3 + typename genType::value_type(3) * s2;
@ -69,6 +68,5 @@ namespace spline
return ((v1 * s + v2) * s + v3) * s + v4;
}
}//namespace spline
}//namespace gtx
}//namespace glm

6
glm/gtx/std_based_type.hpp
View File

@ -22,8 +22,7 @@
#endif
namespace glm{
namespace gtx{
namespace std_based_type ///< GLM_GTX_std_based_type extension: Add support vector types based on C++ standard type
namespace gtx
{
typedef detail::tvec2<std::size_t> size2;
typedef detail::tvec3<std::size_t> size3;
@ -61,12 +60,9 @@ namespace std_based_type ///< GLM_GTX_std_based_type extension: Add support vect
typedef detail::tvec3<unsigned long> ulvec3;
typedef detail::tvec4<unsigned long> ulvec4;
}//namespace std_based_type
}//namespace gtx
}//namespace glm
#include "std_based_type.inl"
namespace glm{using namespace gtx::std_based_type;}
#endif//glm_gtx_std_based_type

12
glm/gtx/string_cast.hpp
View File

@ -29,14 +29,9 @@
#endif
namespace glm{
namespace gtx{
namespace string_cast ///< GLM_GTX_string_cast extension: Setup strings for GLM type values
namespace gtx
{
using namespace gtx::integer;
using namespace gtx::unsigned_int;
using namespace gtx::quaternion;
/// \addtogroup gtx_string_cast
/// @addtogroup gtx_string_cast
/// @{
//! Create a string from a GLM type value.
@ -45,12 +40,9 @@ namespace string_cast ///< GLM_GTX_string_cast extension: Setup strings for GLM
std::string to_string(genType const & x);
/// @}
}//namespace string_cast
}//namespace gtx
}//namespace glm
#include "string_cast.inl"
namespace glm{using namespace gtx::string_cast;}
#endif//glm_gtx_string_cast

4
glm/gtx/string_cast.inl
View File

@ -34,8 +34,7 @@ namespace detail
}//namespace detail
namespace gtx{
namespace string_cast
{
////////////////////////////////
// Scalars
@ -592,6 +591,5 @@ namespace string_cast
x[3][0], x[3][1], x[3][2], x[3][3]);
}
}//namespace string_cast
}//namespace gtx
}//namespace glm

6
glm/gtx/transform.hpp
View File

@ -43,8 +43,7 @@
#endif
namespace glm{
namespace gtx{
namespace transform ///< GLM_GTX_transform extension: Add transformation matrices
namespace gtx
{
/// @addtogroup gtx_transform
/// @{
@ -119,12 +118,9 @@ namespace transform ///< GLM_GTX_transform extension: Add transformation matrice
detail::tvec3<T> const & v);
/// @}
}// namespace transform
}// namespace gtx
}// namespace glm
#include "transform.inl"
namespace glm{using namespace gtx::transform;}
#endif//glm_gtx_transform

4
glm/gtx/transform.inl
View File

@ -8,8 +8,7 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace gtx{
namespace transform
namespace gtx
{
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T> translate(
@ -89,6 +88,5 @@ namespace transform
detail::tmat4x4<T>(1.0f), v);
}
}//namespace transform
}//namespace gtx
}//namespace glm

10
glm/gtx/transform2.hpp
View File

@ -23,12 +23,9 @@
#endif
namespace glm{
namespace gtx{
namespace transform2 ///< GLM_GTX_transform2 extension: Add extra transformation matrices
namespace gtx
{
using namespace gtx::transform;
/// \addtogroup gtx_transform2
/// @addtogroup gtx_transform2
/// @{
//! Transforms a matrix with a shearing on X axis.
@ -107,12 +104,9 @@ namespace transform2 ///< GLM_GTX_transform2 extension: Add extra transformation
valType bias);
/// @}
}// namespace transform2
}// namespace gtx
}// namespace glm
#include "transform2.inl"
namespace glm{using namespace gtx::transform2;}
#endif//glm_gtx_transform2

4
glm/gtx/transform2.inl
View File

@ -9,8 +9,7 @@
namespace glm{
namespace gtx{
namespace transform2
{
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T> shearX2D(
const detail::tmat3x3<T>& m,
@ -153,7 +152,6 @@ namespace transform2
return m * scaleBias(scale, bias);
}
}//namespace transform2
}//namespace gtx
}//namespace glm

8
glm/gtx/ulp.hpp
View File

@ -21,10 +21,9 @@
#endif
namespace glm{
namespace gtx{
namespace ulp ///< GLM_GTX_ulp extension: Precision calculation functions
namespace gtx
{
/// \addtogroup gtx_ulp
/// @addtogroup gtx_ulp
/// @{
//! Return the next ULP value(s) after the input value(s).
@ -58,13 +57,10 @@ namespace ulp ///< GLM_GTX_ulp extension: Precision calculation functions
vecType<uint> float_distance(vecType<T> const & x, vecType<T> const & y);
///@}
}// namespace ulp
}// namespace gtx
}// namespace glm
#include "ulp.inl"
namespace glm{using namespace gtx::ulp;}
#endif//glm_gtx_ulp

5
glm/gtx/ulp.inl
View File

@ -178,8 +178,7 @@ namespace detail
namespace glm{
namespace gtx{
namespace ulp
{
GLM_FUNC_QUALIFIER float next_float(float const & x)
{
return GLM_NEXT_AFTER_FLT(x, std::numeric_limits<float>::max());
@ -391,6 +390,6 @@ namespace ulp
return glm::max(glm::max(ulps[0], ulps[1]), glm::max(ulps[2], ulps[3]));
}
*/
}//namespace ulp
}//namespace gtx
}//namespace glm

10
glm/gtx/unsigned_int.hpp
View File

@ -23,12 +23,9 @@
#endif
namespace glm{
namespace gtx{
namespace unsigned_int ///< GLM_GTX_unsigned_int extension: Add support for unsigned integer for core functions
namespace gtx
{
using namespace gtx::integer;
/// \addtogroup gtx_unsigned_int
/// @addtogroup gtx_unsigned_int
/// @{
//! 32bit signed integer.
@ -48,12 +45,9 @@ namespace unsigned_int ///< GLM_GTX_unsigned_int extension: Add support for unsi
uint mod(uint x, uint y);
/// @}
}//namespace unsigned_int
}//namespace gtx
}//namespace glm
#include "unsigned_int.inl"
namespace glm{using namespace gtx::unsigned_int;}
#endif//glm_gtx_unsigned_int

2
glm/gtx/unsigned_int.inl
View File

@ -9,7 +9,6 @@
namespace glm{
namespace gtx{
namespace unsigned_int{
GLM_FUNC_QUALIFIER uint pow(uint x, uint y)
{
@ -40,6 +39,5 @@ GLM_FUNC_QUALIFIER uint mod(uint x, uint y)
return x - y * (x / y);
}
}//namespace unsigned_int
}//namespace gtx
}//namespace glm

32
glm/gtx/vec1.hpp
View File

@ -22,9 +22,7 @@
#endif
namespace glm{
namespace gtx{
namespace vector1{ ///< GLM_GTX_vec1 extension: 1 component vector.
namespace precision
namespace gtx
{
//! 1 component vector of high precision floating-point numbers.
//! There is no guarantee on the actual precision.
@ -64,7 +62,6 @@ namespace precision
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::lowp_uvec1_t lowp_uvec1;
}//namespace precision
//////////////////////////
// vec1 definition
@ -74,48 +71,45 @@ namespace precision
typedef detail::tvec1<bool> bvec1;
#if(defined(GLM_PRECISION_HIGHP_FLOAT))
typedef precision::highp_vec1 vec1;
typedef highp_vec1 vec1;
#elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
typedef precision::mediump_vec1 vec1;
typedef mediump_vec1 vec1;
#elif(defined(GLM_PRECISION_LOWP_FLOAT))
typedef precision::lowp_vec1 vec1;
typedef lowp_vec1 vec1;
#else
//! 1 component vector of floating-point numbers.
//! From GLM_GTX_vec1 extension.
typedef precision::mediump_vec1 vec1;
typedef mediump_vec1 vec1;
#endif//GLM_PRECISION
#if(defined(GLM_PRECISION_HIGHP_INT))
typedef precision::highp_ivec1 ivec1;
typedef highp_ivec1 ivec1;
#elif(defined(GLM_PRECISION_MEDIUMP_INT))
typedef precision::mediump_ivec1 ivec1;
typedef mediump_ivec1 ivec1;
#elif(defined(GLM_PRECISION_LOWP_INT))
typedef precision::lowp_ivec1 ivec1;
typedef lowp_ivec1 ivec1;
#else
//! 1 component vector of signed integer numbers.
//! From GLM_GTX_vec1 extension.
typedef precision::mediump_ivec1 ivec1;
typedef mediump_ivec1 ivec1;
#endif//GLM_PRECISION
#if(defined(GLM_PRECISION_HIGHP_UINT))
typedef precision::highp_uvec1 uvec1;
typedef highp_uvec1 uvec1;
#elif(defined(GLM_PRECISION_MEDIUMP_UINT))
typedef precision::mediump_uvec1 uvec1;
typedef mediump_uvec1 uvec1;
#elif(defined(GLM_PRECISION_LOWP_UINT))
typedef precision::lowp_uvec1 uvec1;
typedef lowp_uvec1 uvec1;
#else
//! 1 component vector of unsigned integer numbers.
//! From GLM_GTX_vec1 extension.
typedef precision::mediump_uvec1 uvec1;
typedef mediump_uvec1 uvec1;
#endif//GLM_PRECISION
}// namespace vec1
}// namespace gtx
}// namespace glm
#include "vec1.inl"
namespace glm{using namespace gtx::vector1;}
#endif//glm_gtx_vec1

8
glm/gtx/vector_access.hpp
View File

@ -21,10 +21,9 @@
#endif
namespace glm{
namespace gtx{
namespace vector_access ///< GLM_GTX_vector_access extension: Function to set values to vectors
namespace gtx
{
/// \addtogroup gtx_vector_access
/// @addtogroup gtx_vector_access
/// @{
//! Set values to a 2 components vector.
@ -55,12 +54,9 @@ namespace vector_access ///< GLM_GTX_vector_access extension: Function to set va
valType const & w);
/// @}
}//namespace vector_access
}//namespace gtx
}//namespace glm
#include "vector_access.inl"
namespace glm{using namespace gtx::vector_access;}
#endif//glm_gtx_vector_access

2
glm/gtx/vector_access.inl
View File

@ -9,7 +9,6 @@
namespace glm{
namespace gtx{
namespace vector_access{
template <typename valType>
GLM_FUNC_QUALIFIER void set
@ -53,6 +52,5 @@ GLM_FUNC_QUALIFIER void set
v.w = w;
}
}//namespace vector_access
}//namespace gtx
}//namespace glm

11
glm/gtx/vector_angle.hpp
View File

@ -26,13 +26,9 @@
#endif
namespace glm{
namespace gtx{
namespace vector_angle ///< GLM_GTX_vector_angle extension: Compute angle between vectors
namespace gtx
{
using namespace quaternion;
using namespace epsilon;
/// \addtogroup gtx_vector_angle
/// @addtogroup gtx_vector_angle
/// @{
//! Returns the absolute angle between two vectors
@ -61,12 +57,9 @@ namespace vector_angle ///< GLM_GTX_vector_angle extension: Compute angle betwee
detail::tvec3<T> const & ref);
/// @}
}// namespace vector_angle
}// namespace gtx
}// namespace glm
#include "vector_angle.inl"
namespace glm{using namespace gtx::vector_angle;}
#endif//glm_gtx_vector_angle

4
glm/gtx/vector_angle.inl
View File

@ -9,7 +9,6 @@
namespace glm{
namespace gtx{
namespace vector_angle{
template <typename genType>
GLM_FUNC_QUALIFIER typename genType::value_type angle
@ -30,7 +29,7 @@ GLM_FUNC_QUALIFIER valType orientedAngle
)
{
valType Angle = glm::degrees(acos(dot(x, y)));
detail::tvec2<valType> TransformedVector = glm::gtx::rotate_vector::rotate(x, Angle);
detail::tvec2<valType> TransformedVector = glm::gtx::rotate(x, Angle);
if(all(equalEpsilon(y, TransformedVector, valType(0.01))))
return Angle;
else
@ -53,6 +52,5 @@ GLM_FUNC_QUALIFIER valType orientedAngle
return Angle;
}
}//namespace vector_angle
}//namespace gtx
}//namespace glm

8
glm/gtx/vector_query.hpp
View File

@ -23,10 +23,9 @@
#endif
namespace glm{
namespace gtx{
namespace vector_query ///< GLM_GTX_vector_query extension: Query informations of vector types
namespace gtx
{
/// \addtogroup gtx_vector_query
/// @addtogroup gtx_vector_query
/// @{
//! Check if two vectors are collinears.
@ -84,12 +83,9 @@ namespace vector_query ///< GLM_GTX_vector_query extension: Query informations o
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
/// @}
}// namespace vector_query
}// namespace gtx
}// namespace glm
#include "vector_query.inl"
namespace glm{using namespace gtx::vector_query;}
#endif//glm_gtx_vector_query

4
glm/gtx/vector_query.inl
View File

@ -14,8 +14,7 @@
namespace glm{
namespace gtx{
namespace vector_query
{
template <typename T>
GLM_FUNC_QUALIFIER bool areCollinear
(
@ -169,6 +168,5 @@ namespace vector_query
return similar;
}
}//namespace vector_query
}//namespace gtx
}//namespace glm

8
glm/gtx/verbose_operator.hpp
View File

@ -21,10 +21,9 @@
#endif
namespace glm{
namespace gtx{
namespace verbose_operator ///< GLM_GTX_verbose_operator extension: Use words to replace operators
namespace gtx
{
/// \addtogroup gtx_verbose_operator
/// @addtogroup gtx_verbose_operator
/// @{
//! Addition of two values
@ -53,12 +52,9 @@ namespace verbose_operator ///< GLM_GTX_verbose_operator extension: Use words to
genTypeT mad(genTypeT const & a, genTypeU const & b, genTypeV const & c);
/// @}
}// namespace verbose_operator
}// namespace gtx
}// namespace glm
#include "verbose_operator.inl"
namespace glm{using namespace gtx::verbose_operator;}
#endif//glm_gtx_verbose_operator

2
glm/gtx/verbose_operator.inl
View File

@ -9,7 +9,6 @@
namespace glm{
namespace gtx{
namespace verbose_operator{
template <typename genType>
GLM_FUNC_QUALIFIER genType add(genType const & a, genType const & b)
@ -124,6 +123,5 @@ GLM_FUNC_QUALIFIER genTypeT mad(genTypeT const & a, genTypeU const & b, genTypeV
return a * b + c;
}
}//namespace verbose_operator
}//namespace gtx
}//namespace glm

8
glm/gtx/wrap.hpp
View File

@ -21,10 +21,9 @@
#endif
namespace glm{
namespace gtx{
namespace wrap ///< GLM_GTX_wrap: Wrapping mode using my texture samping.
namespace gtx
{
/// \addtogroup gtx_wrap
/// @addtogroup gtx_wrap
/// @{
//! Simulate GL_CLAMP OpenGL wrap mode
@ -43,12 +42,9 @@ namespace wrap ///< GLM_GTX_wrap: Wrapping mode using my texture samping.
genType mirrorRepeat(genType const & Texcoord);
/// @}
}// namespace wrap
}// namespace gtx
}// namespace glm
#include "wrap.inl"
namespace glm{using namespace gtx::wrap;}
#endif//glm_img_wrap

4
glm/gtx/wrap.inl
View File

@ -11,8 +11,7 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace gtx{
namespace wrap
namespace gtx
{
////////////////////////
// clamp
@ -168,6 +167,5 @@ namespace wrap
return Result;
}
}//namespace wrap
}//namespace gtx
}//namespace glm