From 06cc480baac5c652a308fe0a5c25b46691205d3c Mon Sep 17 00:00:00 2001 From: Christophe Riccio Date: Tue, 7 Jun 2011 11:28:11 +0100 Subject: [PATCH] Removed gtx extension namespace --- glm/gtx/associated_min_max.hpp | 6 +--- glm/gtx/associated_min_max.inl | 6 ++-- glm/gtx/bit.hpp | 6 +--- glm/gtx/bit.inl | 2 -- glm/gtx/closest_point.hpp | 6 +--- glm/gtx/closest_point.inl | 2 -- glm/gtx/color_cast.hpp | 8 +---- glm/gtx/color_space.hpp | 6 +--- glm/gtx/color_space.inl | 4 +-- glm/gtx/color_space_YCoCg.hpp | 6 +--- glm/gtx/color_space_YCoCg.inl | 2 -- glm/gtx/compatibility.hpp | 12 +++---- glm/gtx/component_wise.hpp | 8 ++--- glm/gtx/component_wise.inl | 4 +-- glm/gtx/epsilon.hpp | 14 +++----- glm/gtx/epsilon.inl | 4 +-- glm/gtx/euler_angles.hpp | 8 ++--- glm/gtx/euler_angles.inl | 2 -- glm/gtx/extend.hpp | 8 ++--- glm/gtx/extend.inl | 2 -- glm/gtx/extented_min_max.hpp | 10 ++---- glm/gtx/extented_min_max.inl | 4 +-- glm/gtx/fast_exponential.hpp | 6 +--- glm/gtx/fast_exponential.inl | 6 ++-- glm/gtx/fast_square_root.hpp | 8 ++--- glm/gtx/fast_square_root.inl | 2 -- glm/gtx/fast_trigonometry.hpp | 8 ++--- glm/gtx/fast_trigonometry.inl | 4 +-- glm/gtx/gradient_paint.hpp | 10 ++---- glm/gtx/gradient_paint.inl | 2 -- glm/gtx/handed_coordinate_space.hpp | 8 ++--- glm/gtx/handed_coordinate_space.inl | 4 +-- glm/gtx/inertia.hpp | 8 ++--- glm/gtx/inertia.inl | 2 -- glm/gtx/int_10_10_10_2.hpp | 15 +++----- glm/gtx/int_10_10_10_2.inl | 10 +++--- glm/gtx/integer.hpp | 8 ++--- glm/gtx/integer.inl | 4 +-- glm/gtx/intersect.hpp | 8 ++--- glm/gtx/intersect.inl | 2 -- glm/gtx/log_base.hpp | 9 ++--- glm/gtx/log_base.inl | 2 -- glm/gtx/matrix_cross_product.hpp | 6 +--- glm/gtx/matrix_cross_product.inl | 54 ++++++++++++++--------------- glm/gtx/matrix_interpolation.hpp | 6 +--- glm/gtx/matrix_interpolation.inl | 4 +-- glm/gtx/matrix_major_storage.hpp | 6 +--- glm/gtx/matrix_major_storage.inl | 4 +-- glm/gtx/matrix_operation.hpp | 4 +-- glm/gtx/matrix_operation.inl | 4 +-- glm/gtx/matrix_query.hpp | 6 +--- glm/gtx/matrix_query.inl | 4 +-- glm/gtx/mixed_product.hpp | 10 ++---- glm/gtx/mixed_product.inl | 16 ++++----- glm/gtx/multiple.hpp | 8 ++--- glm/gtx/multiple.inl | 6 ++-- glm/gtx/noise.hpp | 8 ++--- glm/gtx/noise.inl | 9 ++--- glm/gtx/norm.hpp | 8 ++--- glm/gtx/norm.inl | 4 +-- glm/gtx/normal.hpp | 8 ++--- glm/gtx/normal.inl | 24 ++++++------- glm/gtx/normalize_dot.hpp | 10 ++---- glm/gtx/normalize_dot.inl | 2 -- glm/gtx/number_precision.hpp | 8 ++--- glm/gtx/ocl_type.hpp | 8 ++--- glm/gtx/optimum_pow.hpp | 8 ++--- glm/gtx/optimum_pow.inl | 2 -- glm/gtx/orthonormalize.hpp | 8 ++--- glm/gtx/orthonormalize.inl | 2 -- glm/gtx/perpendicular.hpp | 8 ++--- glm/gtx/perpendicular.inl | 2 -- glm/gtx/polar_coordinates.hpp | 8 ++--- glm/gtx/polar_coordinates.inl | 4 +-- glm/gtx/projection.hpp | 8 ++--- glm/gtx/projection.inl | 2 -- glm/gtx/quaternion.hpp | 10 ++---- glm/gtx/quaternion.inl | 4 +-- glm/gtx/random.hpp | 8 ++--- glm/gtx/random.inl | 4 +-- glm/gtx/raw_data.hpp | 11 +++--- glm/gtx/reciprocal.hpp | 8 ++--- glm/gtx/reciprocal.inl | 2 -- glm/gtx/rotate_vector.hpp | 10 ++---- glm/gtx/rotate_vector.inl | 4 +-- glm/gtx/simd_mat4.hpp | 10 ++---- glm/gtx/simd_mat4.inl | 6 ++-- glm/gtx/simd_vec4.hpp | 10 ++---- glm/gtx/simd_vec4.inl | 15 ++++---- glm/gtx/simplex.hpp | 10 ++---- 90 files changed, 179 insertions(+), 468 deletions(-) diff --git a/glm/gtx/associated_min_max.hpp b/glm/gtx/associated_min_max.hpp index 29cab7ee..10d2aa2f 100644 --- a/glm/gtx/associated_min_max.hpp +++ b/glm/gtx/associated_min_max.hpp @@ -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 diff --git a/glm/gtx/associated_min_max.inl b/glm/gtx/associated_min_max.inl index 88ea5dab..e1d2d6f7 100644 --- a/glm/gtx/associated_min_max.inl +++ b/glm/gtx/associated_min_max.inl @@ -8,9 +8,8 @@ /////////////////////////////////////////////////////////////////////////////////////////////////// namespace glm{ -namespace gtx{ -namespace associated_min_max{ - +namespace gtx +{ // Min comparison between 2 variables template 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 diff --git a/glm/gtx/bit.hpp b/glm/gtx/bit.hpp index a519730f..35593411 100644 --- a/glm/gtx/bit.hpp +++ b/glm/gtx/bit.hpp @@ -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 diff --git a/glm/gtx/bit.inl b/glm/gtx/bit.inl index 8b4c1a5d..fa8b0cc7 100644 --- a/glm/gtx/bit.inl +++ b/glm/gtx/bit.inl @@ -11,7 +11,6 @@ namespace glm{ namespace gtx{ -namespace bit{ template GLM_FUNC_QUALIFIER genIType mask @@ -772,6 +771,5 @@ GLM_FUNC_QUALIFIER genIUType fillBitfieldWithZero return Result; } -}//namespace bit }//namespace gtx }//namespace glm diff --git a/glm/gtx/closest_point.hpp b/glm/gtx/closest_point.hpp index 7c9d5130..6b33e4ba 100644 --- a/glm/gtx/closest_point.hpp +++ b/glm/gtx/closest_point.hpp @@ -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 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 diff --git a/glm/gtx/closest_point.inl b/glm/gtx/closest_point.inl index 8fab1e63..783281f0 100644 --- a/glm/gtx/closest_point.inl +++ b/glm/gtx/closest_point.inl @@ -12,7 +12,6 @@ namespace glm{ namespace gtx{ -namespace closest_point{ template GLM_FUNC_QUALIFIER detail::tvec3 closestPointOnLine @@ -34,7 +33,6 @@ GLM_FUNC_QUALIFIER detail::tvec3 closestPointOnLine return a + LineDirection * Distance; } -}//namespace closest_point }//namespace gtx }//namespace glm diff --git a/glm/gtx/color_cast.hpp b/glm/gtx/color_cast.hpp index 89928d95..5cc202b7 100644 --- a/glm/gtx/color_cast.hpp +++ b/glm/gtx/color_cast.hpp @@ -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 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 diff --git a/glm/gtx/color_space.hpp b/glm/gtx/color_space.hpp index 3b762363..8b1c5e4b 100644 --- a/glm/gtx/color_space.hpp +++ b/glm/gtx/color_space.hpp @@ -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 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 diff --git a/glm/gtx/color_space.inl b/glm/gtx/color_space.inl index dc8db73b..8b7ac198 100644 --- a/glm/gtx/color_space.inl +++ b/glm/gtx/color_space.inl @@ -8,8 +8,7 @@ /////////////////////////////////////////////////////////////////////////////////////////////////// namespace glm{ -namespace gtx{ -namespace color_space +namespace gtx { template GLM_FUNC_QUALIFIER detail::tvec3 rgbColor(const detail::tvec3& hsvColor) @@ -149,6 +148,5 @@ namespace color_space return dot(color, tmp); } -}//namespace color_space }//namespace gtx }//namespace glm diff --git a/glm/gtx/color_space_YCoCg.hpp b/glm/gtx/color_space_YCoCg.hpp index 5c25fa8c..dfa4e699 100644 --- a/glm/gtx/color_space_YCoCg.hpp +++ b/glm/gtx/color_space_YCoCg.hpp @@ -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 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 diff --git a/glm/gtx/color_space_YCoCg.inl b/glm/gtx/color_space_YCoCg.inl index ff2b8968..ce1b7cc3 100644 --- a/glm/gtx/color_space_YCoCg.inl +++ b/glm/gtx/color_space_YCoCg.inl @@ -9,7 +9,6 @@ namespace glm{ namespace gtx{ -namespace color_space_YCoCg{ template GLM_FUNC_QUALIFIER detail::tvec3 rgb2YCoCg @@ -64,6 +63,5 @@ GLM_FUNC_QUALIFIER detail::tvec3 YCoCgR2rgb return result; } -}//namespace color_space_YCoCg }//namespace gtx }//namespace glm diff --git a/glm/gtx/compatibility.hpp b/glm/gtx/compatibility.hpp index 36299989..0a2585b2 100644 --- a/glm/gtx/compatibility.hpp +++ b/glm/gtx/compatibility.hpp @@ -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 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 GLM_FUNC_QUALIFIER detail::tvec2 lerp(const detail::tvec2& x, const detail::tvec2& 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 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 diff --git a/glm/gtx/component_wise.hpp b/glm/gtx/component_wise.hpp index ab65a404..f842c785 100644 --- a/glm/gtx/component_wise.hpp +++ b/glm/gtx/component_wise.hpp @@ -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 diff --git a/glm/gtx/component_wise.inl b/glm/gtx/component_wise.inl index d37fe418..277b902a 100644 --- a/glm/gtx/component_wise.inl +++ b/glm/gtx/component_wise.inl @@ -8,8 +8,7 @@ /////////////////////////////////////////////////////////////////////////////////////////////////// namespace glm{ -namespace gtx{ -namespace component_wise +namespace gtx { template 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 diff --git a/glm/gtx/epsilon.hpp b/glm/gtx/epsilon.hpp index 3ee7f418..78513e6c 100644 --- a/glm/gtx/epsilon.hpp +++ b/glm/gtx/epsilon.hpp @@ -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 diff --git a/glm/gtx/epsilon.inl b/glm/gtx/epsilon.inl index 4eab9103..02fca35d 100644 --- a/glm/gtx/epsilon.inl +++ b/glm/gtx/epsilon.inl @@ -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 GLM_FUNC_QUALIFIER bool equalEpsilon @@ -229,6 +228,5 @@ GLM_FUNC_QUALIFIER detail::tvec4 notEqualEpsilon abs(x.w - y.w) >= epsilon.w); } -}//namespace epsilon }//namespace gtx }//namespace glm diff --git a/glm/gtx/euler_angles.hpp b/glm/gtx/euler_angles.hpp index fd73ee04..f5023b43 100644 --- a/glm/gtx/euler_angles.hpp +++ b/glm/gtx/euler_angles.hpp @@ -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 orientate4(detail::tvec3 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 diff --git a/glm/gtx/euler_angles.inl b/glm/gtx/euler_angles.inl index afde6ba3..f9de6eed 100644 --- a/glm/gtx/euler_angles.inl +++ b/glm/gtx/euler_angles.inl @@ -9,7 +9,6 @@ namespace glm{ namespace gtx{ -namespace euler_angles{ template GLM_FUNC_QUALIFIER detail::tmat4x4 eulerAngleX @@ -244,6 +243,5 @@ GLM_FUNC_QUALIFIER detail::tmat4x4 orientate4 return yawPitchRoll(angles.z, angles.x, angles.y); } -}//namespace euler_angles }//namespace gtx }//namespace glm diff --git a/glm/gtx/extend.hpp b/glm/gtx/extend.hpp index 9b38b613..a6af8f8a 100644 --- a/glm/gtx/extend.hpp +++ b/glm/gtx/extend.hpp @@ -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 diff --git a/glm/gtx/extend.inl b/glm/gtx/extend.inl index 42eb3684..b4c08d27 100644 --- a/glm/gtx/extend.inl +++ b/glm/gtx/extend.inl @@ -9,7 +9,6 @@ namespace glm{ namespace gtx{ -namespace extend{ template genType extend @@ -55,6 +54,5 @@ detail::tvec4 extend return Origin + (Source - Origin) * Distance; } -}//namespace extend }//namespace gtx }//namespace glm diff --git a/glm/gtx/extented_min_max.hpp b/glm/gtx/extented_min_max.hpp index 2ace7028..6d0e09ef 100644 --- a/glm/gtx/extented_min_max.hpp +++ b/glm/gtx/extented_min_max.hpp @@ -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 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 diff --git a/glm/gtx/extented_min_max.inl b/glm/gtx/extented_min_max.inl index 2cab82ac..59a4cd49 100644 --- a/glm/gtx/extented_min_max.inl +++ b/glm/gtx/extented_min_max.inl @@ -8,8 +8,7 @@ /////////////////////////////////////////////////////////////////////////////////////////////////// namespace glm{ -namespace gtx{ -namespace extented_min_max +namespace gtx { template 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 diff --git a/glm/gtx/fast_exponential.hpp b/glm/gtx/fast_exponential.hpp index ded068f7..77cf0490 100644 --- a/glm/gtx/fast_exponential.hpp +++ b/glm/gtx/fast_exponential.hpp @@ -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 diff --git a/glm/gtx/fast_exponential.inl b/glm/gtx/fast_exponential.inl index 64aa2cba..617b8c54 100644 --- a/glm/gtx/fast_exponential.inl +++ b/glm/gtx/fast_exponential.inl @@ -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 @@ -289,6 +288,5 @@ namespace fast_exponential fastLog2(x.w)); } -}//namespace fast_exponential }//namespace gtx }//namespace glm diff --git a/glm/gtx/fast_square_root.hpp b/glm/gtx/fast_square_root.hpp index 333ac302..430d61e0 100644 --- a/glm/gtx/fast_square_root.hpp +++ b/glm/gtx/fast_square_root.hpp @@ -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 diff --git a/glm/gtx/fast_square_root.inl b/glm/gtx/fast_square_root.inl index 0400bde7..b3c3e611 100644 --- a/glm/gtx/fast_square_root.inl +++ b/glm/gtx/fast_square_root.inl @@ -9,7 +9,6 @@ namespace glm{ namespace gtx{ -namespace fast_square_root{ // fastSqrt template @@ -232,6 +231,5 @@ GLM_FUNC_QUALIFIER detail::tvec4 fastNormalize return x * fastInverseSqrt(sqr); } -}//namespace fast_square_root }//namespace gtx }//namespace glm diff --git a/glm/gtx/fast_trigonometry.hpp b/glm/gtx/fast_trigonometry.hpp index daa8487c..6f3cf791 100644 --- a/glm/gtx/fast_trigonometry.hpp +++ b/glm/gtx/fast_trigonometry.hpp @@ -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 diff --git a/glm/gtx/fast_trigonometry.inl b/glm/gtx/fast_trigonometry.inl index de3d3591..bd8ac1c2 100644 --- a/glm/gtx/fast_trigonometry.inl +++ b/glm/gtx/fast_trigonometry.inl @@ -8,8 +8,7 @@ /////////////////////////////////////////////////////////////////////////////////////////////////// namespace glm{ -namespace gtx{ -namespace fast_trigonometry +namespace gtx { // sin template @@ -267,6 +266,5 @@ namespace fast_trigonometry fastAtan(x.w)); } -}//namespace fast_trigonometry }//namespace gtx }//namespace glm diff --git a/glm/gtx/gradient_paint.hpp b/glm/gtx/gradient_paint.hpp index ea0bd0ab..dd33b3a2 100644 --- a/glm/gtx/gradient_paint.hpp +++ b/glm/gtx/gradient_paint.hpp @@ -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 @@ -44,12 +41,9 @@ namespace gradient_paint ///< GLM_GTX_gradient_paint extension: Compute a radien glm::detail::tvec2 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 diff --git a/glm/gtx/gradient_paint.inl b/glm/gtx/gradient_paint.inl index d3ad8004..d79e2b52 100644 --- a/glm/gtx/gradient_paint.inl +++ b/glm/gtx/gradient_paint.inl @@ -9,7 +9,6 @@ namespace glm{ namespace gtx{ -namespace gradient_paint{ template 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 diff --git a/glm/gtx/handed_coordinate_space.hpp b/glm/gtx/handed_coordinate_space.hpp index ca68bc91..43c802be 100644 --- a/glm/gtx/handed_coordinate_space.hpp +++ b/glm/gtx/handed_coordinate_space.hpp @@ -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 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 diff --git a/glm/gtx/handed_coordinate_space.inl b/glm/gtx/handed_coordinate_space.inl index 5660eab3..6b6fcd0a 100644 --- a/glm/gtx/handed_coordinate_space.inl +++ b/glm/gtx/handed_coordinate_space.inl @@ -8,8 +8,7 @@ /////////////////////////////////////////////////////////////////////////////////////////////////// namespace glm{ -namespace gtx{ -namespace handed_coordinate_space +namespace gtx { template 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 diff --git a/glm/gtx/inertia.hpp b/glm/gtx/inertia.hpp index 18a06537..fd43bc44 100644 --- a/glm/gtx/inertia.hpp +++ b/glm/gtx/inertia.hpp @@ -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 diff --git a/glm/gtx/inertia.inl b/glm/gtx/inertia.inl index c2352989..b82cda7b 100644 --- a/glm/gtx/inertia.inl +++ b/glm/gtx/inertia.inl @@ -9,7 +9,6 @@ namespace glm{ namespace gtx{ -namespace inertia{ template GLM_FUNC_QUALIFIER detail::tmat3x3 boxInertia3( @@ -98,6 +97,5 @@ namespace inertia{ return Result; } -}//namespace inertia }//namespace gtx }//namespace glm diff --git a/glm/gtx/int_10_10_10_2.hpp b/glm/gtx/int_10_10_10_2.hpp index 1dddd206..9dcc75a3 100644 --- a/glm/gtx/int_10_10_10_2.hpp +++ b/glm/gtx/int_10_10_10_2.hpp @@ -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 diff --git a/glm/gtx/int_10_10_10_2.inl b/glm/gtx/int_10_10_10_2.inl index af80f071..6dad9683 100644 --- a/glm/gtx/int_10_10_10_2.inl +++ b/glm/gtx/int_10_10_10_2.inl @@ -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) { - 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); - } + 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 }//namespace gtx }//namespace glm diff --git a/glm/gtx/integer.hpp b/glm/gtx/integer.hpp index 19651e27..3bed74e9 100644 --- a/glm/gtx/integer.hpp +++ b/glm/gtx/integer.hpp @@ -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 diff --git a/glm/gtx/integer.inl b/glm/gtx/integer.inl index e9c93c0f..0c971125 100644 --- a/glm/gtx/integer.inl +++ b/glm/gtx/integer.inl @@ -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 diff --git a/glm/gtx/intersect.hpp b/glm/gtx/intersect.hpp index 3dec2988..23a1e365 100644 --- a/glm/gtx/intersect.hpp +++ b/glm/gtx/intersect.hpp @@ -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 diff --git a/glm/gtx/intersect.inl b/glm/gtx/intersect.inl index f77b495e..c28e96bc 100644 --- a/glm/gtx/intersect.inl +++ b/glm/gtx/intersect.inl @@ -12,7 +12,6 @@ namespace glm{ namespace gtx{ -namespace intersect{ template GLM_FUNC_QUALIFIER bool intersectRayTriangle @@ -196,6 +195,5 @@ GLM_FUNC_QUALIFIER bool intersectLineSphere return false; } -}//namespace intersect }//namespace gtx }//namespace glm diff --git a/glm/gtx/log_base.hpp b/glm/gtx/log_base.hpp index edef8f64..b4744916 100644 --- a/glm/gtx/log_base.hpp +++ b/glm/gtx/log_base.hpp @@ -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 diff --git a/glm/gtx/log_base.inl b/glm/gtx/log_base.inl index cd76b5df..678ab2d8 100644 --- a/glm/gtx/log_base.inl +++ b/glm/gtx/log_base.inl @@ -9,7 +9,6 @@ namespace glm{ namespace gtx{ -namespace log_base{ template GLM_FUNC_QUALIFIER genType log( @@ -87,6 +86,5 @@ GLM_FUNC_QUALIFIER detail::tvec4 log( log(v.w, base.w)); } -}//namespace log_base }//namespace gtx }//namespace glm diff --git a/glm/gtx/matrix_cross_product.hpp b/glm/gtx/matrix_cross_product.hpp index b74b64a7..5894c045 100644 --- a/glm/gtx/matrix_cross_product.hpp +++ b/glm/gtx/matrix_cross_product.hpp @@ -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 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 diff --git a/glm/gtx/matrix_cross_product.inl b/glm/gtx/matrix_cross_product.inl index 3e4173f4..9d24ee69 100644 --- a/glm/gtx/matrix_cross_product.inl +++ b/glm/gtx/matrix_cross_product.inl @@ -9,36 +9,34 @@ namespace glm{ namespace gtx{ -namespace matrix_cross_product + +template +GLM_FUNC_QUALIFIER detail::tmat3x3 matrixCross3( + detail::tvec3 const & x) { - template - GLM_FUNC_QUALIFIER detail::tmat3x3 matrixCross3( - detail::tvec3 const & x) - { - detail::tmat3x3 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 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 - GLM_FUNC_QUALIFIER detail::tmat4x4 matrixCross4( - detail::tvec3 const & x) - { - detail::tmat4x4 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 +GLM_FUNC_QUALIFIER detail::tmat4x4 matrixCross4( + detail::tvec3 const & x) +{ + detail::tmat4x4 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 diff --git a/glm/gtx/matrix_interpolation.hpp b/glm/gtx/matrix_interpolation.hpp index 98c43177..c4a4c03b 100644 --- a/glm/gtx/matrix_interpolation.hpp +++ b/glm/gtx/matrix_interpolation.hpp @@ -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 diff --git a/glm/gtx/matrix_interpolation.inl b/glm/gtx/matrix_interpolation.inl index ab4d2bb4..bab33409 100644 --- a/glm/gtx/matrix_interpolation.inl +++ b/glm/gtx/matrix_interpolation.inl @@ -9,8 +9,7 @@ namespace glm{ namespace gtx{ -namespace matrix_interpolation -{ + template GLM_FUNC_QUALIFIER void axisAngle( detail::tmat4x4 const & mat, @@ -112,6 +111,5 @@ namespace matrix_interpolation return out; } -}//namespace transform }//namespace gtx }//namespace glm diff --git a/glm/gtx/matrix_major_storage.hpp b/glm/gtx/matrix_major_storage.hpp index 751aac80..13f56c3c 100644 --- a/glm/gtx/matrix_major_storage.hpp +++ b/glm/gtx/matrix_major_storage.hpp @@ -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& 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 diff --git a/glm/gtx/matrix_major_storage.inl b/glm/gtx/matrix_major_storage.inl index 281a4fac..60ce6014 100644 --- a/glm/gtx/matrix_major_storage.inl +++ b/glm/gtx/matrix_major_storage.inl @@ -9,8 +9,7 @@ namespace glm{ namespace gtx{ -namespace matrix_major_storage -{ + template GLM_FUNC_QUALIFIER detail::tmat2x2 rowMajor2( const detail::tvec2& v1, @@ -171,6 +170,5 @@ namespace matrix_major_storage return detail::tmat4x4(m); } -}//namespace matrix_major_storage }//namespace gtx }//namespace glm diff --git a/glm/gtx/matrix_operation.hpp b/glm/gtx/matrix_operation.hpp index 3cf2cff0..ff208e20 100644 --- a/glm/gtx/matrix_operation.hpp +++ b/glm/gtx/matrix_operation.hpp @@ -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 const & v); /// @} -}//namespace matrix_operation }//namespace gtx }//namespace glm diff --git a/glm/gtx/matrix_operation.inl b/glm/gtx/matrix_operation.inl index 0d52fbb1..74a8eb0e 100644 --- a/glm/gtx/matrix_operation.inl +++ b/glm/gtx/matrix_operation.inl @@ -9,8 +9,7 @@ namespace glm{ namespace gtx{ -namespace matrix_operation -{ + template GLM_FUNC_QUALIFIER detail::tmat2x2 diagonal2x2 ( @@ -124,6 +123,5 @@ namespace matrix_operation return Result; } -}//namespace matrix_operation }//namespace gtx }//namespace glm diff --git a/glm/gtx/matrix_query.hpp b/glm/gtx/matrix_query.hpp index b71b1af0..f39c8c4b 100644 --- a/glm/gtx/matrix_query.hpp +++ b/glm/gtx/matrix_query.hpp @@ -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::epsilon()); /// @} -}//namespace matrix_query }//namespace gtx }//namespace glm #include "matrix_query.inl" -namespace glm{using namespace gtx::matrix_query;} - #endif//glm_gtx_matrix_query diff --git a/glm/gtx/matrix_query.inl b/glm/gtx/matrix_query.inl index 9ba2b7ec..79939920 100644 --- a/glm/gtx/matrix_query.inl +++ b/glm/gtx/matrix_query.inl @@ -11,8 +11,7 @@ /////////////////////////////////////////////////////////////////////////////////////////////////// namespace glm{ -namespace gtx{ -namespace matrix_query +namespace gtx { template GLM_FUNC_QUALIFIER bool isNull( @@ -139,6 +138,5 @@ namespace matrix_query return result; } -}//namespace matrix_query }//namespace gtx }//namespace glm diff --git a/glm/gtx/mixed_product.hpp b/glm/gtx/mixed_product.hpp index 5ce5430f..2647faf2 100644 --- a/glm/gtx/mixed_product.hpp +++ b/glm/gtx/mixed_product.hpp @@ -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 valType mixedProduct( detail::tvec3 const & v1, @@ -35,12 +34,9 @@ namespace mixed_product ///< GLM_GTX_mixed_product extension: Mixed product of 3 detail::tvec3 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 diff --git a/glm/gtx/mixed_product.inl b/glm/gtx/mixed_product.inl index f4985f10..1062b95f 100644 --- a/glm/gtx/mixed_product.inl +++ b/glm/gtx/mixed_product.inl @@ -10,18 +10,14 @@ namespace glm{ namespace gtx{ -namespace mixed_product +template +GLM_FUNC_QUALIFIER valType mixedProduct( + detail::tvec3 const & v1, + detail::tvec3 const & v2, + detail::tvec3 const & v3) { - template - GLM_FUNC_QUALIFIER valType mixedProduct( - detail::tvec3 const & v1, - detail::tvec3 const & v2, - detail::tvec3 const & v3) - { - return dot(cross(v1, v2), v3); - } + return dot(cross(v1, v2), v3); } -//namespace mixed_product }//namespace gtx }//namespace glm diff --git a/glm/gtx/multiple.hpp b/glm/gtx/multiple.hpp index 189320c9..7d6a9da9 100644 --- a/glm/gtx/multiple.hpp +++ b/glm/gtx/multiple.hpp @@ -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 diff --git a/glm/gtx/multiple.inl b/glm/gtx/multiple.inl index 36bba227..2a482d0e 100644 --- a/glm/gtx/multiple.inl +++ b/glm/gtx/multiple.inl @@ -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 diff --git a/glm/gtx/noise.hpp b/glm/gtx/noise.hpp index 735791d4..d4d519f9 100644 --- a/glm/gtx/noise.hpp +++ b/glm/gtx/noise.hpp @@ -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 const & p); /// @} -}//namespace noise }//namespace gtx }//namespace glm #include "noise.inl" -namespace glm{using namespace gtx::noise;} - #endif//glm_gtx_noise diff --git a/glm/gtx/noise.inl b/glm/gtx/noise.inl index 839173b4..f8383106 100644 --- a/glm/gtx/noise.inl +++ b/glm/gtx/noise.inl @@ -15,8 +15,9 @@ // - GLM core /////////////////////////////////////////////////////////////////////////////////////////////////// -namespace glm -{ +namespace glm{ +namespace gtx{ + template GLM_FUNC_QUALIFIER T permute(T const & x) { @@ -57,9 +58,6 @@ namespace glm return detail::tvec4(pXYZ, pW); } -namespace gtx{ -namespace noise -{ // Classic Perlin noise template GLM_FUNC_QUALIFIER T perlin(detail::tvec2 const & P) @@ -787,6 +785,5 @@ namespace noise dot(m1 * m1, detail::tvec2(dot(p3, x3), dot(p4, x4)))); } -}//namespace noise }//namespace gtx }//namespace glm diff --git a/glm/gtx/norm.hpp b/glm/gtx/norm.hpp index 34c2e985..f9a87bb9 100644 --- a/glm/gtx/norm.hpp +++ b/glm/gtx/norm.hpp @@ -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 diff --git a/glm/gtx/norm.inl b/glm/gtx/norm.inl index e062177b..949664e3 100644 --- a/glm/gtx/norm.inl +++ b/glm/gtx/norm.inl @@ -8,8 +8,7 @@ /////////////////////////////////////////////////////////////////////////////////////////////////// namespace glm{ -namespace gtx{ -namespace norm +namespace gtx { template 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 diff --git a/glm/gtx/normal.hpp b/glm/gtx/normal.hpp index 9d598e92..b7a9bd14 100644 --- a/glm/gtx/normal.hpp +++ b/glm/gtx/normal.hpp @@ -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 const & p3); /// @} -}//namespace normal }//namespace gtx }//namespace glm #include "normal.inl" -namespace glm{using namespace gtx::normal;} - #endif//glm_gtx_normal diff --git a/glm/gtx/normal.inl b/glm/gtx/normal.inl index d7e0cfd2..689e5e0b 100644 --- a/glm/gtx/normal.inl +++ b/glm/gtx/normal.inl @@ -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 - GLM_FUNC_QUALIFIER detail::tvec3 triangleNormal - ( - detail::tvec3 const & p1, - detail::tvec3 const & p2, - detail::tvec3 const & p3 - ) - { - return normalize(cross(p1 - p2, p1 - p3)); - } +template +GLM_FUNC_QUALIFIER detail::tvec3 triangleNormal +( + detail::tvec3 const & p1, + detail::tvec3 const & p2, + detail::tvec3 const & p3 +) +{ + return normalize(cross(p1 - p2, p1 - p3)); +} -}//namespace normal }//namespace gtx }//namespace glm diff --git a/glm/gtx/normalize_dot.hpp b/glm/gtx/normalize_dot.hpp index df83eec4..f00fdca8 100644 --- a/glm/gtx/normalize_dot.hpp +++ b/glm/gtx/normalize_dot.hpp @@ -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 diff --git a/glm/gtx/normalize_dot.inl b/glm/gtx/normalize_dot.inl index 4e00d71f..7a81ebdc 100644 --- a/glm/gtx/normalize_dot.inl +++ b/glm/gtx/normalize_dot.inl @@ -9,7 +9,6 @@ namespace glm{ namespace gtx{ -namespace normalize_dot{ template 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 diff --git a/glm/gtx/number_precision.hpp b/glm/gtx/number_precision.hpp index 6c4bfc6a..3506ae1e 100644 --- a/glm/gtx/number_precision.hpp +++ b/glm/gtx/number_precision.hpp @@ -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 diff --git a/glm/gtx/ocl_type.hpp b/glm/gtx/ocl_type.hpp index bc1bf90f..758a0cf7 100644 --- a/glm/gtx/ocl_type.hpp +++ b/glm/gtx/ocl_type.hpp @@ -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 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 diff --git a/glm/gtx/optimum_pow.hpp b/glm/gtx/optimum_pow.hpp index 05ad4263..72d2ec90 100644 --- a/glm/gtx/optimum_pow.hpp +++ b/glm/gtx/optimum_pow.hpp @@ -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 powOfTwo(const detail::tvec4& x); /// @} -}//namespace optimum_pow }//namespace gtx }//namespace glm #include "optimum_pow.inl" -namespace glm{using namespace gtx::optimum_pow;} - #endif//glm_gtx_optimum_pow diff --git a/glm/gtx/optimum_pow.inl b/glm/gtx/optimum_pow.inl index c38b1bc4..cc171730 100644 --- a/glm/gtx/optimum_pow.inl +++ b/glm/gtx/optimum_pow.inl @@ -9,7 +9,6 @@ namespace glm{ namespace gtx{ -namespace optimum_pow{ template 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 diff --git a/glm/gtx/orthonormalize.hpp b/glm/gtx/orthonormalize.hpp index 38049bac..012424f7 100644 --- a/glm/gtx/orthonormalize.hpp +++ b/glm/gtx/orthonormalize.hpp @@ -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& y); /// @} -}//namespace orthonormalize }//namespace gtx }//namespace glm #include "orthonormalize.inl" -namespace glm{using namespace gtx::orthonormalize;} - #endif//glm_gtx_orthonormalize diff --git a/glm/gtx/orthonormalize.inl b/glm/gtx/orthonormalize.inl index 8f0f110f..149668dd 100644 --- a/glm/gtx/orthonormalize.inl +++ b/glm/gtx/orthonormalize.inl @@ -9,7 +9,6 @@ namespace glm{ namespace gtx{ -namespace orthonormalize{ template GLM_FUNC_QUALIFIER detail::tmat3x3 orthonormalize @@ -43,7 +42,6 @@ namespace orthonormalize{ return normalize(x - y * dot(y, x)); } -}//namespace orthonormalize }//namespace gtx }//namespace glm diff --git a/glm/gtx/perpendicular.hpp b/glm/gtx/perpendicular.hpp index a4d16bfb..d2348c30 100644 --- a/glm/gtx/perpendicular.hpp +++ b/glm/gtx/perpendicular.hpp @@ -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 const & Normal); /// @} -}//namespace perpendicular }//namespace gtx }//namespace glm #include "perpendicular.inl" -namespace glm{using namespace gtx::perpendicular;} - #endif//glm_gtx_perpendicular diff --git a/glm/gtx/perpendicular.inl b/glm/gtx/perpendicular.inl index 595053e7..cff060db 100644 --- a/glm/gtx/perpendicular.inl +++ b/glm/gtx/perpendicular.inl @@ -9,7 +9,6 @@ namespace glm{ namespace gtx{ -namespace perpendicular{ template GLM_FUNC_QUALIFIER detail::tvec2 perp( @@ -35,6 +34,5 @@ GLM_FUNC_QUALIFIER detail::tvec4 perp( return x - projection::proj(x, Normal); } -}//namespace perpendicular }//namespace gtx }//namespace glm diff --git a/glm/gtx/polar_coordinates.hpp b/glm/gtx/polar_coordinates.hpp index f4d5bf75..a8aaf557 100644 --- a/glm/gtx/polar_coordinates.hpp +++ b/glm/gtx/polar_coordinates.hpp @@ -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 euclidean(const detail::tvec3& polar); /// @} -}//namespace polar_coordinates }//namespace gtx }//namespace glm #include "polar_coordinates.inl" -namespace glm{using namespace gtx::polar_coordinates;} - #endif//glm_gtx_polar_coordinates diff --git a/glm/gtx/polar_coordinates.inl b/glm/gtx/polar_coordinates.inl index 9d99d568..7e2913ce 100644 --- a/glm/gtx/polar_coordinates.inl +++ b/glm/gtx/polar_coordinates.inl @@ -8,8 +8,7 @@ /////////////////////////////////////////////////////////////////////////////////////////////////// namespace glm{ -namespace gtx{ -namespace polar_coordinates +namespace gtx { template GLM_FUNC_QUALIFIER detail::tvec3 polar( @@ -37,6 +36,5 @@ namespace polar_coordinates cos(latitude) * cos(longitude)); } -}//namespace polar_coordinates }//namespace gtx }//namespace glm diff --git a/glm/gtx/projection.hpp b/glm/gtx/projection.hpp index 47e8eb66..9b4d035e 100644 --- a/glm/gtx/projection.hpp +++ b/glm/gtx/projection.hpp @@ -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 const & Normal); /// @} -}//namespace projection }//namespace gtx }//namespace glm #include "projection.inl" -namespace glm{using namespace gtx::projection;} - #endif//glm_gtx_projection diff --git a/glm/gtx/projection.inl b/glm/gtx/projection.inl index bd365476..bf1c7ff1 100644 --- a/glm/gtx/projection.inl +++ b/glm/gtx/projection.inl @@ -9,7 +9,6 @@ namespace glm{ namespace gtx{ -namespace projection{ template GLM_FUNC_QUALIFIER detail::tvec2 proj( @@ -35,6 +34,5 @@ GLM_FUNC_QUALIFIER detail::tvec4 proj( return glm::dot(x, Normal) / glm::dot(Normal, Normal) * Normal; } -}//namespace projection }//namespace gtx }//namespace glm diff --git a/glm/gtx/quaternion.hpp b/glm/gtx/quaternion.hpp index 5e1e09a4..46cbcda9 100644 --- a/glm/gtx/quaternion.hpp +++ b/glm/gtx/quaternion.hpp @@ -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 diff --git a/glm/gtx/quaternion.inl b/glm/gtx/quaternion.inl index 41d3b982..a24e3bcb 100644 --- a/glm/gtx/quaternion.inl +++ b/glm/gtx/quaternion.inl @@ -10,8 +10,7 @@ #include namespace glm{ -namespace gtx{ -namespace quaternion +namespace gtx { template GLM_FUNC_QUALIFIER detail::tvec3 cross @@ -298,6 +297,5 @@ namespace quaternion return glm::normalize(x * (T(1) - a) + (y * a)); } -}//namespace quaternion }//namespace gtx }//namespace glm diff --git a/glm/gtx/random.hpp b/glm/gtx/random.hpp index fabc192a..d8277086 100644 --- a/glm/gtx/random.hpp +++ b/glm/gtx/random.hpp @@ -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 detail::tvec4 gaussRand4(const detail::tvec4& mean, const detail::tvec4& 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 diff --git a/glm/gtx/random.inl b/glm/gtx/random.inl index 77edea44..67c64e22 100644 --- a/glm/gtx/random.inl +++ b/glm/gtx/random.inl @@ -11,8 +11,7 @@ #include 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 diff --git a/glm/gtx/raw_data.hpp b/glm/gtx/raw_data.hpp index 078995e4..bc369e38 100644 --- a/glm/gtx/raw_data.hpp +++ b/glm/gtx/raw_data.hpp @@ -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 diff --git a/glm/gtx/reciprocal.hpp b/glm/gtx/reciprocal.hpp index aac6cf76..af0773a2 100644 --- a/glm/gtx/reciprocal.hpp +++ b/glm/gtx/reciprocal.hpp @@ -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 diff --git a/glm/gtx/reciprocal.inl b/glm/gtx/reciprocal.inl index 3a19d3c7..bcd10423 100644 --- a/glm/gtx/reciprocal.inl +++ b/glm/gtx/reciprocal.inl @@ -9,7 +9,6 @@ namespace glm{ namespace gtx{ -namespace reciprocal{ // sec template @@ -588,6 +587,5 @@ GLM_FUNC_QUALIFIER detail::tvec4 acoth acoth(x.w)); } -}//namespace reciprocal }//namespace gtx }//namespace glm diff --git a/glm/gtx/rotate_vector.hpp b/glm/gtx/rotate_vector.hpp index 1eaec829..8bd6c2ac 100644 --- a/glm/gtx/rotate_vector.hpp +++ b/glm/gtx/rotate_vector.hpp @@ -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 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 diff --git a/glm/gtx/rotate_vector.inl b/glm/gtx/rotate_vector.inl index 69eaa1fd..e0911e00 100644 --- a/glm/gtx/rotate_vector.inl +++ b/glm/gtx/rotate_vector.inl @@ -9,8 +9,7 @@ namespace glm{ namespace gtx{ -namespace rotate_vector -{ + template GLM_FUNC_QUALIFIER detail::tvec2 rotate( detail::tvec2 const & v, @@ -144,6 +143,5 @@ namespace rotate_vector return glm::gtx::transform::rotate(Angle, RotationAxis); } -}//namespace rotate_vector }//namespace gtx }//namespace glm diff --git a/glm/gtx/simd_mat4.hpp b/glm/gtx/simd_mat4.hpp index 614cf593..8793abee 100644 --- a/glm/gtx/simd_mat4.hpp +++ b/glm/gtx/simd_mat4.hpp @@ -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 diff --git a/glm/gtx/simd_mat4.inl b/glm/gtx/simd_mat4.inl index 84771b65..4c43099b 100644 --- a/glm/gtx/simd_mat4.inl +++ b/glm/gtx/simd_mat4.inl @@ -234,8 +234,7 @@ namespace detail }//namespace detail -namespace gtx{ -namespace simd_mat4 +namespace gtx { GLM_FUNC_QUALIFIER detail::tmat4x4 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 diff --git a/glm/gtx/simd_vec4.hpp b/glm/gtx/simd_vec4.hpp index 05fb99ec..b849759c 100644 --- a/glm/gtx/simd_vec4.hpp +++ b/glm/gtx/simd_vec4.hpp @@ -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 diff --git a/glm/gtx/simd_vec4.inl b/glm/gtx/simd_vec4.inl index d7b1863a..c95678be 100644 --- a/glm/gtx/simd_vec4.inl +++ b/glm/gtx/simd_vec4.inl @@ -7,10 +7,9 @@ // File : glm/gtx/simd_vec4.inl /////////////////////////////////////////////////////////////////////////////////////////////////// -namespace glm +namespace glm{ +namespace detail { - namespace detail - { template 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 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 diff --git a/glm/gtx/simplex.hpp b/glm/gtx/simplex.hpp index 390a641e..3bf3d746 100644 --- a/glm/gtx/simplex.hpp +++ b/glm/gtx/simplex.hpp @@ -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