mirror/glm
1
0
Fork 0
mirror of https://github.com/g-truc/glm.git synced 2024-11-22 17:04: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:28:11 +01:00
parent 1b33a702f0
commit 06cc480baa
90 changed files with 180 additions and 469 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
glm/gtx/associated_min_max.hpp
View File

@ -22,8 +22,7 @@
#endif
namespace glm{
namespace gtx{
namespace associated_min_max ///< GLM_GTX_associated_min_max extension: Min and max functions that return associated values not the compared onces.
namespace gtx
{
/// \addtogroup gtx_associated_min_max
/// @{
@ -71,12 +70,9 @@ namespace associated_min_max ///< GLM_GTX_associated_min_max extension: Min and
const genTypeT& w, const genTypeU& d);
/// @}
} //namespace associated_min_max
} //namespace gtx
} //namespace glm
#include "associated_min_max.inl"
namespace glm{using namespace gtx::associated_min_max;}
#endif//glm_gtx_associated_min_max

6
glm/gtx/associated_min_max.inl
View File

@ -8,9 +8,8 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace gtx{
namespace associated_min_max{
namespace gtx
{
// Min comparison between 2 variables
template<typename T, typename U>
GLM_FUNC_QUALIFIER U associatedMin(T x, U a, T y, U b)
@ -911,6 +910,5 @@ namespace associated_min_max{
return Result;
}
}//namespace associated_min_max
}//namespace gtx
}//namespace glm

6
glm/gtx/bit.hpp
View File

@ -23,8 +23,7 @@
#endif
namespace glm{
namespace gtx{
namespace bit ///< GLM_GTX_bit extension: Allow to perform bit operations on integer values
namespace gtx
{
/// \addtogroup gtx_bit
/// @{
@ -110,12 +109,9 @@ namespace bit ///< GLM_GTX_bit extension: Allow to perform bit operations on int
int const & ToBit);
/// @}
}// namespace bit
}// namespace gtx
}// namespace glm
#include "bit.inl"
namespace glm{using namespace gtx::bit;}
#endif//glm_gtx_bit

2
glm/gtx/bit.inl
View File

@ -11,7 +11,6 @@
namespace glm{
namespace gtx{
namespace bit{
template <typename genIType>
GLM_FUNC_QUALIFIER genIType mask
@ -772,6 +771,5 @@ GLM_FUNC_QUALIFIER genIUType fillBitfieldWithZero
return Result;
}
}//namespace bit
}//namespace gtx
}//namespace glm

6
glm/gtx/closest_point.hpp
View File

@ -21,8 +21,7 @@
#endif
namespace glm{
namespace gtx{
namespace closest_point ///< GLM_GTX_closest_point extension: Find the point on a straight line which is the closet of a point.
namespace gtx
{
/// \addtogroup gtx_closest_point
/// @{
@ -36,12 +35,9 @@ namespace closest_point ///< GLM_GTX_closest_point extension: Find the point on
detail::tvec3<T> const & b);
/// @}
}// namespace closest_point
}// namespace gtx
}// namespace glm
#include "closest_point.inl"
namespace glm{using namespace gtx::closest_point;}
#endif//glm_gtx_closest_point

2
glm/gtx/closest_point.inl
View File

@ -12,7 +12,6 @@
namespace glm{
namespace gtx{
namespace closest_point{
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<valType> closestPointOnLine
@ -34,7 +33,6 @@ GLM_FUNC_QUALIFIER detail::tvec3<valType> closestPointOnLine
return a + LineDirection * Distance;
}
}//namespace closest_point
}//namespace gtx
}//namespace glm

8
glm/gtx/color_cast.hpp
View File

@ -23,11 +23,8 @@
#endif
namespace glm{
namespace gtx{
namespace color_cast ///< GLM_GTX_color_cast extension: Conversion between two color types
namespace gtx
{
using namespace gtx::number_precision;
/// \addtogroup gtx_color_cast
/// @{
@ -96,12 +93,9 @@ namespace color_cast ///< GLM_GTX_color_cast extension: Conversion between two c
template <typename T> gtc::f64vec4 f64_abgr_cast(T c); //!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
/// @}
}//namespace color_space
}//namespace gtx
}//namespace glm
#include "color_cast.inl"
namespace glm{using namespace gtx::color_cast;}
#endif//glm_gtx_color_cast

6
glm/gtx/color_space.hpp
View File

@ -21,8 +21,7 @@
#endif
namespace glm{
namespace gtx{
namespace color_space ///< GLM_GTX_color_space extension: Related to RGB to HSV conversions and operations
namespace gtx
{
/// \addtogroup gtx_color_space
/// @{
@ -66,12 +65,9 @@ namespace color_space ///< GLM_GTX_color_space extension: Related to RGB to HSV
detail::tvec3<valType> const & color);
/// @}
}//namespace color_space
}//namespace gtx
}//namespace glm
#include "color_space.inl"
namespace glm{using namespace gtx::color_space;}
#endif//glm_gtx_color_space

4
glm/gtx/color_space.inl
View File

@ -8,8 +8,7 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace gtx{
namespace color_space
namespace gtx
{
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> rgbColor(const detail::tvec3<T>& hsvColor)
@ -149,6 +148,5 @@ namespace color_space
return dot(color, tmp);
}
}//namespace color_space
}//namespace gtx
}//namespace glm

6
glm/gtx/color_space_YCoCg.hpp
View File

@ -21,8 +21,7 @@
#endif
namespace glm{
namespace gtx{
namespace color_space_YCoCg ///< GLM_GTX_color_space_YCoCg extension: RGB to YCoCg conversions and operations
namespace gtx
{
/// \addtogroup gtx_color_space_YCoCg
/// @{
@ -54,12 +53,9 @@ namespace color_space_YCoCg ///< GLM_GTX_color_space_YCoCg extension: RGB to YCo
detail::tvec3<valType> const & YCoCgColor);
/// @}
}//namespace color_space_YCoCg
}//namespace gtx
}//namespace glm
#include "color_space_YCoCg.inl"
namespace glm{using namespace gtx::color_space_YCoCg;}
#endif//glm_gtx_color_space_YCoCg

2
glm/gtx/color_space_YCoCg.inl
View File

@ -9,7 +9,6 @@
namespace glm{
namespace gtx{
namespace color_space_YCoCg{
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<valType> rgb2YCoCg
@ -64,6 +63,5 @@ GLM_FUNC_QUALIFIER detail::tvec3<valType> YCoCgR2rgb
return result;
}
}//namespace color_space_YCoCg
}//namespace gtx
}//namespace glm

12
glm/gtx/compatibility.hpp
View File

@ -29,11 +29,10 @@
#endif//GLM_COMPILER
namespace glm{
namespace gtx{
namespace compatibility ///< GLM_GTX_compatibility extension: Provide functions to increase the compatibility with Cg and HLSL languages
namespace gtx
{
/// \addtogroup gtx_compatibility
///@{
/// @addtogroup gtx_compatibility
/// @{
template <typename T> GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> lerp(const detail::tvec2<T>& x, const detail::tvec2<T>& y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
@ -149,14 +148,11 @@ namespace compatibility ///< GLM_GTX_compatibility extension: Provide functions
typedef detail::tmat4x4<double> double4x4; //!< \brief double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
/// @}
}//namespace compatibility
}//namespace gtx
}//namespace glm
#include "compatibility.inl"
namespace glm{using namespace gtx::compatibility;}
#endif//glm_gtx_compatibility

8
glm/gtx/component_wise.hpp
View File

@ -21,10 +21,9 @@
#endif
namespace glm{
namespace gtx{
namespace component_wise ///< GLM_GTX_component_wise extension: Operations between components of a type
namespace gtx
{
/// \addtogroup gtx_component_wise
/// @addtogroup gtx_component_wise
/// @{
//! Add all vector components together.
@ -52,12 +51,9 @@ namespace component_wise ///< GLM_GTX_component_wise extension: Operations betwe
genType const & v);
/// @}
}//namespace component_wise
}//namespace gtx
}//namespace glm
#include "component_wise.inl"
namespace glm{using namespace gtx::component_wise;}
#endif//glm_gtx_component_wise

4
glm/gtx/component_wise.inl
View File

@ -8,8 +8,7 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace gtx{
namespace component_wise
namespace gtx
{
template <typename genType>
GLM_FUNC_QUALIFIER typename genType::value_type compAdd(genType const & v)
@ -47,6 +46,5 @@ namespace component_wise
return result;
}
}//namespace component_wise
}//namespace gtx
}//namespace glm

14
glm/gtx/epsilon.hpp
View File

@ -2,7 +2,7 @@
// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2005-12-21
// Updated : 2006-11-13
// Updated : 2011-06-07
// Licence : This source is under MIT License
// File : glm/gtx/epsilon.hpp
///////////////////////////////////////////////////////////////////////////////////////////////////
@ -25,11 +25,10 @@
#endif
namespace glm{
namespace gtx{
namespace epsilon ///< GLM_GTX_epsilon extension: Comparison functions for a user defined epsilon values.
namespace gtx
{
/// \addtogroup gtx_epsilon
///@{
/// @addtogroup gtx_epsilon
/// @{
//! Returns the component-wise compare of |x - y| < epsilon.
//! From GLM_GTX_epsilon extension.
@ -47,13 +46,10 @@ namespace epsilon ///< GLM_GTX_epsilon extension: Comparison functions for a use
genTypeT const & y,
genTypeU const & epsilon);
///@}
}//namespace epsilon
/// @}
}//namespace gtx
}//namespace glm
#include "epsilon.inl"
namespace glm{using namespace gtx::epsilon;}
#endif//glm_gtx_epsilon

4
glm/gtx/epsilon.inl
View File

@ -2,14 +2,13 @@
// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2005-12-21
// Updated : 2006-01-16
// Updated : 2011-06-07
// Licence : This source is under MIT License
// File : glm/gtx/epsilon.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace gtx{
namespace epsilon{
template <typename genType>
GLM_FUNC_QUALIFIER bool equalEpsilon
@ -229,6 +228,5 @@ GLM_FUNC_QUALIFIER detail::tvec4<bool> notEqualEpsilon
abs(x.w - y.w) >= epsilon.w);
}
}//namespace epsilon
}//namespace gtx
}//namespace glm

8
glm/gtx/euler_angles.hpp
View File

@ -27,10 +27,9 @@
#endif
namespace glm{
namespace gtx{
namespace euler_angles ///< GLM_GTX_euler_angles extension: Build matrices from Euler angles.
namespace gtx
{
/// \addtogroup gtx_euler_angles
/// @addtogroup gtx_euler_angles
/// @{
//! Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X.
@ -130,12 +129,9 @@ namespace euler_angles ///< GLM_GTX_euler_angles extension: Build matrices from
detail::tmat4x4<T> orientate4(detail::tvec3<T> const & angles);
/// @}
}//namespace euler_angles
}//namespace gtx
}//namespace glm
#include "euler_angles.inl"
namespace glm{using namespace gtx::euler_angles;}
#endif//glm_gtx_euler_angles

2
glm/gtx/euler_angles.inl
View File

@ -9,7 +9,6 @@
namespace glm{
namespace gtx{
namespace euler_angles{
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleX
@ -244,6 +243,5 @@ GLM_FUNC_QUALIFIER detail::tmat4x4<valType> orientate4
return yawPitchRoll(angles.z, angles.x, angles.y);
}
}//namespace euler_angles
}//namespace gtx
}//namespace glm

8
glm/gtx/extend.hpp
View File

@ -21,10 +21,9 @@
#endif
namespace glm{
namespace gtx{
namespace extend ///< GLM_GTX_extend extension: Extend a position from a source to a position at a defined length.
namespace gtx
{
/// \addtogroup gtx_extend
/// @addtogroup gtx_extend
/// @{
//! Extends of Length the Origin position using the (Source - Origin) direction.
@ -36,12 +35,9 @@ namespace extend ///< GLM_GTX_extend extension: Extend a position from a source
typename genType::value_type const Length);
/// @}
}//namespace extend
}//namespace gtx
}//namespace glm
#include "extend.inl"
namespace glm{using namespace gtx::extend;}
#endif//glm_gtx_extend

2
glm/gtx/extend.inl
View File

@ -9,7 +9,6 @@
namespace glm{
namespace gtx{
namespace extend{
template <typename genType>
genType extend
@ -55,6 +54,5 @@ detail::tvec4<valType> extend
return Origin + (Source - Origin) * Distance;
}
}//namespace extend
}//namespace gtx
}//namespace glm

10
glm/gtx/extented_min_max.hpp
View File

@ -23,11 +23,10 @@
#endif
namespace glm{
namespace gtx{
namespace extented_min_max ///< GLM_GTX_extented_min_max extension: Min and max functions for 3 to 4 parameters.
namespace gtx
{
/// \addtogroup gtx_extented_min_max
///@{
/// @addtogroup gtx_extented_min_max
/// @{
//< Return the minimum component-wise values of 3 inputs
//< From GLM_GTX_extented_min_max extension
@ -164,12 +163,9 @@ namespace extented_min_max ///< GLM_GTX_extented_min_max extension: Min and max
C<T> const & w);
/// @}
}//namespace extented_min_max
}//namespace gtx
}//namespace glm
#include "extented_min_max.inl"
namespace glm{using namespace gtx::extented_min_max;}
#endif//glm_gtx_extented_min_max

4
glm/gtx/extented_min_max.inl
View File

@ -8,8 +8,7 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace gtx{
namespace extented_min_max
namespace gtx
{
template <typename T>
GLM_FUNC_QUALIFIER T min(
@ -177,6 +176,5 @@ namespace extented_min_max
return glm::max(glm::max(x, y), glm::max(z, w));
}
}//namespace extented_min_max
}//namespace gtx
}//namespace glm

6
glm/gtx/fast_exponential.hpp
View File

@ -23,8 +23,7 @@
#endif
namespace glm{
namespace gtx{
namespace fast_exponential ///< GLM_GTX_fast_exponential extension: Fast but less accurate implementations of exponential based functions.
namespace gtx
{
/// @addtogroup gtx_fast_exponential
/// @{
@ -69,12 +68,9 @@ namespace fast_exponential ///< GLM_GTX_fast_exponential extension: Fast but les
T fastLn(const T& x);
/// @}
}//namespace fast_exponential
}//namespace gtx
}//namespace glm
#include "fast_exponential.inl"
namespace glm{using namespace gtx::fast_exponential;}
#endif//glm_gtx_fast_exponential

6
glm/gtx/fast_exponential.inl
View File

@ -4,12 +4,11 @@
// Created : 2006-01-09
// Updated : 2006-01-09
// Licence : This source is under MIT License
// File : glm/gtx/fast_exponential.h
// File : glm/gtx/fast_exponential.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace gtx{
namespace fast_exponential
namespace gtx
{
// fastPow:
template <typename T>
@ -289,6 +288,5 @@ namespace fast_exponential
fastLog2(x.w));
}
}//namespace fast_exponential
}//namespace gtx
}//namespace glm

8
glm/gtx/fast_square_root.hpp
View File

@ -25,10 +25,9 @@
#endif
namespace glm{
namespace gtx{
namespace fast_square_root ///< GLM_GTX_fast_square_root extension: Fast but less accurate implementations of square root based functions.
namespace gtx
{
/// \addtogroup gtx_fast_square_root
/// @addtogroup gtx_fast_square_root
/// @{
//! Faster than the common sqrt function but less accurate.
@ -57,12 +56,9 @@ namespace fast_square_root ///< GLM_GTX_fast_square_root extension: Fast but le
genType fastNormalize(genType const & x);
/// @}
}// namespace fast_square_root
}// namespace gtx
}// namespace glm
#include "fast_square_root.inl"
namespace glm{using namespace gtx::fast_square_root;}
#endif//glm_gtx_fast_square_root

2
glm/gtx/fast_square_root.inl
View File

@ -9,7 +9,6 @@
namespace glm{
namespace gtx{
namespace fast_square_root{
// fastSqrt
template <typename genType>
@ -232,6 +231,5 @@ GLM_FUNC_QUALIFIER detail::tvec4<valType> fastNormalize
return x * fastInverseSqrt(sqr);
}
}//namespace fast_square_root
}//namespace gtx
}//namespace glm

8
glm/gtx/fast_trigonometry.hpp
View File

@ -21,10 +21,9 @@
#endif
namespace glm{
namespace gtx{
namespace fast_trigonometry ///< GLM_GTX_fast_trigonometry extension: Fast but less accurate implementations of trigonometric functions.
namespace gtx
{
/// \addtogroup gtx_fast_trigonometry
/// @addtogroup gtx_fast_trigonometry
/// @{
//! Faster than the common sin function but less accurate.
@ -70,12 +69,9 @@ namespace fast_trigonometry ///< GLM_GTX_fast_trigonometry extension: Fast but l
T fastAtan(const T& angle);
/// @}
}//namespace fast_trigonometry
}//namespace gtx
}//namespace glm
#include "fast_trigonometry.inl"
namespace glm{using namespace gtx::fast_trigonometry;}
#endif//glm_gtx_fast_trigonometry

4
glm/gtx/fast_trigonometry.inl
View File

@ -8,8 +8,7 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace gtx{
namespace fast_trigonometry
namespace gtx
{
// sin
template <typename T>
@ -267,6 +266,5 @@ namespace fast_trigonometry
fastAtan(x.w));
}
}//namespace fast_trigonometry
}//namespace gtx
}//namespace glm

10
glm/gtx/gradient_paint.hpp
View File

@ -22,12 +22,9 @@
#endif
namespace glm{
namespace gtx{
namespace gradient_paint ///< GLM_GTX_gradient_paint extension: Compute a radient gradient according section OpenVG 1.1 specifications, 9.3.2 Radial Gradients
namespace gtx
{
using namespace gtx::optimum_pow;
/// \addtogroup gtx_gradient_paint
/// @addtogroup gtx_gradient_paint
/// @{
template <typename valType>
@ -44,12 +41,9 @@ namespace gradient_paint ///< GLM_GTX_gradient_paint extension: Compute a radien
glm::detail::tvec2<valType> const & Position);
/// @}
}// namespace gradient_paint
}// namespace gtx
}// namespace glm
#include "gradient_paint.inl"
namespace glm{using namespace gtx::gradient_paint;}
#endif//glm_gtx_gradient_paint

2
glm/gtx/gradient_paint.inl
View File

@ -9,7 +9,6 @@
namespace glm{
namespace gtx{
namespace gradient_paint{
template <typename valType>
valType radialGradient(
@ -39,6 +38,5 @@ namespace gradient_paint{
return (Dist.x * (Position.x - Point0.x) + Dist.y * (Position.y - Point0.y)) / glm::dot(Dist, Dist);
}
}//namespace gradient_paint
}//namespace gtx
}//namespace glm

8
glm/gtx/handed_coordinate_space.hpp
View File

@ -21,10 +21,9 @@
#endif
namespace glm{
namespace gtx{
namespace handed_coordinate_space ///< GLM_GTX_handed_coordinate_space extension: To know if a set of three basis vectors defines a right or left-handed coordinate system.
namespace gtx
{
/// \addtogroup gtx_handed_coordinate_space
/// @addtogroup gtx_handed_coordinate_space
/// @{
//! Return if a trihedron right handed or not.
@ -44,12 +43,9 @@ namespace handed_coordinate_space ///< GLM_GTX_handed_coordinate_space extension
detail::tvec3<T> const & normal);
/// @}
}// namespace handed_coordinate_space
}// namespace gtx
}// namespace glm
#include "handed_coordinate_space.inl"
namespace glm{using namespace gtx::handed_coordinate_space;}
#endif//glm_gtx_handed_coordinate_space

4
glm/gtx/handed_coordinate_space.inl
View File

@ -8,8 +8,7 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace gtx{
namespace handed_coordinate_space
namespace gtx
{
template <typename T>
GLM_FUNC_QUALIFIER bool rightHanded(
@ -29,6 +28,5 @@ namespace handed_coordinate_space
return dot(cross(normal, tangent), binormal) < T(0);
}
}//namespace handed_coordinate_space
}//namespace gtx
}//namespace glm

8
glm/gtx/inertia.hpp
View File

@ -21,10 +21,9 @@
#endif
namespace glm{
namespace gtx{
namespace inertia ///< GLM_GTX_inertia extension: Create inertia matrices
namespace gtx
{
/// \addtogroup gtx_inertia
/// @addtogroup gtx_inertia
/// @{
//! Build an inertia matrix for a box.
@ -84,12 +83,9 @@ namespace inertia ///< GLM_GTX_inertia extension: Create inertia matrices
const T Radius);
/// @}
}// namespace inertia
}// namespace gtx
}// namespace glm
#include "inertia.inl"
namespace glm{using namespace gtx::inertia;}
#endif//glm_gtx_inertia

2
glm/gtx/inertia.inl
View File

@ -9,7 +9,6 @@
namespace glm{
namespace gtx{
namespace inertia{
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T> boxInertia3(
@ -98,6 +97,5 @@ namespace inertia{
return Result;
}
}//namespace inertia
}//namespace gtx
}//namespace glm

15
glm/gtx/int_10_10_10_2.hpp
View File

@ -22,26 +22,19 @@
#endif
namespace glm{
namespace gtx{
namespace int_10_10_10_2 ///< GLM_GTX_int_10_10_10_2 extension: Add support for integer for core functions
namespace gtx
{
using namespace gtx::raw_data;
/// \addtogroup gtx_int_10_10_10_2
///@{
/// @addtogroup gtx_int_10_10_10_2
/// @{
//! From GLM_GTX_int_10_10_10_2 extension.
//! Cast a vec4 to an u_10_10_10_2.
dword uint10_10_10_2_cast(glm::vec4 const & v);
///@}
}//namespace integer
/// @}
}//namespace gtx
}//namespace glm
#include "int_10_10_10_2.inl"
namespace glm{using namespace gtx::int_10_10_10_2;}
#endif//glm_gtx_int_10_10_10_2

12
glm/gtx/int_10_10_10_2.inl
View File

@ -9,13 +9,11 @@
namespace glm{
namespace gtx{
namespace int_10_10_10_2
{
GLM_FUNC_QUALIFIER dword uint10_10_10_2_cast(glm::vec4 const & v)
{
return dword(uint(v.x * 2047.f) << 0 | uint(v.y * 2047.f) << 10 | uint(v.z * 2047.f) << 20 | uint(v.w * 3.f) << 30);
}
}//namespace int_10_10_10_2
GLM_FUNC_QUALIFIER dword uint10_10_10_2_cast(glm::vec4 const & v)
{
return dword(uint(v.x * 2047.f) << 0 | uint(v.y * 2047.f) << 10 | uint(v.z * 2047.f) << 20 | uint(v.w * 3.f) << 30);
}
}//namespace gtx
}//namespace glm

8
glm/gtx/integer.hpp
View File

@ -21,10 +21,9 @@
#endif
namespace glm{
namespace gtx{
namespace integer ///< GLM_GTX_integer extension: Add support for integer for core functions
namespace gtx
{
/// \addtogroup gtx_integer
/// @addtogroup gtx_integer
/// @{
//! Returns x raised to the y power.
@ -45,12 +44,9 @@ namespace integer ///< GLM_GTX_integer extension: Add support for integer for co
genType factorial(genType const & x);
/// @}
}//namespace integer
}//namespace gtx
}//namespace glm
#include "integer.inl"
namespace glm{using namespace gtx::integer;}
#endif//glm_gtx_integer

4
glm/gtx/integer.inl
View File

@ -9,8 +9,7 @@
namespace glm{
namespace gtx{
namespace integer
{
// pow
GLM_FUNC_QUALIFIER int pow(int x, int y)
{
@ -86,6 +85,5 @@ namespace integer
factorial(x.w));
}
}//namespace integer
}//namespace gtx
}//namespace glm

8
glm/gtx/intersect.hpp
View File

@ -23,10 +23,9 @@
#endif
namespace glm{
namespace gtx{
namespace intersect ///< GLM_GTX_intersect extension: Add intersection functions
namespace gtx
{
/// \addtogroup gtx_intersect
/// @addtogroup gtx_intersect
/// @{
//! Compute the intersection of a ray and a triangle.
@ -62,12 +61,9 @@ namespace intersect ///< GLM_GTX_intersect extension: Add intersection functions
genType & position, genType & normal);
/// @}
}//namespace intersect
}//namespace gtx
}//namespace glm
#include "intersect.inl"
namespace glm{using namespace gtx::intersect;}
#endif//glm_gtx_intersect

2
glm/gtx/intersect.inl
View File

@ -12,7 +12,6 @@
namespace glm{
namespace gtx{
namespace intersect{
template <typename genType>
GLM_FUNC_QUALIFIER bool intersectRayTriangle
@ -196,6 +195,5 @@ GLM_FUNC_QUALIFIER bool intersectLineSphere
return false;
}
}//namespace intersect
}//namespace gtx
}//namespace glm

9
glm/gtx/log_base.hpp
View File

@ -21,10 +21,9 @@
#endif
namespace glm{
namespace gtx{
namespace log_base ///< GLM_GTX_log_base extension: Logarithm for any base. base can be a vector or a scalar.
namespace gtx
{
/// \addtogroup gtx_log_base
/// @addtogroup gtx_log_base
/// @{
//! Logarithm for any base.
@ -35,13 +34,9 @@ namespace log_base ///< GLM_GTX_log_base extension: Logarithm for any base. base
genType const & base);
/// @}
}//namespace extend
}//namespace gtx
}//namespace glm
#include "log_base.inl"
namespace glm{using namespace gtx::log_base;}
#endif//glm_gtx_log_base

2
glm/gtx/log_base.inl
View File

@ -9,7 +9,6 @@
namespace glm{
namespace gtx{
namespace log_base{
template <typename genType>
GLM_FUNC_QUALIFIER genType log(
@ -87,6 +86,5 @@ GLM_FUNC_QUALIFIER detail::tvec4<valType> log(
log(v.w, base.w));
}
}//namespace log_base
}//namespace gtx
}//namespace glm

6
glm/gtx/matrix_cross_product.hpp
View File

@ -21,8 +21,7 @@
#endif
namespace glm{
namespace gtx{
namespace matrix_cross_product ///< GLM_GTX_matrix_cross_product: Build cross product matrices
namespace gtx
{
/// \addtogroup gtx_matrix_cross_product
/// @{
@ -40,12 +39,9 @@ namespace matrix_cross_product ///< GLM_GTX_matrix_cross_product: Build cross pr
detail::tvec3<T> const & x);
/// @}
}//namespace matrix_cross_product
}//namespace gtx
}//namespace glm
#include "matrix_cross_product.inl"
namespace glm{using namespace gtx::matrix_cross_product;}
#endif//glm_gtx_matrix_cross_product

54
glm/gtx/matrix_cross_product.inl
View File

@ -9,36 +9,34 @@
namespace glm{
namespace gtx{
namespace matrix_cross_product
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T> matrixCross3(
detail::tvec3<T> const & x)
{
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T> matrixCross3(
detail::tvec3<T> const & x)
{
detail::tmat3x3<T> Result(T(0));
Result[0][1] = x.z;
Result[1][0] = -x.z;
Result[0][2] = -x.y;
Result[2][0] = x.y;
Result[1][2] = x.x;
Result[2][1] = -x.x;
return Result;
}
detail::tmat3x3<T> Result(T(0));
Result[0][1] = x.z;
Result[1][0] = -x.z;
Result[0][2] = -x.y;
Result[2][0] = x.y;
Result[1][2] = x.x;
Result[2][1] = -x.x;
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T> matrixCross4(
detail::tvec3<T> const & x)
{
detail::tmat4x4<T> Result(T(0));
Result[0][1] = x.z;
Result[1][0] = -x.z;
Result[0][2] = -x.y;
Result[2][0] = x.y;
Result[1][2] = x.x;
Result[2][1] = -x.x;
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T> matrixCross4(
detail::tvec3<T> const & x)
{
detail::tmat4x4<T> Result(T(0));
Result[0][1] = x.z;
Result[1][0] = -x.z;
Result[0][2] = -x.y;
Result[2][0] = x.y;
Result[1][2] = x.x;
Result[2][1] = -x.x;
return Result;
}
}//namespace matrix_cross_product
}//namespace gtx
}//namespace glm

6
glm/gtx/matrix_interpolation.hpp
View File

@ -24,8 +24,7 @@
#endif
namespace glm{
namespace gtx{
namespace matrix_interpolation ///< GLM_GTX_matrix_interpolation extension: Add transformation matrices
namespace gtx
{
/// \addtogroup gtx_matrix_interpolation
/// @{
@ -55,12 +54,9 @@ namespace matrix_interpolation ///< GLM_GTX_matrix_interpolation extension: Add
T const delta);
/// @}
}//namespace matrix_interpolation
}//namespace gtx
}//namespace glm
#include "matrix_interpolation.inl"
namespace glm{using namespace gtx::matrix_interpolation;}
#endif//glm_gtx_transform

4
glm/gtx/matrix_interpolation.inl
View File

@ -9,8 +9,7 @@
namespace glm{
namespace gtx{
namespace matrix_interpolation
{
template <typename T>
GLM_FUNC_QUALIFIER void axisAngle(
detail::tmat4x4<T> const & mat,
@ -112,6 +111,5 @@ namespace matrix_interpolation
return out;
}
}//namespace transform
}//namespace gtx
}//namespace glm

6
glm/gtx/matrix_major_storage.hpp
View File

@ -21,8 +21,7 @@
#endif
namespace glm{
namespace gtx{
namespace matrix_major_storage ///< GLM_GTX_matrix_major_storage: Build matrices with specific matrix order, row or column
namespace gtx
{
/// \addtogroup gtx_matrix_major_storage
/// @{
@ -112,12 +111,9 @@ namespace matrix_major_storage ///< GLM_GTX_matrix_major_storage: Build matrices
const detail::tmat4x4<T>& m);
/// @}
}//namespace matrix_major_storage
}//namespace gtx
}//namespace glm
#include "matrix_major_storage.inl"
namespace glm{using namespace gtx::matrix_major_storage;}
#endif//glm_gtx_matrix_major_storage

4
glm/gtx/matrix_major_storage.inl
View File

@ -9,8 +9,7 @@
namespace glm{
namespace gtx{
namespace matrix_major_storage
{
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat2x2<T> rowMajor2(
const detail::tvec2<T>& v1,
@ -171,6 +170,5 @@ namespace matrix_major_storage
return detail::tmat4x4<T>(m);
}
}//namespace matrix_major_storage
}//namespace gtx
}//namespace glm

4
glm/gtx/matrix_operation.hpp
View File

@ -21,8 +21,7 @@
#endif
namespace glm{
namespace gtx{
namespace matrix_operation ///< GLM_GTX_matrix_operation: Build diagonal matrices
namespace gtx
{
/// \addtogroup gtx_matrix_operation
/// @{
@ -82,7 +81,6 @@ namespace matrix_operation ///< GLM_GTX_matrix_operation: Build diagonal matrice
detail::tvec4<valType> const & v);
/// @}
}//namespace matrix_operation
}//namespace gtx
}//namespace glm

4
glm/gtx/matrix_operation.inl
View File

@ -9,8 +9,7 @@
namespace glm{
namespace gtx{
namespace matrix_operation
{
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat2x2<valType> diagonal2x2
(
@ -124,6 +123,5 @@ namespace matrix_operation
return Result;
}
}//namespace matrix_operation
}//namespace gtx
}//namespace glm

6
glm/gtx/matrix_query.hpp
View File

@ -21,8 +21,7 @@
#endif
namespace glm{
namespace gtx{
namespace matrix_query ///< GLM_GTX_matrix_query: Query to evaluate matrix properties
namespace gtx
{
/// \addtogroup gtx_matrix_query
/// @{
@ -84,12 +83,9 @@ namespace matrix_query ///< GLM_GTX_matrix_query: Query to evaluate matrix prope
const typename genType::value_type epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
/// @}
}//namespace matrix_query
}//namespace gtx
}//namespace glm
#include "matrix_query.inl"
namespace glm{using namespace gtx::matrix_query;}
#endif//glm_gtx_matrix_query

4
glm/gtx/matrix_query.inl
View File

@ -11,8 +11,7 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace gtx{
namespace matrix_query
namespace gtx
{
template<typename T>
GLM_FUNC_QUALIFIER bool isNull(
@ -139,6 +138,5 @@ namespace matrix_query
return result;
}
}//namespace matrix_query
}//namespace gtx
}//namespace glm

10
glm/gtx/mixed_product.hpp
View File

@ -21,13 +21,12 @@
#endif
namespace glm{
namespace gtx{
namespace mixed_product ///< GLM_GTX_mixed_product extension: Mixed product of 3 vectors.
namespace gtx
{
/// \addtogroup gtx_mixed_product
/// @addtogroup gtx_mixed_product
/// @{
//! \brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension)
/// @brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension)
template <typename valType>
valType mixedProduct(
detail::tvec3<valType> const & v1,
@ -35,12 +34,9 @@ namespace mixed_product ///< GLM_GTX_mixed_product extension: Mixed product of 3
detail::tvec3<valType> const & v3);
/// @}
}// namespace mixed_product
}// namespace gtx
}// namespace glm
#include "mixed_product.inl"
namespace glm{using namespace gtx::mixed_product;}
#endif//glm_gtx_mixed_product

16
glm/gtx/mixed_product.inl
View File

@ -10,18 +10,14 @@
namespace glm{
namespace gtx{
namespace mixed_product
template <typename valType>
GLM_FUNC_QUALIFIER valType mixedProduct(
detail::tvec3<valType> const & v1,
detail::tvec3<valType> const & v2,
detail::tvec3<valType> const & v3)
{
template <typename valType>
GLM_FUNC_QUALIFIER valType mixedProduct(
detail::tvec3<valType> const & v1,
detail::tvec3<valType> const & v2,
detail::tvec3<valType> const & v3)
{
return dot(cross(v1, v2), v3);
}
return dot(cross(v1, v2), v3);
}
//namespace mixed_product
}//namespace gtx
}//namespace glm

8
glm/gtx/multiple.hpp
View File

@ -21,10 +21,9 @@
#endif
namespace glm{
namespace gtx{
namespace multiple ///< GLM_GTX_multiple: Find the closest number of a number multiple of other number.
namespace gtx
{
/// \addtogroup gtx_multiple
/// @addtogroup gtx_multiple
/// @{
//! Higher Multiple number of Source.
@ -42,12 +41,9 @@ namespace multiple ///< GLM_GTX_multiple: Find the closest number of a number mu
genType const & Multiple);
/// @}
}//namespace multiple
}//namespace gtx
}//namespace glm
#include "multiple.inl"
namespace glm{using namespace gtx::multiple;}
#endif//glm_gtx_multiple

6
glm/gtx/multiple.inl
View File

@ -2,7 +2,7 @@
// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2009-10-26
// Updated : 2009-10-26
// Updated : 2011-06-07
// Licence : This source is under MIT License
// File : glm/gtx/multiple.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
@ -11,8 +11,7 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace gtx{
namespace multiple
namespace gtx
{
//////////////////////
// higherMultiple
@ -186,6 +185,5 @@ namespace multiple
return Result;
}
}//namespace multiple
}//namespace gtx
}//namespace glm

8
glm/gtx/noise.hpp
View File

@ -26,10 +26,9 @@
#endif
namespace glm{
namespace gtx{
namespace noise ///< GLM_GTX_noise extension: Comparison functions for a user defined epsilon values.
namespace gtx
{
/// \addtogroup gtx_noise
/// @addtogroup gtx_noise
/// @{
//! Classic perlin noise.
@ -52,12 +51,9 @@ namespace noise ///< GLM_GTX_noise extension: Comparison functions for a user de
vecType<T> const & p);
/// @}
}//namespace noise
}//namespace gtx
}//namespace glm
#include "noise.inl"
namespace glm{using namespace gtx::noise;}
#endif//glm_gtx_noise

9
glm/gtx/noise.inl
View File

@ -15,8 +15,9 @@
// - GLM core
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm
{
namespace glm{
namespace gtx{
template <typename T>
GLM_FUNC_QUALIFIER T permute(T const & x)
{
@ -57,9 +58,6 @@ namespace glm
return detail::tvec4<T>(pXYZ, pW);
}
namespace gtx{
namespace noise
{
// Classic Perlin noise
template <typename T>
GLM_FUNC_QUALIFIER T perlin(detail::tvec2<T> const & P)
@ -787,6 +785,5 @@ namespace noise
dot(m1 * m1, detail::tvec2<T>(dot(p3, x3), dot(p4, x4))));
}
}//namespace noise
}//namespace gtx
}//namespace glm

8
glm/gtx/norm.hpp
View File

@ -26,10 +26,9 @@
#endif
namespace glm{
namespace gtx{
namespace norm ///< GLM_GTX_norm extension: Various way to compute vector norms.
namespace gtx
{
/// \addtogroup gtx_norm
/// @addtogroup gtx_norm
/// @{
//! Returns the squared length of x.
@ -132,12 +131,9 @@ namespace norm ///< GLM_GTX_norm extension: Various way to compute vector norms.
unsigned int Depth);
/// @}
}//namespace norm
}//namespace gtx
}//namespace glm
#include "norm.inl"
namespace glm{using namespace gtx::norm;}
#endif//glm_gtx_norm

4
glm/gtx/norm.inl
View File

@ -8,8 +8,7 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace gtx{
namespace norm
namespace gtx
{
template <typename T>
GLM_FUNC_QUALIFIER T length2(
@ -125,6 +124,5 @@ namespace norm
return pow(pow(v.x, T(Depth)) + pow(v.y, T(Depth)) + pow(v.z, T(Depth)), T(1) / T(Depth));
}
}//namespace norm
}//namespace gtx
}//namespace glm

8
glm/gtx/normal.hpp
View File

@ -21,10 +21,9 @@
#endif
namespace glm{
namespace gtx{
namespace normal ///< GLM_GTX_normal extension: Compute the normal of a triangle.
namespace gtx
{
/// \addtogroup gtx_normal
/// @addtogroup gtx_normal
/// @{
//! Computes triangle normal from triangle points.
@ -36,12 +35,9 @@ namespace normal ///< GLM_GTX_normal extension: Compute the normal of a triangle
detail::tvec3<T> const & p3);
/// @}
}//namespace normal
}//namespace gtx
}//namespace glm
#include "normal.inl"
namespace glm{using namespace gtx::normal;}
#endif//glm_gtx_normal

24
glm/gtx/normal.inl
View File

@ -2,26 +2,24 @@
// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2005-12-21
// Updated : 2005-12-21
// Updated : 2011-06-07
// Licence : This source is under MIT License
// File : glm/gtx/normal.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace gtx{
namespace normal{
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> triangleNormal
(
detail::tvec3<T> const & p1,
detail::tvec3<T> const & p2,
detail::tvec3<T> const & p3
)
{
return normalize(cross(p1 - p2, p1 - p3));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> triangleNormal
(
detail::tvec3<T> const & p1,
detail::tvec3<T> const & p2,
detail::tvec3<T> const & p3
)
{
return normalize(cross(p1 - p2, p1 - p3));
}
}//namespace normal
}//namespace gtx
}//namespace glm

10
glm/gtx/normalize_dot.hpp
View File

@ -23,12 +23,9 @@
#endif
namespace glm{
namespace gtx{
namespace normalize_dot ///< GLM_GTX_normalize_dot extension: Dot product of vectors that need to be normalize with a single square root.
namespace gtx
{
using namespace gtx::fast_square_root;
/// \addtogroup gtx_normalize_dot
/// @addtogroup gtx_normalize_dot
/// @{
//! Normalize parameters and returns the dot product of x and y.
@ -48,12 +45,9 @@ namespace normalize_dot ///< GLM_GTX_normalize_dot extension: Dot product of vec
genType const & y);
/// @}
}//namespace normalize_dot
}//namespace gtx
}//namespace glm
#include "normalize_dot.inl"
namespace glm{using namespace gtx::normalize_dot;}
#endif//glm_gtx_normalize_dot

2
glm/gtx/normalize_dot.inl
View File

@ -9,7 +9,6 @@
namespace glm{
namespace gtx{
namespace normalize_dot{
template <typename genType>
GLM_FUNC_QUALIFIER genType normalizeDot
@ -115,6 +114,5 @@ GLM_FUNC_QUALIFIER valType fastNormalizeDot
glm::dot(y, y));
}
}//namespace normalize_dot
}//namespace gtx
}//namespace glm

8
glm/gtx/number_precision.hpp
View File

@ -24,13 +24,12 @@
#endif
namespace glm{
namespace gtx{
namespace number_precision ///< GLM_GTX_number_precision extension: Defined size types.
namespace gtx
{
/////////////////////////////
// Unsigned int vector types
/// \addtogroup gtx_number_precision
/// @addtogroup gtx_number_precision
/// @{
typedef u8 u8vec1; //!< \brief 8bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
@ -56,12 +55,9 @@ namespace number_precision ///< GLM_GTX_number_precision extension: Defined size
typedef f64 f64mat1x1; //!< \brief Double-precision floating-point scalar. (from GLM_GTX_number_precision extension)
/// @}
}//namespace number_precision
}//namespace gtx
}//namespace glm
#include "number_precision.inl"
namespace glm{using namespace gtx::number_precision;}
#endif//glm_gtx_number_precision

8
glm/gtx/ocl_type.hpp
View File

@ -21,13 +21,12 @@
#endif
namespace glm{
namespace gtx{
namespace ocl_type ///< GLM_GTX_ocl_type extension: OpenCL types.
namespace gtx
{
///////////////////////////
// Scalar types
/// \addtogroup gtx_ocl_type
/// @addtogroup gtx_ocl_type
/// @{
typedef detail::int8 cl_char; //!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
@ -99,12 +98,9 @@ namespace ocl_type ///< GLM_GTX_ocl_type extension: OpenCL types.
typedef detail::tvec4<detail::float32> cl_float4; //!< \brief Single-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
/// @}
}//namespace ocl_type
}//namespace gtx
}//namespace glm
#include "ocl_type.inl"
namespace glm{using namespace gtx::ocl_type;}
#endif//glm_gtx_ocl_type

8
glm/gtx/optimum_pow.hpp
View File

@ -21,10 +21,9 @@
#endif
namespace glm{
namespace gtx{
namespace optimum_pow ///< GLM_GTX_optimum_pow extension: Integer exponentiation of power functions.
namespace gtx
{
/// \addtogroup gtx_optimum_pow
/// @addtogroup gtx_optimum_pow
/// @{
//! Returns x raised to the power of 2.
@ -59,12 +58,9 @@ namespace optimum_pow ///< GLM_GTX_optimum_pow extension: Integer exponentiation
detail::tvec4<bool> powOfTwo(const detail::tvec4<int>& x);
/// @}
}//namespace optimum_pow
}//namespace gtx
}//namespace glm
#include "optimum_pow.inl"
namespace glm{using namespace gtx::optimum_pow;}
#endif//glm_gtx_optimum_pow

2
glm/gtx/optimum_pow.inl
View File

@ -9,7 +9,6 @@
namespace glm{
namespace gtx{
namespace optimum_pow{
template <typename genType>
GLM_FUNC_QUALIFIER genType pow2(const genType& x)
@ -58,6 +57,5 @@ namespace optimum_pow{
powOfTwo(x.w));
}
}//namespace optimum_pow
}//namespace gtx
}//namespace glm

8
glm/gtx/orthonormalize.hpp
View File

@ -21,10 +21,9 @@
#endif
namespace glm{
namespace gtx{
namespace orthonormalize ///< GLM_GTX_orthonormalize extension: Orthonormalize matrices.
namespace gtx
{
/// \addtogroup gtx_orthonormalize
/// @addtogroup gtx_orthonormalize
/// @{
//! Returns the orthonormalized matrix of m.
@ -41,12 +40,9 @@ namespace orthonormalize ///< GLM_GTX_orthonormalize extension: Orthonormalize m
const detail::tvec3<T>& y);
/// @}
}//namespace orthonormalize
}//namespace gtx
}//namespace glm
#include "orthonormalize.inl"
namespace glm{using namespace gtx::orthonormalize;}
#endif//glm_gtx_orthonormalize

2
glm/gtx/orthonormalize.inl
View File

@ -9,7 +9,6 @@
namespace glm{
namespace gtx{
namespace orthonormalize{
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T> orthonormalize
@ -43,7 +42,6 @@ namespace orthonormalize{
return normalize(x - y * dot(y, x));
}
}//namespace orthonormalize
}//namespace gtx
}//namespace glm

8
glm/gtx/perpendicular.hpp
View File

@ -23,10 +23,9 @@
#endif
namespace glm{
namespace gtx{
namespace perpendicular ///< GLM_GTX_perpendicular extension: Perpendicular of a vector from other one
namespace gtx
{
/// \addtogroup gtx_perpendicular
/// @addtogroup gtx_perpendicular
/// @{
//! Projects x a perpendicular axis of Normal.
@ -51,12 +50,9 @@ namespace perpendicular ///< GLM_GTX_perpendicular extension: Perpendicular of a
detail::tvec4<T> const & Normal);
/// @}
}//namespace perpendicular
}//namespace gtx
}//namespace glm
#include "perpendicular.inl"
namespace glm{using namespace gtx::perpendicular;}
#endif//glm_gtx_perpendicular

2
glm/gtx/perpendicular.inl
View File

@ -9,7 +9,6 @@
namespace glm{
namespace gtx{
namespace perpendicular{
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> perp(
@ -35,6 +34,5 @@ GLM_FUNC_QUALIFIER detail::tvec4<T> perp(
return x - projection::proj(x, Normal);
}
}//namespace perpendicular
}//namespace gtx
}//namespace glm

8
glm/gtx/polar_coordinates.hpp
View File

@ -21,10 +21,9 @@
#endif
namespace glm{
namespace gtx{
namespace polar_coordinates ///< GLM_GTX_polar_coordinates extension: Conversion from Euclidean space to polar space and revert.
namespace gtx
{
/// \addtogroup gtx_polar_coordinates
/// @addtogroup gtx_polar_coordinates
/// @{
//! Convert Euclidean to Polar coordinates, x is the xz distance, y, the latitude and z the longitude.
@ -38,12 +37,9 @@ namespace polar_coordinates ///< GLM_GTX_polar_coordinates extension: Conversion
detail::tvec3<T> euclidean(const detail::tvec3<T>& polar);
/// @}
}//namespace polar_coordinates
}//namespace gtx
}//namespace glm
#include "polar_coordinates.inl"
namespace glm{using namespace gtx::polar_coordinates;}
#endif//glm_gtx_polar_coordinates

4
glm/gtx/polar_coordinates.inl
View File

@ -8,8 +8,7 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace gtx{
namespace polar_coordinates
namespace gtx
{
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> polar(
@ -37,6 +36,5 @@ namespace polar_coordinates
cos(latitude) * cos(longitude));
}
}//namespace polar_coordinates
}//namespace gtx
}//namespace glm

8
glm/gtx/projection.hpp
View File

@ -21,10 +21,9 @@
#endif
namespace glm{
namespace gtx{
namespace projection ///< GLM_GTX_projection extension: Projection of a vector to other one
namespace gtx
{
/// \addtogroup gtx_projection
/// @addtogroup gtx_projection
/// @{
//! Projects x on Normal.
@ -49,12 +48,9 @@ namespace projection ///< GLM_GTX_projection extension: Projection of a vector t
detail::tvec4<T> const & Normal);
/// @}
}//namespace projection
}//namespace gtx
}//namespace glm
#include "projection.inl"
namespace glm{using namespace gtx::projection;}
#endif//glm_gtx_projection

2
glm/gtx/projection.inl
View File

@ -9,7 +9,6 @@
namespace glm{
namespace gtx{
namespace projection{
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> proj(
@ -35,6 +34,5 @@ GLM_FUNC_QUALIFIER detail::tvec4<T> proj(
return glm::dot(x, Normal) / glm::dot(Normal, Normal) * Normal;
}
}//namespace projection
}//namespace gtx
}//namespace glm

10
glm/gtx/quaternion.hpp
View File

@ -26,11 +26,10 @@
#endif
namespace glm{
namespace gtx{
namespace quaternion ///< GLM_GTX_quaternion extension: Quaternion types and functions
namespace gtx
{
/// \addtogroup gtx_quaternion
///@{
/// @addtogroup gtx_quaternion
/// @{
//! Compute a cross product between a quaternion and a vector.
//! From GLM_GTX_quaternion extension.
@ -204,12 +203,9 @@ namespace quaternion ///< GLM_GTX_quaternion extension: Quaternion types and fun
T const & a);
/// @}
}//namespace quaternion
}//namespace gtx
}//namespace glm
#include "quaternion.inl"
namespace glm{using namespace gtx::quaternion;}
#endif//glm_gtx_quaternion

4
glm/gtx/quaternion.inl
View File

@ -10,8 +10,7 @@
#include <limits>
namespace glm{
namespace gtx{
namespace quaternion
namespace gtx
{
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<valType> cross
@ -298,6 +297,5 @@ namespace quaternion
return glm::normalize(x * (T(1) - a) + (y * a));
}
}//namespace quaternion
}//namespace gtx
}//namespace glm

8
glm/gtx/random.hpp
View File

@ -24,10 +24,9 @@
#endif
namespace glm{
namespace gtx{
namespace random ///< GLM_GTX_random extension: Generate random number from various distribution methods
namespace gtx
{
/// \addtogroup gtx_random
/// @addtogroup gtx_random
/// @{
//! Generate a random number in the interval [-1, 1], according a linear distribution.
@ -78,12 +77,9 @@ namespace random ///< GLM_GTX_random extension: Generate random number from vari
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 random
}//namespace gtx
}//namespace glm
#include "random.inl"
namespace glm{using namespace gtx::random;}
#endif//glm_gtx_random

4
glm/gtx/random.inl
View File

@ -11,8 +11,7 @@
#include <cassert>
namespace glm{
namespace gtx{
namespace random
namespace gtx
{
template <>
GLM_FUNC_QUALIFIER float signedRand1()
@ -531,6 +530,5 @@ namespace random
gaussRand1(mean.w, std_deviation.w));
}
}//namespace random
}//namespace gtx
}//namespace glm

11
glm/gtx/raw_data.hpp
View File

@ -22,11 +22,10 @@
#endif
namespace glm{
namespace gtx{
namespace raw_data ///< GLM_GTX_raw_data extension: Projection of a vector to other one
namespace gtx
{
/// \addtogroup gtx_raw_data
///@{
/// @addtogroup gtx_raw_data
/// @{
//! Type for byte numbers.
//! From GLM_GTX_raw_data extension.
@ -44,13 +43,11 @@ namespace raw_data ///< GLM_GTX_raw_data extension: Projection of a vector to ot
//! From GLM_GTX_raw_data extension.
typedef uint64 qword;
///@}
/// @}
}// namespace raw_data
}// namespace gtx
}// namespace glm
#include "raw_data.inl"
namespace glm{using namespace gtx::raw_data;}
#endif//glm_gtx_raw_data

8
glm/gtx/reciprocal.hpp
View File

@ -18,10 +18,9 @@
#endif
namespace glm{
namespace gtx{
namespace reciprocal ///< GLM_GTX_reciprocal extension: Define secant, cosecant and cotangent functions.
namespace gtx
{
/// \addtogroup gtx_reciprocal
/// @addtogroup gtx_reciprocal
/// @{
//! Secant function.
@ -88,12 +87,9 @@ namespace reciprocal ///< GLM_GTX_reciprocal extension: Define secant, cosecant
genType acoth(genType const & x);
/// @}
}//namespace reciprocal
}//namespace gtx
}//namespace glm
#include "reciprocal.inl"
namespace glm{using namespace gtx::reciprocal;}
#endif//glm_gtx_reciprocal

2
glm/gtx/reciprocal.inl
View File

@ -9,7 +9,6 @@
namespace glm{
namespace gtx{
namespace reciprocal{
// sec
template <typename genType>
@ -588,6 +587,5 @@ GLM_FUNC_QUALIFIER detail::tvec4<valType> acoth
acoth(x.w));
}
}//namespace reciprocal
}//namespace gtx
}//namespace glm

10
glm/gtx/rotate_vector.hpp
View File

@ -22,12 +22,9 @@
#endif
namespace glm{
namespace gtx{
namespace rotate_vector ///< GLM_GTX_rotate_vector extension: Function to directly rotate a vector
namespace gtx
{
using namespace transform;
/// \addtogroup gtx_rotate_vector
/// @addtogroup gtx_rotate_vector
/// @{
//! Rotate a two dimensional vector.
@ -103,12 +100,9 @@ namespace rotate_vector ///< GLM_GTX_rotate_vector extension: Function to direct
detail::tvec3<T> const & Up);
/// @}
}//namespace rotate_vector
}//namespace gtx
}//namespace glm
#include "rotate_vector.inl"
namespace glm{using namespace gtx::rotate_vector;}
#endif//glm_gtx_rotate_vector

4
glm/gtx/rotate_vector.inl
View File

@ -9,8 +9,7 @@
namespace glm{
namespace gtx{
namespace rotate_vector
{
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> rotate(
detail::tvec2<T> const & v,
@ -144,6 +143,5 @@ namespace rotate_vector
return glm::gtx::transform::rotate(Angle, RotationAxis);
}
}//namespace rotate_vector
}//namespace gtx
}//namespace glm

10
glm/gtx/simd_mat4.hpp
View File

@ -128,13 +128,12 @@ namespace detail
fmat4x4SIMD const operator++ (fmat4x4SIMD const & m, int);
}//namespace detail
namespace gtx{
namespace simd_mat4 ///< GLM_GTX_simd_mat4 extension: SIMD implementation of mat4 type.
namespace gtx
{
typedef detail::fmat4x4SIMD simdMat4;
/// \addtogroup gtx_simd_mat4
///@{
/// @addtogroup gtx_simd_mat4
/// @{
//! Convert a simdMat4 to a mat4.
//! (From GLM_GTX_simd_mat4 extension)
@ -172,12 +171,9 @@ namespace simd_mat4 ///< GLM_GTX_simd_mat4 extension: SIMD implementation of mat
detail::fmat4x4SIMD const & m);
/// @}
}// namespace simd_mat4
}// namespace gtx
}// namespace glm
#include "simd_mat4.inl"
namespace glm{using namespace gtx::simd_mat4;}
#endif//glm_gtx_simd_mat4

6
glm/gtx/simd_mat4.inl
View File

@ -234,8 +234,7 @@ namespace detail
}//namespace detail
namespace gtx{
namespace simd_mat4
namespace gtx
{
GLM_FUNC_QUALIFIER detail::tmat4x4<float> mat4_cast
(
@ -303,7 +302,6 @@ namespace simd_mat4
detail::sse_inverse_ps(&m[0].Data, &result[0].Data);
return result;
}
}//namespace simd_mat4
}//namespace gtx
}//namespace gtx
}//namespace glm

10
glm/gtx/simd_vec4.hpp
View File

@ -111,13 +111,12 @@ namespace detail
};
}//namespace detail
namespace gtx{
namespace simd_vec4 ///< GLM_GTX_simd_vec4 extension: SIMD implementation of vec4 type.
namespace gtx
{
typedef glm::detail::fvec4SIMD simdVec4;
/// \addtogroup gtx_simd_vec4
///@{
/// @addtogroup gtx_simd_vec4
/// @{
//! Convert a simdVec4 to a vec4.
//! (From GLM_GTX_simd_vec4 extension)
@ -463,12 +462,9 @@ namespace simd_vec4 ///< GLM_GTX_simd_vec4 extension: SIMD implementation of vec
detail::fvec4SIMD const & x);
/// @}
}//namespace simd_vec4
}//namespace gtx
}//namespace glm
#include "simd_vec4.inl"
namespace glm{using namespace gtx::simd_vec4;}
#endif//glm_gtx_simd_vec4

15
glm/gtx/simd_vec4.inl
View File

@ -7,10 +7,9 @@
// File : glm/gtx/simd_vec4.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm
namespace glm{
namespace detail
{
namespace detail
{
template <int Value>
struct mask
{
@ -265,11 +264,10 @@ namespace glm
return fvec4SIMD(_mm_sub_ps(v.Data, glm::detail::one));
}
}//namespace detail
}//namespace detail
namespace gtx{
namespace gtx{
namespace simd_vec4
{
GLM_FUNC_QUALIFIER detail::tvec4<float> vec4_cast
(
detail::fvec4SIMD const & x
@ -725,6 +723,5 @@ namespace glm
return _mm_rsqrt_ps(x.Data);
}
}//namespace simd_vec4
}//namespace gtx
}//namespace gtx
}//namespace glm

10
glm/gtx/simplex.hpp
View File

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