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

Removed old deprecated test function declarations

Browse Source
This commit is contained in:
Christophe Riccio 2011-05-18 14:55:06 +01:00
parent c99e2f523f
commit 9ecdd379e4
52 changed files with 329 additions and 539 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
glm/gtc/half_float.hpp
View File

@ -17,11 +17,7 @@
# pragma message("GLM: GLM_GTC_half_float extension included")
#endif
namespace glm
{
namespace test{
bool main_gtc_half_float();
}//namespace
namespace glm{
namespace detail
{
#ifndef _MSC_EXTENSIONS

4
glm/gtc/matrix_integer.hpp
View File

@ -22,10 +22,6 @@
namespace glm
{
namespace test{
bool main_gtc_matrix_integer();
}//namespace test
namespace gtc{
//! GLM_GTC_matrix_integer extension: Add integer matrices
namespace matrix_integer

4
glm/gtc/matrix_transform.hpp
View File

@ -23,10 +23,6 @@
namespace glm
{
namespace test{
bool main_gtc_matrix_transform();
}//namespace test
namespace gtc{
//! GLM_GTC_matrix_transform extension: Add transformation matrices
namespace matrix_transform

4
glm/gtc/quaternion.hpp
View File

@ -28,10 +28,6 @@
namespace glm
{
namespace test{
bool main_gtc_quaternion();
}//namespace test
namespace detail
{
//! \brief Template for quaternion.

4
glm/gtc/swizzle.hpp
View File

@ -23,10 +23,6 @@
namespace glm
{
namespace test{
void main_gtc_swizzle();
}//namespace test
namespace gtc{
//! GLM_GTC_swizzle extension
namespace swizzle

4
glm/gtc/type_precision.hpp
View File

@ -26,10 +26,6 @@
namespace glm
{
namespace test{
bool main_gtc_type_precision();
}//namespace test
namespace gtc{
//! GLM_GTC_type_precision extension: Defined types with specific size.
namespace type_precision

4
glm/gtc/type_ptr.hpp
View File

@ -23,10 +23,6 @@
namespace glm
{
namespace test{
void main_gtc_type_ptr();
}//namespace test
namespace gtc{
//! GLM_GTC_type_ptr extension: Get access to vectors & matrices value type address.
namespace type_ptr{

4
glm/gtx/associated_min_max.hpp
View File

@ -23,10 +23,6 @@
namespace glm
{
namespace test{
void main_gtx_associated_min_max();
}//namespace test
namespace gtx
{
//! GLM_GTX_associated_min_max extension: Min and max functions that return associated values not the compared onces.

4
glm/gtx/bit.hpp
View File

@ -24,10 +24,6 @@
namespace glm
{
namespace test{
void main_gtx_bit();
}//namespace test
namespace gtx{
//! GLM_GTX_bit extension: Allow to perform bit operations on integer values
namespace bit

4
glm/gtx/closest_point.hpp
View File

@ -22,10 +22,6 @@
namespace glm
{
namespace test{
void main_gtx_closest_point();
}//namespace test
namespace gtx{
//! GLM_GTX_closest_point extension: Find the point on a straight line which is the closet of a point.
namespace closest_point{

4
glm/gtx/color_cast.hpp
View File

@ -24,10 +24,6 @@
namespace glm
{
namespace test{
void main_ext_gtx_color_cast();
}//namespace test
namespace gtx{
//! GLM_GTX_color_cast extension: Conversion between two color types
namespace color_cast

4
glm/gtx/color_space.hpp
View File

@ -22,10 +22,6 @@
namespace glm
{
namespace test{
void main_gtx_color_space();
}//namespace test
namespace gtx{
//! GLM_GTX_color_space extension: Related to RGB to HSV conversions and operations
namespace color_space

4
glm/gtx/color_space_YCoCg.hpp
View File

@ -22,10 +22,6 @@
namespace glm
{
namespace test{
void main_gtx_color_space_YCoCg();
}//namespace test
namespace gtx{
//! GLM_GTX_color_space_YCoCg extension: RGB to YCoCg conversions and operations
namespace color_space_YCoCg

4
glm/gtx/compatibility.hpp
View File

@ -30,10 +30,6 @@
namespace glm
{
namespace test{
void main_gtx_compatibility();
}//namespace test
namespace gtx{
//! GLM_GTX_compatibility extension: Provide functions to increase the compatibility with Cg and HLSL languages
namespace compatibility

4
glm/gtx/component_wise.hpp
View File

@ -22,10 +22,6 @@
namespace glm
{
namespace test{
void main_gtx_component_wise();
}//namespace test
namespace gtx{
//! GLM_GTX_component_wise extension: Operations between components of a type
namespace component_wise

4
glm/gtx/epsilon.hpp
View File

@ -24,10 +24,6 @@
namespace glm
{
namespace test{
void main_gtx_epsilon();
}//namespace test
namespace gtx{
//! GLM_GTX_epsilon extension: Comparison functions for a user defined epsilon values.
namespace epsilon

4
glm/gtx/extend.hpp
View File

@ -22,10 +22,6 @@
namespace glm
{
namespace test{
void main_gtx_extend();
}//namespace test
namespace gtx{
//! GLM_GTX_extend extension: Extend a position from a source to a position at a defined length.
namespace extend

4
glm/gtx/extented_min_max.hpp
View File

@ -24,10 +24,6 @@
namespace glm
{
namespace test{
void main_ext_gtx_extented_min_max();
}//namespace test
namespace gtx{
//! GLM_GTX_extented_min_max extension: Min and max functions for 3 to 4 parameters.
namespace extented_min_max

4
glm/gtx/fast_exponential.hpp
View File

@ -24,10 +24,6 @@
namespace glm
{
namespace test{
void main_gtx_fast_exponential();
}//namespace test
namespace gtx{
//! GLM_GTX_fast_exponential extension: Fast but less accurate implementations of exponential based functions.
namespace fast_exponential

4
glm/gtx/fast_square_root.hpp
View File

@ -26,10 +26,6 @@
namespace glm
{
namespace test{
void main_gtx_fast_square_root();
}//namespace test
namespace gtx{
//! GLM_GTX_fast_square_root extension: Fast but less accurate implementations of square root based functions.
namespace fast_square_root

4
glm/gtx/fast_trigonometry.hpp
View File

@ -22,10 +22,6 @@
namespace glm
{
namespace test{
void main_gtx_fast_trigonometry();
}//namespace test
namespace gtx{
//! GLM_GTX_fast_trigonometry extension: Fast but less accurate implementations of trigonometric functions.
namespace fast_trigonometry

4
glm/gtx/gradient_paint.hpp
View File

@ -23,10 +23,6 @@
namespace glm
{
namespace test{
void main_gtx_gradient_paint();
}//namespace test
namespace gtx{
//! GLM_GTX_gradient_paint extension: Compute a radient gradient according section OpenVG 1.1 specifications, 9.3.2 Radial Gradients
namespace gradient_paint

4
glm/gtx/intersect.hpp
View File

@ -24,10 +24,6 @@
namespace glm
{
namespace test{
void main_gtx_intesect();
}//namespace test
namespace gtx{
//! GLM_GTX_intersect extension: Add intersection functions
namespace intersect

4
glm/gtx/log_base.hpp
View File

@ -22,10 +22,6 @@
namespace glm
{
namespace test{
void main_ext_gtx_log_base();
}//namespace test
namespace gtx{
//! GLM_GTX_log_base extension: Logarithm for any base. base can be a vector or a scalar.
namespace log_base

4
glm/gtx/matrix_cross_product.hpp
View File

@ -22,10 +22,6 @@
namespace glm
{
namespace test{
void main_gtx_matrix_cross_product();
}//namespace test
namespace gtx{
//! GLM_GTX_matrix_cross_product: Build cross product matrices
namespace matrix_cross_product

4
glm/gtx/matrix_interpolation.hpp
View File

@ -25,10 +25,6 @@
namespace glm
{
namespace test{
void main_gtx_transform();
}//namespace test
namespace gtx{
//! GLM_GTX_matrix_interpolation extension: Add transformation matrices
namespace matrix_interpolation

4
glm/gtx/matrix_operation.hpp
View File

@ -22,10 +22,6 @@
namespace glm
{
namespace test{
void main_gtx_matrix_operation();
}//namespace test
namespace gtx{
//! GLM_GTX_matrix_operation: Build diagonal matrices
namespace matrix_operation

4
glm/gtx/matrix_query.hpp
View File

@ -22,10 +22,6 @@
namespace glm
{
namespace test{
void main_gtx_matrix_query();
}//namespace test
namespace gtx{
//! GLM_GTX_matrix_query: Query to evaluate matrix properties
namespace matrix_query

4
glm/gtx/mixed_product.hpp
View File

@ -22,10 +22,6 @@
namespace glm
{
namespace test{
void main_gtx_matrix_selection();
}//namespace test
namespace gtx{
//! GLM_GTX_mixed_product extension: Mixed product of 3 vectors.
namespace mixed_product

4
glm/gtx/multiple.hpp
View File

@ -22,10 +22,6 @@
namespace glm
{
namespace test{
bool main_img_multiple();
}//namespace test
namespace gtx{
//! GLM_GTX_multiple: Find the closest number of a number multiple of other number.
namespace multiple

4
glm/gtx/noise.hpp
View File

@ -27,10 +27,6 @@
namespace glm
{
namespace test{
void main_gtx_noise();
}//namespace test
namespace gtx{
//! GLM_GTX_noise extension: Comparison functions for a user defined epsilon values.
namespace noise

4
glm/gtx/norm.hpp
View File

@ -27,10 +27,6 @@
namespace glm
{
namespace test{
void main_gtx_norm();
}//namespace test
namespace gtx{
//! GLM_GTX_norm extension: Various way to compute vector norms.
namespace norm

4
glm/gtx/normal.hpp
View File

@ -22,10 +22,6 @@
namespace glm
{
namespace test{
void main_gtx_normal();
}//namespace test
namespace gtx{
//! GLM_GTX_normal extension: Compute the normal of a triangle.
namespace normal

4
glm/gtx/optimum_pow.hpp
View File

@ -22,10 +22,6 @@
namespace glm
{
namespace test{
void main_gtx_optimum_pow();
}//namespace test
namespace gtx{
//! GLM_GTX_optimum_pow extension: Integer exponentiation of power functions.
namespace optimum_pow

4
glm/gtx/orthonormalize.hpp
View File

@ -22,10 +22,6 @@
namespace glm
{
namespace test{
void main_gtx_orthonormalize();
}//namespace test
namespace gtx{
//! GLM_GTX_orthonormalize extension: Orthonormalize matrices.
namespace orthonormalize

4
glm/gtx/perpendicular.hpp
View File

@ -24,10 +24,6 @@
namespace glm
{
namespace test{
void main_gtx_perpendicular();
}//namespace test
namespace gtx{
//! GLM_GTX_perpendicular extension: Perpendicular of a vector from other one
namespace perpendicular

4
glm/gtx/projection.hpp
View File

@ -22,10 +22,6 @@
namespace glm
{
namespace test{
void main_gtx_projection();
}//namespace test
namespace gtx{
//! GLM_GTX_projection extension: Projection of a vector to other one
namespace projection

4
glm/gtx/reciprocal.hpp
View File

@ -19,10 +19,6 @@
namespace glm
{
namespace test{
void main_gtx_reciprocal();
}//namespace test
namespace gtx{
//! GLM_GTX_reciprocal extension: Define secant, cosecant and cotangent functions.
namespace reciprocal

73
glm/gtx/simplex.hpp
View File

@ -20,49 +20,48 @@
# pragma message("GLM: GLM_GTX_simplex extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
//! GLM_GTX_simplex extension: Spline functions
namespace spline
{
namespace gtx{
//! GLM_GTX_simplex extension: Spline functions
namespace spline
{
/// \addtogroup gtx_spline
///@{
/// \addtogroup gtx_spline
///@{
//! Return a point from a catmull rom curve.
//! From GLM_GTX_spline extension.
template <typename genType>
genType catmullRom(
genType const & v1,
genType const & v2,
genType const & v3,
genType const & v4,
typename genType::value_type const & s);
//! Return a point from a catmull rom curve.
//! From GLM_GTX_spline extension.
template <typename genType>
genType catmullRom(
genType const & v1,
genType const & v2,
genType const & v3,
genType const & v4,
typename genType::value_type const & s);
//! Return a point from a hermite curve.
//! From GLM_GTX_spline extension.
template <typename genType>
genType hermite(
genType const & v1,
genType const & t1,
genType const & v2,
genType const & t2,
typename genType::value_type const & s);
//! Return a point from a hermite curve.
//! From GLM_GTX_spline extension.
template <typename genType>
genType hermite(
genType const & v1,
genType const & t1,
genType const & v2,
genType const & t2,
typename genType::value_type const & s);
//! Return a point from a cubic curve.
//! From GLM_GTX_spline extension.
template <typename genType>
genType cubic(
genType const & v1,
genType const & v2,
genType const & v3,
genType const & v4,
typename genType::value_type const & s);
//! Return a point from a cubic curve.
//! From GLM_GTX_spline extension.
template <typename genType>
genType cubic(
genType const & v1,
genType const & v2,
genType const & v3,
genType const & v4,
typename genType::value_type const & s);
///@}
///@}
}//namespace simplex
}//namespace gtx
}//namespace simplex
}//namespace gtx
}//namespace glm
#include "simplex.inl"

75
glm/gtx/spline.hpp
View File

@ -21,51 +21,50 @@
# pragma message("GLM: GLM_GTX_spline extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
//! GLM_GTX_spline extension: Spline functions
namespace spline
{
namespace gtx{
//! GLM_GTX_spline extension: Spline functions
namespace spline
{
using namespace gtx::optimum_pow;
using namespace gtx::optimum_pow;
/// \addtogroup gtx_spline
///@{
/// \addtogroup gtx_spline
///@{
//! Return a point from a catmull rom curve.
//! From GLM_GTX_spline extension.
template <typename genType>
genType catmullRom(
genType const & v1,
genType const & v2,
genType const & v3,
genType const & v4,
typename genType::value_type const & s);
//! Return a point from a catmull rom curve.
//! From GLM_GTX_spline extension.
template <typename genType>
genType catmullRom(
genType const & v1,
genType const & v2,
genType const & v3,
genType const & v4,
typename genType::value_type const & s);
//! Return a point from a hermite curve.
//! From GLM_GTX_spline extension.
template <typename genType>
genType hermite(
genType const & v1,
genType const & t1,
genType const & v2,
genType const & t2,
typename genType::value_type const & s);
//! Return a point from a hermite curve.
//! From GLM_GTX_spline extension.
template <typename genType>
genType hermite(
genType const & v1,
genType const & t1,
genType const & v2,
genType const & t2,
typename genType::value_type const & s);
//! Return a point from a cubic curve.
//! From GLM_GTX_spline extension.
template <typename genType>
genType cubic(
genType const & v1,
genType const & v2,
genType const & v3,
genType const & v4,
typename genType::value_type const & s);
//! Return a point from a cubic curve.
//! From GLM_GTX_spline extension.
template <typename genType>
genType cubic(
genType const & v1,
genType const & v2,
genType const & v3,
genType const & v4,
typename genType::value_type const & s);
///@}
///@}
}//namespace spline
}//namespace gtx
}//namespace spline
}//namespace gtx
}//namespace glm
#include "spline.inl"

4
glm/gtx/std_based_type.hpp
View File

@ -23,10 +23,6 @@
namespace glm
{
namespace test{
void main_gtx_std_based_type();
}//namespace test
namespace gtx{
//! GLM_GTX_std_based_type extension: Add support vector types based on C++ standard type
namespace std_based_type

4
glm/gtx/string_cast.hpp
View File

@ -30,10 +30,6 @@
namespace glm
{
namespace test{
void main_gtx_string_cast();
}//namespace test
namespace gtx{
//! GLM_GTX_string_cast extension: Setup strings for GLM type values
namespace string_cast

4
glm/gtx/transform.hpp
View File

@ -24,10 +24,6 @@
namespace glm
{
namespace test{
void main_gtx_transform();
}//namespace test
namespace gtx{
//! GLM_GTX_transform extension: Add transformation matrices
namespace transform

4
glm/gtx/transform2.hpp
View File

@ -24,10 +24,6 @@
namespace glm
{
namespace test{
void main_gtx_transform2();
}//namespace test
namespace gtx{
//! GLM_GTX_transform2 extension: Add extra transformation matrices
namespace transform2

66
glm/gtx/ulp.hpp
View File

@ -20,49 +20,47 @@
# pragma message("GLM: GLM_GTX_ulp extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace ulp ///< GLM_GTX_ulp extension: Precision calculation functions
{
namespace gtx{
//! GLM_GTX_ulp extension: Precision calculation functions
namespace ulp
{
/// \addtogroup gtx_ulp
///@{
/// \addtogroup gtx_ulp
///@{
//! Return the next ULP value(s) after the input value(s).
//! From GLM_GTX_ulp extension.
template <typename genType>
genType next_float(genType const & x);
//! Return the next ULP value(s) after the input value(s).
//! From GLM_GTX_ulp extension.
template <typename genType>
genType next_float(genType const & x);
//! Return the previous ULP value(s) before the input value(s).
//! From GLM_GTX_ulp extension.
template <typename genType>
genType prev_float(genType const & x);
//! Return the previous ULP value(s) before the input value(s).
//! From GLM_GTX_ulp extension.
template <typename genType>
genType prev_float(genType const & x);
//! Return the value(s) ULP distance after the input value(s).
//! From GLM_GTX_ulp extension.
template <typename genType>
genType next_float(genType const & x, uint const & Distance);
//! Return the value(s) ULP distance after the input value(s).
//! From GLM_GTX_ulp extension.
template <typename genType>
genType next_float(genType const & x, uint const & Distance);
//! Return the value(s) ULP distance before the input value(s).
//! From GLM_GTX_ulp extension.
template <typename genType>
genType prev_float(genType const & x, uint const & Distance);
//! Return the value(s) ULP distance before the input value(s).
//! From GLM_GTX_ulp extension.
template <typename genType>
genType prev_float(genType const & x, uint const & Distance);
//! Return the distance in the number of ULP between 2 scalars.
//! From GLM_GTX_ulp extension.
template <typename T>
uint float_distance(T const & x, T const & y);
//! Return the distance in the number of ULP between 2 scalars.
//! From GLM_GTX_ulp extension.
template <typename T>
uint float_distance(T const & x, T const & y);
//! Return the distance in the number of ULP between 2 vectors.
//! From GLM_GTX_ulp extension.
template<typename T, template<typename> class vecType>
vecType<uint> float_distance(vecType<T> const & x, vecType<T> const & y);
//! Return the distance in the number of ULP between 2 vectors.
//! From GLM_GTX_ulp extension.
template<typename T, template<typename> class vecType>
vecType<uint> float_distance(vecType<T> const & x, vecType<T> const & y);
///@}
///@}
}//namespace ulp
}//namespace gtx
}//namespace ulp
}//namespace gtx
}//namespace glm
#include "ulp.inl"

48
glm/gtx/unsigned_int.hpp
View File

@ -22,41 +22,35 @@
# pragma message("GLM: GLM_GTX_unsigned_int extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace unsigned_int ///< GLM_GTX_unsigned_int extension: Add support for unsigned integer for core functions
{
namespace test{
void main_gtx_unsigned_int();
}//namespace test
using namespace gtx::integer;
namespace gtx{
//! GLM_GTX_unsigned_int extension: Add support for unsigned integer for core functions
namespace unsigned_int
{
using namespace gtx::integer;
/// \addtogroup gtx_unsigned_int
///@{
/// \addtogroup gtx_unsigned_int
///@{
//! 32bit signed integer.
//! From GLM_GTX_unsigned_int extension.
typedef signed int sint;
//! 32bit signed integer.
//! From GLM_GTX_unsigned_int extension.
typedef signed int sint;
//! Returns x raised to the y power.
//! From GLM_GTX_unsigned_int extension.
uint pow(uint x, uint y);
//! Returns x raised to the y power.
//! From GLM_GTX_unsigned_int extension.
uint pow(uint x, uint y);
//! Returns the positive square root of x.
//! From GLM_GTX_unsigned_int extension.
uint sqrt(uint x);
//! Returns the positive square root of x.
//! From GLM_GTX_unsigned_int extension.
uint sqrt(uint x);
//! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y.
//! From GLM_GTX_unsigned_int extension.
uint mod(uint x, uint y);
//! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y.
//! From GLM_GTX_unsigned_int extension.
uint mod(uint x, uint y);
///@}
///@}
}//namespace unsigned_int
}//namespace gtx
}//namespace unsigned_int
}//namespace gtx
}//namespace glm
#include "unsigned_int.inl"

139
glm/gtx/vec1.hpp
View File

@ -21,103 +21,96 @@
# pragma message("GLM: GLM_GTX_vec1 extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace vector1{ ///< GLM_GTX_vec1 extension: 1 component vector.
namespace precision
{
namespace test{
void main_gtx_vector1();
}//namespace test
//! 1 component vector of high precision floating-point numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::highp_vec1_t highp_vec1;
//! 1 component vector of medium precision floating-point numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::mediump_vec1_t mediump_vec1;
//! 1 component vector of low precision floating-point numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::lowp_vec1_t lowp_vec1;
namespace gtx{
//! GLM_GTX_vector1 extension: 1 component vector.
namespace vector1
{
namespace precision
{
//! 1 component vector of high precision floating-point numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::highp_vec1_t highp_vec1;
//! 1 component vector of medium precision floating-point numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::mediump_vec1_t mediump_vec1;
//! 1 component vector of low precision floating-point numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::lowp_vec1_t lowp_vec1;
//! 1 component vector of high precision signed integer numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::highp_ivec1_t highp_ivec1;
//! 1 component vector of medium precision signed integer numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::mediump_ivec1_t mediump_ivec1;
//! 1 component vector of low precision signed integer numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::lowp_ivec1_t lowp_ivec1;
//! 1 component vector of high precision signed integer numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::highp_ivec1_t highp_ivec1;
//! 1 component vector of medium precision signed integer numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::mediump_ivec1_t mediump_ivec1;
//! 1 component vector of low precision signed integer numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::lowp_ivec1_t lowp_ivec1;
//! 1 component vector of high precision unsigned integer numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::highp_uvec1_t highp_uvec1;
//! 1 component vector of medium precision unsigned integer numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::mediump_uvec1_t mediump_uvec1;
//! 1 component vector of low precision unsigned integer numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::lowp_uvec1_t lowp_uvec1;
}//namespace precision
//! 1 component vector of high precision unsigned integer numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::highp_uvec1_t highp_uvec1;
//! 1 component vector of medium precision unsigned integer numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::mediump_uvec1_t mediump_uvec1;
//! 1 component vector of low precision unsigned integer numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::lowp_uvec1_t lowp_uvec1;
}//namespace precision
//////////////////////////
// vec1 definition
//////////////////////////
// vec1 definition
//! 1 component vector of boolean.
//! From GLM_GTX_vec1 extension.
typedef detail::tvec1<bool> bvec1;
//! 1 component vector of boolean.
//! From GLM_GTX_vec1 extension.
typedef detail::tvec1<bool> bvec1;
#if(defined(GLM_PRECISION_HIGHP_FLOAT))
typedef precision::highp_vec1 vec1;
typedef precision::highp_vec1 vec1;
#elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
typedef precision::mediump_vec1 vec1;
typedef precision::mediump_vec1 vec1;
#elif(defined(GLM_PRECISION_LOWP_FLOAT))
typedef precision::lowp_vec1 vec1;
typedef precision::lowp_vec1 vec1;
#else
//! 1 component vector of floating-point numbers.
//! From GLM_GTX_vec1 extension.
typedef precision::mediump_vec1 vec1;
//! 1 component vector of floating-point numbers.
//! From GLM_GTX_vec1 extension.
typedef precision::mediump_vec1 vec1;
#endif//GLM_PRECISION
#if(defined(GLM_PRECISION_HIGHP_INT))
typedef precision::highp_ivec1 ivec1;
typedef precision::highp_ivec1 ivec1;
#elif(defined(GLM_PRECISION_MEDIUMP_INT))
typedef precision::mediump_ivec1 ivec1;
typedef precision::mediump_ivec1 ivec1;
#elif(defined(GLM_PRECISION_LOWP_INT))
typedef precision::lowp_ivec1 ivec1;
typedef precision::lowp_ivec1 ivec1;
#else
//! 1 component vector of signed integer numbers.
//! From GLM_GTX_vec1 extension.
typedef precision::mediump_ivec1 ivec1;
//! 1 component vector of signed integer numbers.
//! From GLM_GTX_vec1 extension.
typedef precision::mediump_ivec1 ivec1;
#endif//GLM_PRECISION
#if(defined(GLM_PRECISION_HIGHP_UINT))
typedef precision::highp_uvec1 uvec1;
typedef precision::highp_uvec1 uvec1;
#elif(defined(GLM_PRECISION_MEDIUMP_UINT))
typedef precision::mediump_uvec1 uvec1;
typedef precision::mediump_uvec1 uvec1;
#elif(defined(GLM_PRECISION_LOWP_UINT))
typedef precision::lowp_uvec1 uvec1;
typedef precision::lowp_uvec1 uvec1;
#else
//! 1 component vector of unsigned integer numbers.
//! From GLM_GTX_vec1 extension.
typedef precision::mediump_uvec1 uvec1;
//! 1 component vector of unsigned integer numbers.
//! From GLM_GTX_vec1 extension.
typedef precision::mediump_uvec1 uvec1;
#endif//GLM_PRECISION
}//namespace vec1
}//namespace gtx
}//namespace vec1
}//namespace gtx
}//namespace glm
#include "vec1.inl"

70
glm/gtx/vector_access.hpp
View File

@ -20,50 +20,44 @@
# pragma message("GLM: GLM_GTX_vector_access extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace vector_access ///< GLM_GTX_vector_access extension: Function to set values to vectors
{
namespace test{
void main_gtx_vector_access();
}//namespace test
/// \addtogroup gtx_vector_access
///@{
namespace gtx{
//! GLM_GTX_vector_access extension: Function to set values to vectors
namespace vector_access
{
/// \addtogroup gtx_vector_access
///@{
//! Set values to a 2 components vector.
//! From GLM_GTX_vector_access extension.
template <typename valType>
void set(
detail::tvec2<valType> & v,
valType const & x,
valType const & y);
//! Set values to a 2 components vector.
//! From GLM_GTX_vector_access extension.
template <typename valType>
void set(
detail::tvec2<valType> & v,
valType const & x,
valType const & y);
//! Set values to a 3 components vector.
//! From GLM_GTX_vector_access extension.
template <typename valType>
void set(
detail::tvec3<valType> & v,
valType const & x,
valType const & y,
valType const & z);
//! Set values to a 3 components vector.
//! From GLM_GTX_vector_access extension.
template <typename valType>
void set(
detail::tvec3<valType> & v,
valType const & x,
valType const & y,
valType const & z);
//! Set values to a 4 components vector.
//! From GLM_GTX_vector_access extension.
template <typename valType>
void set(
detail::tvec4<valType> & v,
valType const & x,
valType const & y,
valType const & z,
valType const & w);
//! Set values to a 4 components vector.
//! From GLM_GTX_vector_access extension.
template <typename valType>
void set(
detail::tvec4<valType> & v,
valType const & x,
valType const & y,
valType const & z,
valType const & w);
///@}
///@}
}//namespace vector_access
}//namespace gtx
}//namespace vector_access
}//namespace gtx
}//namespace glm
#include "vector_access.inl"

3
glm/gtx/vector_angle.hpp
View File

@ -27,8 +27,7 @@
namespace glm{
namespace gtx{
//! GLM_GTX_vector_angle extension: Compute angle between vectors
namespace vector_angle
namespace vector_angle ///< GLM_GTX_vector_angle extension: Compute angle between vectors
{
using namespace quaternion;
using namespace epsilon;

116
glm/gtx/vector_query.hpp
View File

@ -22,77 +22,71 @@
# pragma message("GLM: GLM_GTX_vector_query extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace vector_query ///< GLM_GTX_vector_query extension: Query informations of vector types
{
namespace test{
void main_ext_gtx_vector_query();
}//namespace test
/// \addtogroup gtx_vector_query
///@{
namespace gtx{
//! GLM_GTX_vector_query extension: Query informations of vector types
namespace vector_query
{
/// \addtogroup gtx_vector_query
///@{
//! Check if two vectors are collinears.
//! From GLM_GTX_vector_query extensions.
template <typename genType>
bool areCollinear(
genType const & v0,
genType const & v1,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if two vectors are collinears.
//! From GLM_GTX_vector_query extensions.
template <typename genType>
bool areCollinear(
genType const & v0,
genType const & v1,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if two vectors are opposites.
//! From GLM_GTX_vector_query extensions.
template <typename genType>
bool areOpposite(
genType const & v0,
genType const & v1,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if two vectors are opposites.
//! From GLM_GTX_vector_query extensions.
template <typename genType>
bool areOpposite(
genType const & v0,
genType const & v1,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if two vectors are orthogonals.
//! From GLM_GTX_vector_query extensions.
template <typename genType>
bool areOrthogonal(
genType const & v0,
genType const & v1,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if two vectors are orthogonals.
//! From GLM_GTX_vector_query extensions.
template <typename genType>
bool areOrthogonal(
genType const & v0,
genType const & v1,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if a vector is normalized.
//! From GLM_GTX_vector_query extensions.
template <typename genType>
bool isNormalized(
genType const & v,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if a vector is normalized.
//! From GLM_GTX_vector_query extensions.
template <typename genType>
bool isNormalized(
genType const & v,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if a vector is null.
//! From GLM_GTX_vector_query extensions.
template <typename genType>
bool isNull(
genType const & v,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if a vector is null.
//! From GLM_GTX_vector_query extensions.
template <typename genType>
bool isNull(
genType const & v,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if two vectors are orthonormal.
//! From GLM_GTX_vector_query extensions.
template <typename genType>
bool areOrthonormal(
genType const & v0,
genType const & v1,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if two vectors are orthonormal.
//! From GLM_GTX_vector_query extensions.
template <typename genType>
bool areOrthonormal(
genType const & v0,
genType const & v1,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if two vectors are similar.
//! From GLM_GTX_vector_query extensions.
template <typename genType>
bool areSimilar(
genType const & v0,
genType const & v1,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if two vectors are similar.
//! From GLM_GTX_vector_query extensions.
template <typename genType>
bool areSimilar(
genType const & v0,
genType const & v1,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
///@}
///@}
}//namespace vector_query
}//namespace gtx
}//namespace vector_query
}//namespace gtx
}//namespace glm
#include "vector_query.inl"

62
glm/gtx/verbose_operator.hpp
View File

@ -20,47 +20,41 @@
# pragma message("GLM: GLM_GTX_verbose_operator extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace verbose_operator ///< GLM_GTX_verbose_operator extension: Use words to replace operators
{
namespace test{
void main_ext_gtx_verbose_operator();
}//namespace test
/// \addtogroup gtx_verbose_operator
///@{
namespace gtx{
//! GLM_GTX_verbose_operator extension: Use words to replace operators
namespace verbose_operator
{
/// \addtogroup gtx_verbose_operator
///@{
//! Addition of two values
//! From GLM_GTX_verbose_operator extension.
template <typename genTypeT, typename genTypeU>
genTypeT add(genTypeT const & a, genTypeU const & b);
//! Addition of two values
//! From GLM_GTX_verbose_operator extension.
template <typename genTypeT, typename genTypeU>
genTypeT add(genTypeT const & a, genTypeU const & b);
//! Substration of two values
//! From GLM_GTX_verbose_operator extension.
template <typename genTypeT, typename genTypeU>
genTypeT sub(genTypeT const & a, genTypeU const & b);
//! Substration of two values
//! From GLM_GTX_verbose_operator extension.
template <typename genTypeT, typename genTypeU>
genTypeT sub(genTypeT const & a, genTypeU const & b);
//! Multiplication of two values
//! From GLM_GTX_verbose_operator extension.
template <typename genTypeT, typename genTypeU>
genTypeT mul(genTypeT const & a, genTypeU const & b);
//! Multiplication of two values
//! From GLM_GTX_verbose_operator extension.
template <typename genTypeT, typename genTypeU>
genTypeT mul(genTypeT const & a, genTypeU const & b);
//! Division of two values
//! From GLM_GTX_verbose_operator extension.
template <typename genTypeT, typename genTypeU>
genTypeT div(genTypeT const & a, genTypeU const & b);
//! Division of two values
//! From GLM_GTX_verbose_operator extension.
template <typename genTypeT, typename genTypeU>
genTypeT div(genTypeT const & a, genTypeU const & b);
//! Multiplication and addition of three values
//! From GLM_GTX_verbose_operator extension.
template <typename genTypeT, typename genTypeU, typename genTypeV>
genTypeT mad(genTypeT const & a, genTypeU const & b, genTypeV const & c);
//! Multiplication and addition of three values
//! From GLM_GTX_verbose_operator extension.
template <typename genTypeT, typename genTypeU, typename genTypeV>
genTypeT mad(genTypeT const & a, genTypeU const & b, genTypeV const & c);
///@}
}//namespace verbose_operator
}//namespace gtx
///@}
}//namespace verbose_operator
}//namespace gtx
}//namespace glm
#include "verbose_operator.inl"

46
glm/gtx/wrap.hpp
View File

@ -20,38 +20,32 @@
# pragma message("GLM: GLM_GTX_wrap extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace wrap ///< GLM_GTX_wrap: Wrapping mode using my texture samping.
{
namespace test{
bool main_gtx_wrap();
}//namespace test
/// \addtogroup gtx_wrap
///@{
namespace gtx{
//! GLM_GTX_wrap: Wrapping mode using my texture samping.
namespace wrap
{
/// \addtogroup gtx_wrap
///@{
//! Simulate GL_CLAMP OpenGL wrap mode
//! From GLM_GTX_wrap extension.
template <typename genType>
genType clamp(genType const & Texcoord);
//! Simulate GL_CLAMP OpenGL wrap mode
//! From GLM_GTX_wrap extension.
template <typename genType>
genType clamp(genType const & Texcoord);
//! Simulate GL_REPEAT OpenGL wrap mode
//! From GLM_GTX_wrap extension.
template <typename genType>
genType repeat(genType const & Texcoord);
//! Simulate GL_REPEAT OpenGL wrap mode
//! From GLM_GTX_wrap extension.
template <typename genType>
genType repeat(genType const & Texcoord);
//! Simulate GL_MIRROR_REPEAT OpenGL wrap mode
//! From GLM_GTX_wrap extension.
template <typename genType>
genType mirrorRepeat(genType const & Texcoord);
//! Simulate GL_MIRROR_REPEAT OpenGL wrap mode
//! From GLM_GTX_wrap extension.
template <typename genType>
genType mirrorRepeat(genType const & Texcoord);
///@}
///@}
}//namespace wrap
}//namespace gtx
}//namespace wrap
}//namespace gtx
}//namespace glm
#include "wrap.inl"