anulax
/
glm
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity

Fixed half precision implementation

Browse Source
master
Christophe Riccio ago%!(EXTRA string=12 years)
parent c14e2d7fbc
commit 296e3d7007
14 changed files with 776 additions and 500 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 7
      glm/core/type_half.hpp
  2. 104
      glm/core/type_mat.hpp
  3. 272
      glm/core/type_vec.hpp
  4. 95
      glm/fwd.hpp
  5. 276
      glm/gtc/half_float.hpp
  6. 396
      glm/gtc/half_float.inl
  7. 15
      glm/gtc/quaternion.hpp
  8. 12
      glm/gtc/quaternion.inl
  9. 4
      glm/gtx/dual_quaternion.hpp
  10. 12
      test/core/core_setup_precision.cpp
  11. 6
      test/core/core_type_vec2.cpp
  12. 73
      test/gtc/gtc_half_float.cpp
  13. 2
      test/gtc/gtc_quaternion.cpp
  14. 2
      test/gtx/gtx_bit.cpp

7
glm/core/type_half.hpp
Unescape View File

@ -121,14 +121,15 @@ namespace detail
/// High half-precision floating-point numbers.
typedef detail::half highp_half;
#if(!defined(GLM_PRECISION_HIGHP_HALF) && !defined(GLM_PRECISION_MEDIUMP_HALF) && !defined(GLM_PRECISION_LOWP_HALF))
typedef mediump_half half_t;
#elif(defined(GLM_PRECISION_HIGHP_HALF) && !defined(GLM_PRECISION_MEDIUMP_HALF) && !defined(GLM_PRECISION_LOWP_HALF))
#if(defined(GLM_PRECISION_HIGHP_HALF) && !defined(GLM_PRECISION_MEDIUMP_HALF) && !defined(GLM_PRECISION_LOWP_HALF))
typedef highp_half half_t;
#elif(!defined(GLM_PRECISION_HIGHP_HALF) && defined(GLM_PRECISION_MEDIUMP_HALF) && !defined(GLM_PRECISION_LOWP_HALF))
typedef mediump_half half_t;
#elif(!defined(GLM_PRECISION_HIGHP_HALF) && !defined(GLM_PRECISION_MEDIUMP_HALF) && defined(GLM_PRECISION_LOWP_HALF))
typedef lowp_half half_t;
#elif(!defined(GLM_PRECISION_HIGHP_HALF) && !defined(GLM_PRECISION_MEDIUMP_HALF) && !defined(GLM_PRECISION_LOWP_HALF))
/// Default half-precision floating-point numbers.
typedef highp_half half_t;
#else
# error "GLM error: Multiple default precisions requested for half-precision floating-point types"
#endif

104
glm/core/type_mat.hpp
Unescape View File

@ -370,16 +370,16 @@ namespace detail
//////////////////////////
// Float definition
#if(defined(GLM_PRECISION_HIGHP_FLOAT))
typedef highp_mat2x2 mat2x2;
typedef highp_mat2x3 mat2x3;
typedef highp_mat2x4 mat2x4;
typedef highp_mat3x2 mat3x2;
typedef highp_mat3x3 mat3x3;
typedef highp_mat3x4 mat3x4;
typedef highp_mat4x2 mat4x2;
typedef highp_mat4x3 mat4x3;
typedef highp_mat4x4 mat4x4;
#if(defined(GLM_PRECISION_LOWP_FLOAT))
typedef lowp_mat2x2 mat2x2;
typedef lowp_mat2x3 mat2x3;
typedef lowp_mat2x4 mat2x4;
typedef lowp_mat3x2 mat3x2;
typedef lowp_mat3x3 mat3x3;
typedef lowp_mat3x4 mat3x4;
typedef lowp_mat4x2 mat4x2;
typedef lowp_mat4x3 mat4x3;
typedef lowp_mat4x4 mat4x4;
#elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
typedef mediump_mat2x2 mat2x2;
typedef mediump_mat2x3 mat2x3;
@ -390,61 +390,51 @@ namespace detail
typedef mediump_mat4x2 mat4x2;
typedef mediump_mat4x3 mat4x3;
typedef mediump_mat4x4 mat4x4;
#elif(defined(GLM_PRECISION_LOWP_FLOAT))
typedef lowp_mat2x2 mat2x2;
typedef lowp_mat2x3 mat2x3;
typedef lowp_mat2x4 mat2x4;
typedef lowp_mat3x2 mat3x2;
typedef lowp_mat3x3 mat3x3;
typedef lowp_mat3x4 mat3x4;
typedef lowp_mat4x2 mat4x2;
typedef lowp_mat4x3 mat4x3;
typedef lowp_mat4x4 mat4x4;
#else
//! 2 columns of 2 components matrix of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_mat2x2 mat2x2;
typedef highp_mat2x2 mat2x2;
//! 2 columns of 3 components matrix of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_mat2x3 mat2x3;
typedef highp_mat2x3 mat2x3;
//! 2 columns of 4 components matrix of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_mat2x4 mat2x4;
typedef highp_mat2x4 mat2x4;
//! 3 columns of 2 components matrix of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_mat3x2 mat3x2;
typedef highp_mat3x2 mat3x2;
//! 3 columns of 3 components matrix of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_mat3x3 mat3x3;
typedef highp_mat3x3 mat3x3;
//! 3 columns of 4 components matrix of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_mat3x4 mat3x4;
typedef highp_mat3x4 mat3x4;
//! 4 columns of 2 components matrix of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_mat4x2 mat4x2;
typedef highp_mat4x2 mat4x2;
//! 4 columns of 3 components matrix of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_mat4x3 mat4x3;
typedef highp_mat4x3 mat4x3;
//! 4 columns of 4 components matrix of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_mat4x4 mat4x4;
typedef highp_mat4x4 mat4x4;
#endif//GLM_PRECISION
@ -727,16 +717,16 @@ namespace detail
/// @}
#if(defined(GLM_PRECISION_HIGHP_DOUBLE))
typedef highp_dmat2x2 dmat2x2;
typedef highp_dmat2x3 dmat2x3;
typedef highp_dmat2x4 dmat2x4;
typedef highp_dmat3x2 dmat3x2;
typedef highp_dmat3x3 dmat3x3;
typedef highp_dmat3x4 dmat3x4;
typedef highp_dmat4x2 dmat4x2;
typedef highp_dmat4x3 dmat4x3;
typedef highp_dmat4x4 dmat4x4;
#if(defined(GLM_PRECISION_LOWP_DOUBLE))
typedef lowp_dmat2x2 dmat2x2;
typedef lowp_dmat2x3 dmat2x3;
typedef lowp_dmat2x4 dmat2x4;
typedef lowp_dmat3x2 dmat3x2;
typedef lowp_dmat3x3 dmat3x3;
typedef lowp_dmat3x4 dmat3x4;
typedef lowp_dmat4x2 dmat4x2;
typedef lowp_dmat4x3 dmat4x3;
typedef lowp_dmat4x4 dmat4x4;
#elif(defined(GLM_PRECISION_MEDIUMP_DOUBLE))
typedef mediump_dmat2x2 dmat2x2;
typedef mediump_dmat2x3 dmat2x3;
@ -747,77 +737,67 @@ namespace detail
typedef mediump_dmat4x2 dmat4x2;
typedef mediump_dmat4x3 dmat4x3;
typedef mediump_dmat4x4 dmat4x4;
#elif(defined(GLM_PRECISION_LOWP_DOUBLE))
typedef lowp_dmat2x2 dmat2x2;
typedef lowp_dmat2x3 dmat2x3;
typedef lowp_dmat2x4 dmat2x4;
typedef lowp_dmat3x2 dmat3x2;
typedef lowp_dmat3x3 dmat3x3;
typedef lowp_dmat3x4 dmat3x4;
typedef lowp_dmat4x2 dmat4x2;
typedef lowp_dmat4x3 dmat4x3;
typedef lowp_dmat4x4 dmat4x4;
#else
#else //defined(GLM_PRECISION_HIGHP_DOUBLE)
//! 2 * 2 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_dmat2x2 dmat2;
typedef highp_dmat2x2 dmat2;
//! 3 * 3 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_dmat3x3 dmat3;
typedef highp_dmat3x3 dmat3;
//! 4 * 4 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_dmat4x4 dmat4;
typedef highp_dmat4x4 dmat4;
//! 2 * 2 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_dmat2x2 dmat2x2;
typedef highp_dmat2x2 dmat2x2;
//! 2 * 3 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_dmat2x3 dmat2x3;
typedef highp_dmat2x3 dmat2x3;
//! 2 * 4 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_dmat2x4 dmat2x4;
typedef highp_dmat2x4 dmat2x4;
//! 3 * 2 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_dmat3x2 dmat3x2;
typedef highp_dmat3x2 dmat3x2;
/// 3 * 3 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_dmat3x3 dmat3x3;
typedef highp_dmat3x3 dmat3x3;
/// 3 * 4 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_dmat3x4 dmat3x4;
typedef highp_dmat3x4 dmat3x4;
/// 4 * 2 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_dmat4x2 dmat4x2;
typedef highp_dmat4x2 dmat4x2;
/// 4 * 3 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_dmat4x3 dmat4x3;
typedef highp_dmat4x3 dmat4x3;
/// 4 * 4 matrix of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef mediump_dmat4x4 dmat4x4;
typedef highp_dmat4x4 dmat4x4;
#endif//GLM_PRECISION

272
glm/core/type_vec.hpp
Unescape View File

@ -74,27 +74,48 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// 2 components vector of high precision floating-point numbers.
/// 2 components vector of high single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<float, highp> highp_vec2;
/// 2 components vector of medium precision floating-point numbers.
/// 2 components vector of medium single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<float, mediump> mediump_vec2;
/// 2 components vector of low precision floating-point numbers.
/// 2 components vector of low single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<float, lowp> lowp_vec2;
/// 2 components vector of high double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<double, highp> highp_dvec2;
/// 2 components vector of medium double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<double, mediump> mediump_dvec2;
/// 2 components vector of low double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<double, lowp> lowp_dvec2;
/// 2 components vector of high precision signed integer numbers.
/// There is no guarantee on the actual precision.
///
@ -136,6 +157,27 @@ namespace detail
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<uint, lowp> lowp_uvec2;
/// 2 components vector of high precision bool numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<bool, highp> highp_bvec2;
/// 2 components vector of medium precision bool numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<bool, mediump> mediump_bvec2;
/// 2 components vector of low precision bool numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec2<bool, lowp> lowp_bvec2;
/// @}
@ -143,27 +185,48 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// 3 components vector of high precision floating-point numbers.
/// 3 components vector of high single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<float, highp> highp_vec3;
/// 3 components vector of medium precision floating-point numbers.
/// 3 components vector of medium single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<float, mediump> mediump_vec3;
/// 3 components vector of low precision floating-point numbers.
/// 3 components vector of low single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<float, lowp> lowp_vec3;
/// 3 components vector of high double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<double, highp> highp_dvec3;
/// 3 components vector of medium double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<double, mediump> mediump_dvec3;
/// 3 components vector of low double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<double, lowp> lowp_dvec3;
/// 3 components vector of high precision signed integer numbers.
/// There is no guarantee on the actual precision.
///
@ -206,73 +269,118 @@ namespace detail
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<uint, lowp> lowp_uvec3;
/// 3 components vector of high precision bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<bool, highp> highp_bvec3;
/// 3 components vector of medium precision bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<bool, mediump> mediump_bvec3;
/// 3 components vector of low precision bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec3<bool, lowp> lowp_bvec3;
/// @}
/// @addtogroup core_precision
/// @{
/// 4 components vector of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 4 components vector of high single-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<float, highp> highp_vec4;
/// 4 components vector of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 4 components vector of medium single-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<float, mediump> mediump_vec4;
/// 4 components vector of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 4 components vector of low single-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<float, lowp> lowp_vec4;
/// 4 components vector of high double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<double, highp> highp_dvec4;
/// 4 components vector of medium double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<double, mediump> mediump_dvec4;
/// 4 components vector of low double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<double, lowp> lowp_dvec4;
/// 4 components vector of high precision signed integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<int, highp> highp_ivec4;
/// 4 components vector of medium precision signed integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<int, mediump> mediump_ivec4;
/// 4 components vector of low precision signed integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<int, lowp> lowp_ivec4;
/// 4 components vector of high precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<uint, highp> highp_uvec4;
/// 4 components vector of medium precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<uint, mediump> mediump_uvec4;
/// 4 components vector of low precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<uint, lowp> lowp_uvec4;
/// 4 components vector of high precision bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<bool, highp> highp_bvec4;
/// 4 components vector of medium precision bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<bool, mediump> mediump_bvec4;
/// 4 components vector of low precision bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::tvec4<bool, lowp> lowp_bvec4;
/// @}
@ -280,136 +388,144 @@ namespace detail
/// @{
//////////////////////////
// Float definition
// Default float definition
#if(defined(GLM_PRECISION_HIGHP_FLOAT))
typedef highp_vec2 vec2;
typedef highp_vec3 vec3;
typedef highp_vec4 vec4;
#if(defined(GLM_PRECISION_LOWP_FLOAT))
typedef lowp_vec2 vec2;
typedef lowp_vec3 vec3;
typedef lowp_vec4 vec4;
#elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
typedef mediump_vec2 vec2;
typedef mediump_vec3 vec3;
typedef mediump_vec4 vec4;
#elif(defined(GLM_PRECISION_LOWP_FLOAT))
typedef lowp_vec2 vec2;
typedef lowp_vec3 vec3;
typedef lowp_vec4 vec4;
#else
#else //defined(GLM_PRECISION_HIGHP_FLOAT)
/// 2 components vector of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef mediump_vec2 vec2;
typedef highp_vec2 vec2;
//! 3 components vector of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef mediump_vec3 vec3;
typedef highp_vec3 vec3;
//! 4 components vector of floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef mediump_vec4 vec4;
typedef highp_vec4 vec4;
#endif//GLM_PRECISION
//////////////////////////
// Default double definition
#if(defined(GLM_PRECISION_LOWP_DOUBLE))
typedef lowp_dvec2 dvec2;
typedef lowp_dvec3 dvec3;
typedef lowp_dvec4 dvec4;
#elif(defined(GLM_PRECISION_MEDIUMP_DOUBLE))
typedef mediump_dvec2 dvec2;
typedef mediump_dvec3 dvec3;
typedef mediump_dvec4 dvec4;
#else //defined(GLM_PRECISION_HIGHP_DOUBLE)
/// 2 components vector of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef highp_dvec2 dvec2;
//! 3 components vector of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef highp_dvec3 dvec3;
//! 4 components vector of double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef highp_dvec4 dvec4;
#endif//GLM_PRECISION
//////////////////////////
// Signed integer definition
#if(defined(GLM_PRECISION_HIGHP_INT))
typedef highp_ivec2 ivec2;
typedef highp_ivec3 ivec3;
typedef highp_ivec4 ivec4;
#if(defined(GLM_PRECISION_LOWP_INT))
typedef lowp_ivec2 ivec2;
typedef lowp_ivec3 ivec3;
typedef lowp_ivec4 ivec4;
#elif(defined(GLM_PRECISION_MEDIUMP_INT))
typedef mediump_ivec2 ivec2;
typedef mediump_ivec3 ivec3;
typedef mediump_ivec4 ivec4;
#elif(defined(GLM_PRECISION_LOWP_INT))
typedef lowp_ivec2 ivec2;
typedef lowp_ivec3 ivec3;
typedef lowp_ivec4 ivec4;
#else
#else //defined(GLM_PRECISION_HIGHP_INT)
//! 2 components vector of signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef mediump_ivec2 ivec2;
typedef highp_ivec2 ivec2;
//! 3 components vector of signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef mediump_ivec3 ivec3;
typedef highp_ivec3 ivec3;
//! 4 components vector of signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef mediump_ivec4 ivec4;
typedef highp_ivec4 ivec4;
#endif//GLM_PRECISION
//////////////////////////
// Unsigned integer definition
#if(defined(GLM_PRECISION_HIGHP_UINT))
typedef highp_uvec2 uvec2;
typedef highp_uvec3 uvec3;
typedef highp_uvec4 uvec4;
#if(defined(GLM_PRECISION_LOWP_UINT))
typedef lowp_uvec2 uvec2;
typedef lowp_uvec3 uvec3;
typedef lowp_uvec4 uvec4;
#elif(defined(GLM_PRECISION_MEDIUMP_UINT))
typedef mediump_uvec2 uvec2;
typedef mediump_uvec3 uvec3;
typedef mediump_uvec4 uvec4;
#elif(defined(GLM_PRECISION_LOWP_UINT))
typedef lowp_uvec2 uvec2;
typedef lowp_uvec3 uvec3;
typedef lowp_uvec4 uvec4;
#else
#else //defined(GLM_PRECISION_HIGHP_UINT)
/// 2 components vector of unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef mediump_uvec2 uvec2;
typedef highp_uvec2 uvec2;
/// 3 components vector of unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef mediump_uvec3 uvec3;
typedef highp_uvec3 uvec3;
/// 4 components vector of unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef mediump_uvec4 uvec4;
typedef highp_uvec4 uvec4;
#endif//GLM_PRECISION
//////////////////////////
// Boolean definition
#if(defined(GLM_PRECISION_LOWP_BOOL))
typedef lowp_bvec2 bvec2;
typedef lowp_bvec3 bvec3;
typedef lowp_bvec4 bvec4;
#elif(defined(GLM_PRECISION_MEDIUMP_BOOL))
typedef mediump_bvec2 bvec2;
typedef mediump_bvec3 bvec3;
typedef mediump_bvec4 bvec4;
#else //defined(GLM_PRECISION_HIGHP_BOOL)
//! 2 components vector of boolean.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef detail::tvec2<bool, mediump> bvec2;
typedef highp_bvec2 bvec2;
//! 3 components vector of boolean.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef detail::tvec3<bool, mediump> bvec3;
typedef highp_bvec3 bvec3;
//! 4 components vector of boolean.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef detail::tvec4<bool, mediump> bvec4;
//////////////////////////
// Double definition
//! Vector of 2 double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef detail::tvec2<double, mediump> dvec2;
//! Vector of 3 double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef detail::tvec3<double, mediump> dvec3;
//! Vector of 4 double-precision floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef detail::tvec4<double, mediump> dvec4;
typedef highp_bvec4 bvec4;
#endif//GLM_PRECISION
/// @}
}//namespace glm

95
glm/fwd.hpp
Unescape View File

@ -47,40 +47,107 @@ namespace detail
template <typename T, precision P> struct tquat;
}//namespace detail
/// Quaternion of floating-point numbers.
/// Quaternion of low half-precision floating-point numbers.
///
/// @see gtc_quaternion
typedef detail::tquat<float, mediump> quat;
typedef detail::tquat<half, lowp> lowp_hquat;
/// Quaternion of half-precision floating-point numbers.
/// Quaternion of medium half-precision floating-point numbers.
///
/// @see gtc_quaternion
typedef detail::tquat<detail::half, mediump> hquat;
typedef detail::tquat<half, mediump> mediump_hquat;
/// Quaternion of high half-precision floating-point numbers.
///
/// @see gtc_quaternion
typedef detail::tquat<half, highp> highp_hquat;
#if(defined(GLM_PRECISION_HIGHP_HALF) && !defined(GLM_PRECISION_MEDIUMP_HALF) && !defined(GLM_PRECISION_LOWP_HALF))
typedef highp_hquat hquat;
#elif(!defined(GLM_PRECISION_HIGHP_HALF) && defined(GLM_PRECISION_MEDIUMP_HALF) && !defined(GLM_PRECISION_LOWP_HALF))
typedef mediump_hquat hquat;
#elif(!defined(GLM_PRECISION_HIGHP_HALF) && !defined(GLM_PRECISION_MEDIUMP_HALF) && defined(GLM_PRECISION_LOWP_HALF))
typedef lowp_hquat hquat;
#elif(!defined(GLM_PRECISION_HIGHP_HALF) && !defined(GLM_PRECISION_MEDIUMP_HALF) && !defined(GLM_PRECISION_LOWP_HALF))
/// Default half-precision floating-point numbers.
typedef highp_hquat hquat;
#endif
/// Quaternion of low single-precision floating-point numbers.
///
/// @see gtc_quaternion
typedef detail::tquat<float, lowp> lowp_quat;
/// Quaternion of medium single-precision floating-point numbers.
///
/// @see gtc_quaternion
typedef detail::tquat<float, mediump> mediump_quat;
/// Quaternion of high single-precision floating-point numbers.
///
/// @see gtc_quaternion
typedef detail::tquat<float, highp> highp_quat;
#if(defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
typedef highp_quat quat;
#elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
typedef mediump_quat quat;
#elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && defined(GLM_PRECISION_LOWP_FLOAT))
typedef lowp_quat quat;
#elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
/// Quaternion of default single-precision floating-point numbers.
typedef highp_quat quat;
#endif
/// Quaternion of low single-precision floating-point numbers.
///
/// @see gtc_quaternion
typedef lowp_quat lowp_fquat;
/// Quaternion of medium single-precision floating-point numbers.
///
/// @see gtc_quaternion
typedef mediump_quat mediump_fquat;
/// Quaternion of single-precision floating-point numbers.
/// Quaternion of high single-precision floating-point numbers.
///
/// @see gtc_quaternion
typedef detail::tquat<float, mediump> fquat;
typedef highp_quat highp_fquat;
/// Quaternion of double-precision floating-point numbers.
/// Quaternion of default single-precision floating-point numbers.
///
/// @see gtc_quaternion
typedef detail::tquat<double, mediump> dquat;
typedef quat fquat;
/// Quaternion of low precision floating-point numbers.
/// Quaternion of low double-precision floating-point numbers.
///
/// @see gtc_quaternion
typedef detail::tquat<float, lowp> lowp_quat;
typedef detail::tquat<double, lowp> lowp_dquat;
/// Quaternion of medium precision floating-point numbers.
/// Quaternion of medium double-precision floating-point numbers.
///
/// @see gtc_quaternion
typedef detail::tquat<float, mediump> mediump_quat;
typedef detail::tquat<double, mediump> mediump_dquat;
/// Quaternion of high precision floating-point numbers.
/// Quaternion of high double-precision floating-point numbers.
///
/// @see gtc_quaternion
typedef detail::tquat<double, highp> highp_dquat;
#if(defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE))
typedef highp_dquat dquat;
#elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE))
typedef mediump_dquat dquat;
#elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && defined(GLM_PRECISION_LOWP_DOUBLE))
typedef lowp_dquat dquat;
#elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE))
/// Quaternion of default double-precision floating-point numbers.
///
/// @see gtc_quaternion
typedef detail::tquat<float, highp> highp_quat;
typedef highp_dquat dquat;
#endif
}//namespace glm

276
glm/gtc/half_float.hpp
Unescape View File

@ -48,8 +48,8 @@ namespace glm{
namespace detail
{
#if(GLM_COMPONENT == GLM_COMPONENT_CXX98)
template <>
struct tvec2<half, defaultp>
template <precision P>
struct tvec2<half, P>
{
enum ctor{null};
typedef half value_type;
@ -58,8 +58,8 @@ namespace detail
GLM_FUNC_DECL size_type length() const;
static GLM_FUNC_DECL size_type value_size();
typedef tvec2<half, defaultp> type;
typedef tvec2<bool, defaultp> bool_type;
typedef tvec2<half, P> type;
typedef tvec2<bool, P> bool_type;
//////////////////////////////////////
// Data
@ -76,7 +76,7 @@ namespace detail
// Implicit basic constructors
tvec2();
tvec2(tvec2<half, defaultp> const & v);
tvec2(tvec2<half, P> const & v);
//////////////////////////////////////
// Explicit basic constructors
@ -91,7 +91,7 @@ namespace detail
//////////////////////////////////////
// Swizzle constructors
tvec2(tref2<half, defaultp> const & r);
tvec2(tref2<half, P> const & r);
//////////////////////////////////////
// Convertion scalar constructors
@ -108,42 +108,42 @@ namespace detail
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec2(tvec2<U, defaultp> const & v);
explicit tvec2(tvec2<U, P> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec2(tvec3<U, defaultp> const & v);
explicit tvec2(tvec3<U, P> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec2(tvec4<U, defaultp> const & v);
explicit tvec2(tvec4<U, P> const & v);
//////////////////////////////////////
// Unary arithmetic operators
tvec2<half, defaultp>& operator= (tvec2<half, defaultp> const & v);
tvec2<half, P>& operator= (tvec2<half, P> const & v);
tvec2<half, defaultp>& operator+=(half const & s);
tvec2<half, defaultp>& operator+=(tvec2<half, defaultp> const & v);
tvec2<half, defaultp>& operator-=(half const & s);
tvec2<half, defaultp>& operator-=(tvec2<half, defaultp> const & v);
tvec2<half, defaultp>& operator*=(half const & s);
tvec2<half, defaultp>& operator*=(tvec2<half, defaultp> const & v);
tvec2<half, defaultp>& operator/=(half const & s);
tvec2<half, defaultp>& operator/=(tvec2<half, defaultp> const & v);
tvec2<half, defaultp>& operator++();
tvec2<half, defaultp>& operator--();
tvec2<half, P>& operator+=(half const & s);
tvec2<half, P>& operator+=(tvec2<half, P> const & v);
tvec2<half, P>& operator-=(half const & s);
tvec2<half, P>& operator-=(tvec2<half, P> const & v);
tvec2<half, P>& operator*=(half const & s);
tvec2<half, P>& operator*=(tvec2<half, P> const & v);
tvec2<half, P>& operator/=(half const & s);
tvec2<half, P>& operator/=(tvec2<half, P> const & v);
tvec2<half, P>& operator++();
tvec2<half, P>& operator--();
//////////////////////////////////////
// Swizzle operators
half swizzle(comp X) const;
tvec2<half, defaultp> swizzle(comp X, comp Y) const;
tvec3<half, defaultp> swizzle(comp X, comp Y, comp Z) const;
tvec4<half, defaultp> swizzle(comp X, comp Y, comp Z, comp W) const;
tref2<half, defaultp> swizzle(comp X, comp Y);
tvec2<half, P> swizzle(comp X, comp Y) const;
tvec3<half, P> swizzle(comp X, comp Y, comp Z) const;
tvec4<half, P> swizzle(comp X, comp Y, comp Z, comp W) const;
tref2<half, P> swizzle(comp X, comp Y);
};
template <>
struct tvec3<half, defaultp>
template <precision P>
struct tvec3<half, P>
{
enum ctor{null};
typedef half value_type;
@ -151,8 +151,8 @@ namespace detail
GLM_FUNC_DECL size_type length() const;
static GLM_FUNC_DECL size_type value_size();
typedef tvec3<half, defaultp> type;
typedef tvec3<bool, defaultp> bool_type;
typedef tvec3<half, P> type;
typedef tvec3<bool, P> bool_type;
//////////////////////////////////////
// Data
@ -169,7 +169,7 @@ namespace detail
// Implicit basic constructors
tvec3();
tvec3(tvec3<half, defaultp> const & v);
tvec3(tvec3<half, P> const & v);
//////////////////////////////////////
// Explicit basic constructors
@ -185,7 +185,7 @@ namespace detail
//////////////////////////////////////
// Swizzle constructors
tvec3(tref3<half, defaultp> const & r);
tvec3(tref3<half, P> const & r);
//////////////////////////////////////
// Convertion scalar constructors
@ -202,45 +202,45 @@ namespace detail
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
explicit tvec3(tvec2<A, defaultp> const & v, B const & s);
explicit tvec3(tvec2<A, P> const & v, B const & s);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
explicit tvec3(A const & s, tvec2<B, defaultp> const & v);
explicit tvec3(A const & s, tvec2<B, P> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec3(tvec3<U, defaultp> const & v);
explicit tvec3(tvec3<U, P> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec3(tvec4<U, defaultp> const & v);
explicit tvec3(tvec4<U, P> const & v);
//////////////////////////////////////
// Unary arithmetic operators
tvec3<half, defaultp>& operator= (tvec3<half, defaultp> const & v);
tvec3<half, P>& operator= (tvec3<half, P> const & v);
tvec3<half, defaultp>& operator+=(half const & s);
tvec3<half, defaultp>& operator+=(tvec3<half, defaultp> const & v);
tvec3<half, defaultp>& operator-=(half const & s);
tvec3<half, defaultp>& operator-=(tvec3<half, defaultp> const & v);
tvec3<half, defaultp>& operator*=(half const & s);
tvec3<half, defaultp>& operator*=(tvec3<half, defaultp> const & v);
tvec3<half, defaultp>& operator/=(half const & s);
tvec3<half, defaultp>& operator/=(tvec3<half, defaultp> const & v);
tvec3<half, defaultp>& operator++();
tvec3<half, defaultp>& operator--();
tvec3<half, P>& operator+=(half const & s);
tvec3<half, P>& operator+=(tvec3<half, P> const & v);
tvec3<half, P>& operator-=(half const & s);
tvec3<half, P>& operator-=(tvec3<half, P> const & v);
tvec3<half, P>& operator*=(half const & s);
tvec3<half, P>& operator*=(tvec3<half, P> const & v);
tvec3<half, P>& operator/=(half const & s);
tvec3<half, P>& operator/=(tvec3<half, P> const & v);
tvec3<half, P>& operator++();
tvec3<half, P>& operator--();
//////////////////////////////////////
// Swizzle operators
half swizzle(comp X) const;
tvec2<half, defaultp> swizzle(comp X, comp Y) const;
tvec3<half, defaultp> swizzle(comp X, comp Y, comp Z) const;
tvec4<half, defaultp> swizzle(comp X, comp Y, comp Z, comp W) const;
tref3<half, defaultp> swizzle(comp X, comp Y, comp Z);
tvec2<half, P> swizzle(comp X, comp Y) const;
tvec3<half, P> swizzle(comp X, comp Y, comp Z) const;
tvec4<half, P> swizzle(comp X, comp Y, comp Z, comp W) const;
tref3<half, P> swizzle(comp X, comp Y, comp Z);
};
template <>
struct tvec4<half, defaultp>
template <precision P>
struct tvec4<half, P>
{
enum ctor{null};
typedef half value_type;
@ -248,8 +248,8 @@ namespace detail
GLM_FUNC_DECL size_type length() const;
static GLM_FUNC_DECL size_type value_size();
typedef tvec4<half, defaultp> type;
typedef tvec4<bool, defaultp> bool_type;
typedef tvec4<half, P> type;
typedef tvec4<bool, P> bool_type;
//////////////////////////////////////
// Data
@ -266,7 +266,7 @@ namespace detail
// Implicit basic constructors
tvec4();
tvec4(tvec4<half, defaultp> const & v);
tvec4(tvec4<half, P> const & v);
//////////////////////////////////////
// Explicit basic constructors
@ -283,7 +283,7 @@ namespace detail
//////////////////////////////////////
// Swizzle constructors
tvec4(tref4<half, defaultp> const & r);
tvec4(tref4<half, P> const & r);
//////////////////////////////////////
// Convertion scalar constructors
@ -300,50 +300,50 @@ namespace detail
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C>
explicit tvec4(tvec2<A, defaultp> const & v, B const & s1, C const & s2);
explicit tvec4(tvec2<A, P> const & v, B const & s1, C const & s2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C>
explicit tvec4(A const & s1, tvec2<B, defaultp> const & v, C const & s2);
explicit tvec4(A const & s1, tvec2<B, P> const & v, C const & s2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C>
explicit tvec4(A const & s1, B const & s2, tvec2<C, defaultp> const & v);
explicit tvec4(A const & s1, B const & s2, tvec2<C, P> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
explicit tvec4(tvec3<A, defaultp> const & v, B const & s);
explicit tvec4(tvec3<A, P> const & v, B const & s);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
explicit tvec4(A const & s, tvec3<B, defaultp> const & v);
explicit tvec4(A const & s, tvec3<B, P> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
explicit tvec4(tvec2<A, defaultp> const & v1, tvec2<B, defaultp> const & v2);
explicit tvec4(tvec2<A, P> const & v1, tvec2<B, P> const & v2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec4(tvec4<U, defaultp> const & v);
explicit tvec4(tvec4<U, P> const & v);
//////////////////////////////////////
// Unary arithmetic operators
tvec4<half, defaultp>& operator= (tvec4<half, defaultp> const & v);
tvec4<half, P>& operator= (tvec4<half, P> const & v);
tvec4<half, defaultp>& operator+=(half const & s);
tvec4<half, defaultp>& operator+=(tvec4<half, defaultp> const & v);
tvec4<half, defaultp>& operator-=(half const & s);
tvec4<half, defaultp>& operator-=(tvec4<half, defaultp> const & v);
tvec4<half, defaultp>& operator*=(half const & s);
tvec4<half, defaultp>& operator*=(tvec4<half, defaultp> const & v);
tvec4<half, defaultp>& operator/=(half const & s);
tvec4<half, defaultp>& operator/=(tvec4<half, defaultp> const & v);
tvec4<half, defaultp>& operator++();
tvec4<half, defaultp>& operator--();
tvec4<half, P>& operator+=(half const & s);
tvec4<half, P>& operator+=(tvec4<half, P> const & v);
tvec4<half, P>& operator-=(half const & s);
tvec4<half, P>& operator-=(tvec4<half, P> const & v);
tvec4<half, P>& operator*=(half const & s);
tvec4<half, P>& operator*=(tvec4<half, P> const & v);
tvec4<half, P>& operator/=(half const & s);
tvec4<half, P>& operator/=(tvec4<half, P> const & v);
tvec4<half, P>& operator++();
tvec4<half, P>& operator--();
//////////////////////////////////////
// Swizzle operators
half swizzle(comp X) const;
tvec2<half, defaultp> swizzle(comp X, comp Y) const;
tvec3<half, defaultp> swizzle(comp X, comp Y, comp Z) const;
tvec4<half, defaultp> swizzle(comp X, comp Y, comp Z, comp W) const;
tref4<half, defaultp> swizzle(comp X, comp Y, comp Z, comp W);
tvec2<half, P> swizzle(comp X, comp Y) const;
tvec3<half, P> swizzle(comp X, comp Y, comp Z) const;
tvec4<half, P> swizzle(comp X, comp Y, comp Z, comp W) const;
tref4<half, P> swizzle(comp X, comp Y, comp Z, comp W);
};
#endif//(GLM_COMPONENT == GLM_COMPONENT_CXX98)
}
@ -548,123 +548,105 @@ namespace detail
/// Type for default half-precision floating-point numbers.
/// @see gtc_half_float
typedef half_t half;
#if(!defined(GLM_PRECISION_HIGHP_HALF) && !defined(GLM_PRECISION_MEDIUMP_HALF) && !defined(GLM_PRECISION_LOWP_HALF))
typedef half_t half;
#if(!defined(GLM_PRECISION_HIGHP_HALF) && !defined(GLM_PRECISION_MEDIUMP_HALF) && defined(GLM_PRECISION_LOWP_HALF))
typedef lowp_hvec2 hvec2;
typedef lowp_hvec3 hvec3;
typedef lowp_hvec4 hvec4;
typedef lowp_hmat2 hmat2;
typedef lowp_hmat3 hmat3;
typedef lowp_hmat4 hmat4;
typedef lowp_hmat2x2 hmat2x2;
typedef lowp_hmat2x3 hmat2x3;
typedef lowp_hmat2x4 hmat2x4;
typedef lowp_hmat3x2 hmat3x2;
typedef lowp_hmat3x3 hmat3x3;
typedef lowp_hmat3x4 hmat3x4;
typedef lowp_hmat4x2 hmat4x2;
typedef lowp_hmat4x3 hmat4x3;
typedef lowp_hmat4x4 hmat4x4;
#elif(!defined(GLM_PRECISION_HIGHP_HALF) && defined(GLM_PRECISION_MEDIUMP_HALF) && !defined(GLM_PRECISION_LOWP_HALF))
typedef mediump_hvec2 hvec2;
typedef mediump_hvec3 hvec3;
typedef mediump_hvec4 hvec4;
typedef mediump_hmat2 hmat2;
typedef mediump_hmat3 hmat3;
typedef mediump_hmat4 hmat4;
typedef mediump_hmat2x2 hmat2x2;
typedef mediump_hmat2x3 hmat2x3;
typedef mediump_hmat2x4 hmat2x4;
typedef mediump_hmat3x2 hmat3x2;
typedef mediump_hmat3x3 hmat3x3;
typedef mediump_hmat3x4 hmat3x4;
typedef mediump_hmat4x2 hmat4x2;
typedef mediump_hmat4x3 hmat4x3;
typedef mediump_hmat4x4 hmat4x4;
#else //(!defined(GLM_PRECISION_HIGHP_HALF) && !defined(GLM_PRECISION_MEDIUMP_HALF) && !defined(GLM_PRECISION_LOWP_HALF))
//////////////////////////////////////////////
// Default half precision floating-point numbers.
/// Vector of 2 default half-precision floating-point numbers.
/// @see gtc_half_float
typedef mediump_hvec2 hvec2;
typedef highp_hvec2 hvec2;
/// Vector of 3 default half-precision floating-point numbers.
/// @see gtc_half_float
typedef mediump_hvec3 hvec3;
typedef highp_hvec3 hvec3;
/// Vector of 4 default half-precision floating-point numbers.
/// @see gtc_half_float
typedef mediump_hvec4 hvec4;
typedef highp_hvec4 hvec4;
/// 2 * 2 matrix of default half-precision floating-point numbers.
/// @see gtc_half_float
typedef mediump_hmat2x2 hmat2;
typedef highp_hmat2x2 hmat2;
/// 3 * 3 matrix of default half-precision floating-point numbers.
/// @see gtc_half_float
typedef mediump_hmat3x3 hmat3;
typedef highp_hmat3x3 hmat3;
/// 4 * 4 matrix of default half-precision floating-point numbers.
/// @see gtc_half_float
typedef mediump_hmat4x4 hmat4;
typedef highp_hmat4x4 hmat4;
/// 2 * 2 matrix of default half-precision floating-point numbers.
/// @see gtc_half_float
typedef mediump_hmat2x2 hmat2x2;
typedef highp_hmat2x2 hmat2x2;
/// 2 * 3 matrix of default half-precision floating-point numbers.
/// @see gtc_half_float
typedef mediump_hmat2x3 hmat2x3;
typedef highp_hmat2x3 hmat2x3;
/// 2 * 4 matrix of default half-precision floating-point numbers.
/// @see gtc_half_float
typedef mediump_hmat2x4 hmat2x4;
typedef highp_hmat2x4 hmat2x4;
/// 3 * 2 matrix of default half-precision floating-point numbers.
/// @see gtc_half_float
typedef mediump_hmat3x2 hmat3x2;
typedef highp_hmat3x2 hmat3x2;
/// 3 * 3 matrix of default half-precision floating-point numbers.
/// @see gtc_half_float
typedef mediump_hmat3x3 hmat3x3;
typedef highp_hmat3x3 hmat3x3;
/// 3 * 4 matrix of default half-precision floating-point numbers.
/// @see gtc_half_float
typedef mediump_hmat3x4 hmat3x4;
typedef highp_hmat3x4 hmat3x4;
/// 4 * 2 matrix of default half-precision floating-point numbers.
/// @see gtc_half_float
typedef mediump_hmat4x2 hmat4x2;
typedef highp_hmat4x2 hmat4x2;
/// 4 * 3 matrix of default half-precision floating-point numbers.
/// @see gtc_half_float
typedef mediump_hmat4x3 hmat4x3;
typedef highp_hmat4x3 hmat4x3;
/// 4 * 4 matrix of default half-precision floating-point numbers.
/// @see gtc_half_float
typedef mediump_hmat4x4 hmat4x4;
#elif(defined(GLM_PRECISION_HIGHP_HALF) && !defined(GLM_PRECISION_MEDIUMP_HALF) && !defined(GLM_PRECISION_LOWP_HALF))
typedef detail::tvec2<half_t, highp> hvec2;
typedef detail::tvec3<half_t, highp> hvec3;
typedef detail::tvec4<half_t, highp> hvec4;
typedef detail::tmat2x2<half_t, highp> hmat2;
typedef detail::tmat3x3<half_t, highp> hmat3;
typedef detail::tmat4x4<half_t, highp> hmat4;
typedef detail::tmat2x2<half_t, highp> hmat2x2;
typedef detail::tmat2x3<half_t, highp> hmat2x3;
typedef detail::tmat2x4<half_t, highp> hmat2x4;
typedef detail::tmat3x2<half_t, highp> hmat3x2;
typedef detail::tmat3x3<half_t, highp> hmat3x3;
typedef detail::tmat3x4<half_t, highp> hmat3x4;
typedef detail::tmat4x2<half_t, highp> hmat4x2;
typedef detail::tmat4x3<half_t, highp> hmat4x3;
typedef detail::tmat4x4<half_t, highp> hmat4x4;
#elif(!defined(GLM_PRECISION_HIGHP_HALF) && defined(GLM_PRECISION_MEDIUMP_HALF) && !defined(GLM_PRECISION_LOWP_HALF))
typedef detail::tvec2<half_t, mediump> hvec2;
typedef detail::tvec3<half_t, mediump> hvec3;
typedef detail::tvec4<half_t, mediump> hvec4;
typedef detail::tmat2x2<half_t, mediump> hmat2;
typedef detail::tmat3x3<half_t, mediump> hmat3;
typedef detail::tmat4x4<half_t, mediump> hmat4;
typedef detail::tmat2x2<half_t, mediump> hmat2x2;
typedef detail::tmat2x3<half_t, mediump> hmat2x3;
typedef detail::tmat2x4<half_t, mediump> hmat2x4;
typedef detail::tmat3x2<half_t, mediump> hmat3x2;
typedef detail::tmat3x3<half_t, mediump> hmat3x3;
typedef detail::tmat3x4<half_t, mediump> hmat3x4;
typedef detail::tmat4x2<half_t, mediump> hmat4x2;
typedef detail::tmat4x3<half_t, mediump> hmat4x3;
typedef detail::tmat4x4<half_t, mediump> hmat4x4;
#elif(!defined(GLM_PRECISION_HIGHP_HALF) && !defined(GLM_PRECISION_MEDIUMP_HALF) && defined(GLM_PRECISION_LOWP_HALF))
typedef detail::tvec2<half_t, lowp> hvec2;
typedef detail::tvec3<half_t, lowp> hvec3;
typedef detail::tvec4<half_t, lowp> hvec4;
typedef detail::tmat2x2<half_t, lowp> hmat2;
typedef detail::tmat3x3<half_t, lowp> hmat3;
typedef detail::tmat4x4<half_t, lowp> hmat4;
typedef detail::tmat2x2<half_t, lowp> hmat2x2;
typedef detail::tmat2x3<half_t, lowp> hmat2x3;
typedef detail::tmat2x4<half_t, lowp> hmat2x4;
typedef detail::tmat3x2<half_t, lowp> hmat3x2;
typedef detail::tmat3x3<half_t, lowp> hmat3x3;
typedef detail::tmat3x4<half_t, lowp> hmat3x4;
typedef detail::tmat4x2<half_t, lowp> hmat4x2;
typedef detail::tmat4x3<half_t, lowp> hmat4x3;
typedef detail::tmat4x4<half_t, lowp> hmat4x4;
#endif
typedef highp_hmat4x4 hmat4x4;
#endif//GLM_PRECISION
/// Returns the absolute value of a half-precision floating-point value
/// @see gtc_half_float

396
glm/gtc/half_float.inl
View File

File diff suppressed because it is too large Load Diff

15
glm/gtc/quaternion.hpp
Unescape View File

@ -308,21 +308,6 @@ namespace detail
detail::tvec3<T, P> axis(
detail::tquat<T, P> const & x);
/// Build a quaternion from an angle and a normalized axis.
///
/// @param angle Angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
/// @param x x component of the x-axis, x, y, z must be a normalized axis
/// @param y y component of the y-axis, x, y, z must be a normalized axis
/// @param z z component of the z-axis, x, y, z must be a normalized axis
///
/// @see gtc_quaternion
template <typename T, precision P>
detail::tquat<T, P> angleAxis(
T const & angle,
T const & x,
T const & y,
T const & z);
/// Build a quaternion from an angle and a normalized axis.
///
/// @param angle Angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.

12
glm/gtc/quaternion.inl
Unescape View File

@ -754,18 +754,6 @@ namespace detail
return detail::tvec3<T, P>(x.x * tmp2, x.y * tmp2, x.z * tmp2);
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tquat<T, defaultp> angleAxis
(
T const & angle,
T const & x,
T const & y,
T const & z
)
{
return angleAxis(angle, detail::tvec3<T, defaultp>(x, y, z));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> angleAxis
(

4
glm/gtx/dual_quaternion.hpp
Unescape View File

@ -271,12 +271,12 @@ namespace detail
/// Dual-quaternion of floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef mediump_fdualquat dualquat;
typedef highp_fdualquat dualquat;
/// Dual-quaternion of single-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef mediump_fdualquat fdualquat;
typedef highp_fdualquat fdualquat;
#elif(defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
typedef highp_fdualquat dualquat;
typedef highp_fdualquat fdualquat;

12
test/core/core_setup_precision.cpp
Unescape View File

@ -42,12 +42,24 @@ static int test_vec()
return Error;
}
static int test_dvec()
{
int Error = 0;
Error += sizeof(glm::dvec2) == sizeof(glm::highp_dvec2) ? 0 : 1;
Error += sizeof(glm::dvec3) == sizeof(glm::highp_dvec3) ? 0 : 1;
Error += sizeof(glm::dvec4) == sizeof(glm::highp_dvec4) ? 0 : 1;
return Error;
}
int main()
{
int Error = 0;
Error += test_mat();
Error += test_vec();
Error += test_dvec();
return Error;
}

6
test/core/core_type_vec2.cpp
Unescape View File

@ -210,8 +210,8 @@ int test_vec2_size()
Error += sizeof(glm::vec2) == sizeof(glm::mediump_vec2) ? 0 : 1;
Error += 8 == sizeof(glm::mediump_vec2) ? 0 : 1;
Error += sizeof(glm::dvec2) == sizeof(glm::highp_vec2) ? 0 : 1;
Error += 16 == sizeof(glm::highp_vec2) ? 0 : 1;
Error += sizeof(glm::dvec2) == sizeof(glm::highp_dvec2) ? 0 : 1;
Error += 16 == sizeof(glm::highp_dvec2) ? 0 : 1;
Error += glm::vec2().length() == 2 ? 0 : 1;
Error += glm::dvec2().length() == 2 ? 0 : 1;
@ -223,7 +223,7 @@ int main()
int Error = 0;
Error += test_vec2_size();
Error += test_vec2_ctor();
Error += test_vec2_ctor();
Error += test_vec2_operators();
return Error;

73
test/gtc/gtc_half_float.cpp
Unescape View File

@ -46,8 +46,8 @@ int test_half_precision_vec()
Error += sizeof(glm::hvec2) == 4 ? 0 : 1;
Error += sizeof(glm::hvec3) == 6 ? 0 : 1;
Error += sizeof(glm::hvec4) == 8 ? 0 : 1;
return Error;
return Error;
}
int test_half_precision_mat()
@ -68,7 +68,7 @@ int test_half_precision_mat()
Error += sizeof(glm::hmat4x3) == 24 ? 0 : 1;
Error += sizeof(glm::hmat4x4) == 32 ? 0 : 1;
return Error;
return Error;
}
int test_half_ctor_mat2x2()
@ -103,7 +103,7 @@ int test_half_ctor_mat2x2()
Error += A == C ? 0 : 1;
}
return Error;
return Error;
}
int test_half_ctor_mat2x3()
@ -208,7 +208,7 @@ int test_half_ctor_mat3x2()
Error += A == C ? 0 : 1;
}
return Error;
return Error;
}
int test_half_ctor_mat3x3()
@ -243,7 +243,7 @@ int test_half_ctor_mat3x3()
Error += A == C ? 0 : 1;
}
return Error;
return Error;
}
int test_half_ctor_mat3x4()
@ -278,7 +278,7 @@ int test_half_ctor_mat3x4()
Error += A == C ? 0 : 1;
}
return Error;
return Error;
}
int test_half_ctor_mat4x2()
@ -527,10 +527,69 @@ int test_hvec4_size()
return Error;
}
static int test_hvec_precision()
{
int Error = 0;
Error += sizeof(glm::hvec2) == sizeof(glm::highp_hvec2) ? 0 : 1;
Error += sizeof(glm::hvec3) == sizeof(glm::highp_hvec3) ? 0 : 1;
Error += sizeof(glm::hvec4) == sizeof(glm::highp_hvec4) ? 0 : 1;
return Error;
}
static int test_hmat_precision()
{
int Error = 0;
Error += sizeof(glm::hmat2) == sizeof(glm::lowp_hmat2) ? 0 : 1;
Error += sizeof(glm::hmat3) == sizeof(glm::lowp_hmat3) ? 0 : 1;
Error += sizeof(glm::hmat4) == sizeof(glm::lowp_hmat4) ? 0 : 1;
Error += sizeof(glm::hmat2) == sizeof(glm::mediump_hmat2) ? 0 : 1;
Error += sizeof(glm::hmat3) == sizeof(glm::mediump_hmat3) ? 0 : 1;
Error += sizeof(glm::hmat4) == sizeof(glm::mediump_hmat4) ? 0 : 1;
Error += sizeof(glm::hmat2) == sizeof(glm::highp_hmat2) ? 0 : 1;
Error += sizeof(glm::hmat3) == sizeof(glm::highp_hmat3) ? 0 : 1;
Error += sizeof(glm::hmat4) == sizeof(glm::highp_hmat4) ? 0 : 1;
Error += sizeof(glm::hmat2x2) == sizeof(glm::lowp_hmat2x2) ? 0 : 1;
Error += sizeof(glm::hmat3x2) == sizeof(glm::lowp_hmat3x2) ? 0 : 1;
Error += sizeof(glm::hmat4x2) == sizeof(glm::lowp_hmat4x2) ? 0 : 1;
Error += sizeof(glm::hmat2x2) == sizeof(glm::mediump_hmat2x2) ? 0 : 1;
Error += sizeof(glm::hmat3x2) == sizeof(glm::mediump_hmat3x2) ? 0 : 1;
Error += sizeof(glm::hmat4x2) == sizeof(glm::mediump_hmat4x2) ? 0 : 1;
Error += sizeof(glm::hmat2x2) == sizeof(glm::highp_hmat2x2) ? 0 : 1;
Error += sizeof(glm::hmat3x2) == sizeof(glm::highp_hmat3x2) ? 0 : 1;
Error += sizeof(glm::hmat4x2) == sizeof(glm::highp_hmat4x2) ? 0 : 1;
Error += sizeof(glm::hmat2x3) == sizeof(glm::lowp_hmat2x3) ? 0 : 1;
Error += sizeof(glm::hmat3x3) == sizeof(glm::lowp_hmat3x3) ? 0 : 1;
Error += sizeof(glm::hmat4x3) == sizeof(glm::lowp_hmat4x3) ? 0 : 1;
Error += sizeof(glm::hmat2x3) == sizeof(glm::mediump_hmat2x3) ? 0 : 1;
Error += sizeof(glm::hmat3x3) == sizeof(glm::mediump_hmat3x3) ? 0 : 1;
Error += sizeof(glm::hmat4x3) == sizeof(glm::mediump_hmat4x3) ? 0 : 1;
Error += sizeof(glm::hmat2x3) == sizeof(glm::highp_hmat2x3) ? 0 : 1;
Error += sizeof(glm::hmat3x3) == sizeof(glm::highp_hmat3x3) ? 0 : 1;
Error += sizeof(glm::hmat4x3) == sizeof(glm::highp_hmat4x3) ? 0 : 1;
Error += sizeof(glm::hmat2x4) == sizeof(glm::lowp_hmat2x4) ? 0 : 1;
Error += sizeof(glm::hmat3x4) == sizeof(glm::lowp_hmat3x4) ? 0 : 1;
Error += sizeof(glm::hmat4x4) == sizeof(glm::lowp_hmat4x4) ? 0 : 1;
Error += sizeof(glm::hmat2x4) == sizeof(glm::mediump_hmat2x4) ? 0 : 1;
Error += sizeof(glm::hmat3x4) == sizeof(glm::mediump_hmat3x4) ? 0 : 1;
Error += sizeof(glm::hmat4x4) == sizeof(glm::mediump_hmat4x4) ? 0 : 1;
Error += sizeof(glm::hmat2x4) == sizeof(glm::highp_hmat2x4) ? 0 : 1;
Error += sizeof(glm::hmat3x4) == sizeof(glm::highp_hmat3x4) ? 0 : 1;
Error += sizeof(glm::hmat4x4) == sizeof(glm::highp_hmat4x4) ? 0 : 1;
return Error;
}
int main()
{
int Error = 0;
Error += test_hvec_precision();
Error += test_hvec2_size();
Error += test_hvec3_size();
Error += test_hvec4_size();

2
test/gtc/gtc_quaternion.cpp
Unescape View File

@ -200,7 +200,7 @@ int test_quat_slerp()
// Testing almost equal quaternions (this test should pass through the linear interpolation)
// Must be 0 0.00X 0 0.99999
glm::quat almostid = glm::slerp(id, glm::angleAxis(0.1f, 0.0f, 1.0f, 0.0f), 0.5f);
glm::quat almostid = glm::slerp(id, glm::angleAxis(0.1f, glm::vec3(0.0f, 1.0f, 0.0f)), 0.5f);
return Error;
}

2
test/gtx/gtx_bit.cpp
Unescape View File

@ -602,7 +602,5 @@ int main()
Error += ::extractField::test();
Error += ::bitRevert::test();
while(true);
return Error;
}

Write Preview
Loading…
Cancel
Save