Merge branch '0.9.5' of https://github.com/g-truc/glm into 0.9.5
Christophe Riccio
ago%!(EXTRA string=12 years)
commit
e818afba4d
88 changed files with 2113 additions and 1575 deletions
File diff suppressed because it is too large
Load Diff
@ -1,143 +0,0 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
/// OpenGL Mathematics (glm.g-truc.net)
|
||||
///
|
||||
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
/// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
/// of this software and associated documentation files (the "Software"), to deal
|
||||
/// in the Software without restriction, including without limitation the rights
|
||||
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
/// copies of the Software, and to permit persons to whom the Software is
|
||||
/// furnished to do so, subject to the following conditions:
|
||||
///
|
||||
/// The above copyright notice and this permission notice shall be included in
|
||||
/// all copies or substantial portions of the Software.
|
||||
///
|
||||
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
/// THE SOFTWARE.
|
||||
///
|
||||
/// @ref gtx_color_cast
|
||||
/// @file glm/gtx/color_cast.hpp
|
||||
/// @date 2007-06-21 / 2011-06-07
|
||||
/// @author Christophe Riccio
|
||||
///
|
||||
/// @see core (dependence)
|
||||
/// @see gtx_number_precision (dependence)
|
||||
///
|
||||
/// @defgroup gtx_color_cast GLM_GTX_color_cast
|
||||
/// @ingroup gtx
|
||||
///
|
||||
/// @brief Conversion between two color types.
|
||||
///
|
||||
/// <glm/gtx/color_cast.hpp> need to be included to use these functionalities.
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLM_GTX_color_cast |
||||
#define GLM_GTX_color_cast GLM_VERSION |
||||
|
||||
// Dependency:
|
||||
#include "../glm.hpp" |
||||
#include "../gtx/number_precision.hpp" |
||||
|
||||
#if(defined(GLM_MESSAGES) && !defined(glm_ext)) |
||||
# pragma message("GLM: GLM_GTX_color_cast extension included") |
||||
#endif |
||||
|
||||
namespace glm |
||||
{ |
||||
/// @addtogroup gtx_color_cast
|
||||
/// @{
|
||||
|
||||
//! Conversion of a floating value into a 8bit unsigned int value.
|
||||
/// @see gtx_color_cast
|
||||
template <typename valType> |
||||
GLM_DEPRECATED uint8 u8channel_cast(valType a); |
||||
|
||||
template <typename T> |
||||
GLM_DEPRECATED uint32 u32_rgbx_cast(const detail::tvec3<T, P>& c); //!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED uint32 u32_xrgb_cast(const detail::tvec3<T, P>& c); //!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED uint32 u32_bgrx_cast(const detail::tvec3<T, P>& c); //!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED uint32 u32_xbgr_cast(const detail::tvec3<T, P>& c); //!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
|
||||
|
||||
template <typename T> |
||||
GLM_DEPRECATED uint32 u32_rgba_cast(const detail::tvec4<T, P>& c); //!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED uint32 u32_argb_cast(const detail::tvec4<T, P>& c); //!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED uint32 u32_bgra_cast(const detail::tvec4<T, P>& c); //!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED uint32 u32_abgr_cast(const detail::tvec4<T, P>& c); //!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
|
||||
|
||||
template <typename T> |
||||
GLM_DEPRECATED uint64 u64_rgbx_cast(const detail::tvec3<T, P>& c); //!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED uint64 u64_xrgb_cast(const detail::tvec3<T, P>& c); //!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED uint64 u64_bgrx_cast(const detail::tvec3<T, P>& c); //!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED uint64 u64_xbgr_cast(const detail::tvec3<T, P>& c); //!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
|
||||
|
||||
template <typename T> |
||||
GLM_DEPRECATED uint64 u64_rgba_cast(const detail::tvec4<T, P>& c); //!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED uint64 u64_argb_cast(const detail::tvec4<T, P>& c); //!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED uint64 u64_bgra_cast(const detail::tvec4<T, P>& c); //!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED uint64 u64_abgr_cast(const detail::tvec4<T, P>& c); //!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
|
||||
|
||||
template <typename T> |
||||
GLM_DEPRECATED f32 f32_channel_cast(T a); //!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
|
||||
|
||||
template <typename T> |
||||
GLM_DEPRECATED f32vec3 f32_rgbx_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED f32vec3 f32_xrgb_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED f32vec3 f32_bgrx_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED f32vec3 f32_xbgr_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
|
||||
|
||||
template <typename T> |
||||
GLM_DEPRECATED f32vec4 f32_rgba_cast(T c); //!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED f32vec4 f32_argb_cast(T c); //!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED f32vec4 f32_bgra_cast(T c); //!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED f32vec4 f32_abgr_cast(T c); //!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
|
||||
|
||||
template <typename T> |
||||
GLM_DEPRECATED f64 f64_channel_cast(T a); //!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
|
||||
|
||||
template <typename T> |
||||
GLM_DEPRECATED f64vec3 f64_rgbx_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED f64vec3 f64_xrgb_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED f64vec3 f64_bgrx_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED f64vec3 f64_xbgr_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
|
||||
|
||||
template <typename T> |
||||
GLM_DEPRECATED f64vec4 f64_rgba_cast(T c); //!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED f64vec4 f64_argb_cast(T c); //!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED f64vec4 f64_bgra_cast(T c); //!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
|
||||
template <typename T> |
||||
GLM_DEPRECATED f64vec4 f64_abgr_cast(T c); //!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
|
||||
|
||||
/// @}
|
||||
}//namespace glm
|
||||
|
||||
#include "color_cast.inl" |
||||
|
||||
#endif//GLM_GTX_color_cast
|
||||
@ -1,733 +0,0 @@ |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// Created : 2007-06-21 |
||||
// Updated : 2007-08-03 |
||||
// Licence : This source is under MIT License |
||||
// File : glm/gtx/color_cast.inl |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
|
||||
namespace glm |
||||
{ |
||||
template <typename T> |
||||
GLM_FUNC_QUALIFIER uint8 u8channel_cast(T a) |
||||
{ |
||||
return static_cast<uint8>(a * T(255)); |
||||
} |
||||
|
||||
template <typename T> |
||||
GLM_FUNC_QUALIFIER uint16 u16channel_cast(T a) |
||||
{ |
||||
return static_cast<uint16>(a * T(65535)); |
||||
} |
||||
|
||||
template <typename T> |
||||
GLM_FUNC_QUALIFIER uint32 u32_rgbx_cast(const detail::tvec3<T, P>& c) |
||||
{ |
||||
uint32 result = 0; |
||||
result += static_cast<uint32>(c.x * detail::tvec3<T, P>::value_type(255)) << 0; |
||||
result += static_cast<uint32>(c.y * detail::tvec3<T, P>::value_type(255)) << 8; |
||||
result += static_cast<uint32>(c.z * detail::tvec3<T, P>::value_type(255)) << 16; |
||||
return result; |
||||
} |
||||
|
||||
template <typename T> |
||||
GLM_FUNC_QUALIFIER uint32 u32_xrgb_cast(const detail::tvec3<T, P>& c) |
||||
{ |
||||
uint32 result = 0; |
||||
result += static_cast<uint32>(c.x * detail::tvec3<T, P>::value_type(255)) << 8; |
||||
result += static_cast<uint32>(c.y * detail::tvec3<T, P>::value_type(255)) << 16; |
||||
result += static_cast<uint32>(c.z * detail::tvec3<T, P>::value_type(255)) << 24; |
||||
return result; |
||||
} |
||||
|
||||
template <typename T> |
||||
GLM_FUNC_QUALIFIER uint32 u32_bgrx_cast(const detail::tvec3<T, P>& c) |
||||
{ |
||||
uint32 result = 0; |
||||
result += static_cast<uint32>(c.x * detail::tvec3<T, P>::value_type(255)) << 16; |
||||
result += static_cast<uint32>(c.y * detail::tvec3<T, P>::value_type(255)) << 8; |
||||
result += static_cast<uint32>(c.z * detail::tvec3<T, P>::value_type(255)) << 0; |
||||
return result; |
||||
} |
||||
|
||||
template <typename T> |
||||
GLM_FUNC_QUALIFIER uint32 u32_xbgr_cast(const detail::tvec3<T, P>& c) |
||||
{ |
||||
uint32 result = 0; |
||||
result += static_cast<uint32>(c.x * detail::tvec3<T, P>::value_type(255)) << 24; |
||||
result += static_cast<uint32>(c.y * detail::tvec3<T, P>::value_type(255)) << 16; |
||||
result += static_cast<uint32>(c.z * detail::tvec3<T, P>::value_type(255)) << 8; |
||||
result += static_cast<uint32>(c.w * detail::tvec3<T, P>::value_type(255)) << 0; |
||||
return result; |
||||
} |
||||
|
||||
template <typename T> |
||||
GLM_FUNC_QUALIFIER uint32 u32_rgba_cast(const detail::tvec4<T, P>& c) |
||||
{ |
||||
uint32 result = 0; |
||||
result += static_cast<uint32>(c.x * detail::tvec4<T, P>::value_type(255)) << 0; |
||||
result += static_cast<uint32>(c.y * detail::tvec4<T, P>::value_type(255)) << 8; |
||||
result += static_cast<uint32>(c.z * detail::tvec4<T, P>::value_type(255)) << 16; |
||||
result += static_cast<uint32>(c.w * detail::tvec4<T, P>::value_type(255)) << 24; |
||||
return result; |
||||
} |
||||
|
||||
template <typename T> |
||||
GLM_FUNC_QUALIFIER uint32 u32_argb_cast(const detail::tvec4<T, P>& c) |
||||
{ |
||||
uint32 result = 0; |
||||
result += static_cast<uint32>(c.x * detail::tvec4<T, P>::value_type(255)) << 8; |
||||
result += static_cast<uint32>(c.y * detail::tvec4<T, P>::value_type(255)) << 16; |
||||
result += static_cast<uint32>(c.z * detail::tvec4<T, P>::value_type(255)) << 24; |
||||
result += static_cast<uint32>(c.w * detail::tvec4<T, P>::value_type(255)) << 0; |
||||
return result; |
||||
} |
||||
|
||||
template <typename T> |
||||
GLM_FUNC_QUALIFIER uint32 u32_bgra_cast(const detail::tvec4<T, P>& c) |
||||
{ |
||||
uint32 result = 0; |
||||
result += static_cast<uint32>(c.x * detail::tvec4<T, P>::value_type(255)) << 16; |
||||
result += static_cast<uint32>(c.y * detail::tvec4<T, P>::value_type(255)) << 8; |
||||
result += static_cast<uint32>(c.z * detail::tvec4<T, P>::value_type(255)) << 0; |
||||
result += static_cast<uint32>(c.w * detail::tvec4<T, P>::value_type(255)) << 24; |
||||
return result; |
||||
} |
||||
|
||||
template <typename T> |
||||
GLM_FUNC_QUALIFIER uint32 u32_abgr_cast(const detail::tvec4<T, P>& c) |
||||
{ |
||||
uint32 result = 0; |
||||
result += static_cast<uint32>(c.x * detail::tvec4<T, P>::value_type(255)) << 24; |
||||
result += static_cast<uint32>(c.y * detail::tvec4<T, P>::value_type(255)) << 16; |
||||
result += static_cast<uint32>(c.z * detail::tvec4<T, P>::value_type(255)) << 8; |
||||
result += static_cast<uint32>(c.w * detail::tvec4<T, P>::value_type(255)) << 0; |
||||
return result; |
||||
} |
||||
|
||||
template <typename T> |
||||
GLM_FUNC_QUALIFIER uint64 u64_rgbx_cast(const detail::tvec3<T, P>& c) |
||||
{ |
||||
uint64 result = 0; |
||||
result += static_cast<uint64>(c.x * detail::tvec3<T, P>::value_type(65535)) << 0; |
||||
result += static_cast<uint64>(c.y * detail::tvec3<T, P>::value_type(65535)) << 16; |
||||
result += static_cast<uint64>(c.z * detail::tvec3<T, P>::value_type(65535)) << 32; |
||||
return result; |
||||
} |
||||
|
||||
template <typename T> |
||||
GLM_FUNC_QUALIFIER uint64 u32_xrgb_cast(const detail::tvec3<T, P>& c) |
||||
{ |
||||
uint64 result = 0; |
||||
result += static_cast<uint64>(c.x * detail::tvec3<T, P>::value_type(65535)) << 16; |
||||
result += static_cast<uint64>(c.y * detail::tvec3<T, P>::value_type(65535)) << 32; |
||||
result += static_cast<uint64>(c.z * detail::tvec3<T, P>::value_type(65535)) << 48; |
||||
return result; |
||||
} |
||||
|
||||
template <typename T> |
||||
GLM_FUNC_QUALIFIER uint64 u32_bgrx_cast(const detail::tvec3<T, P>& c) |
||||
{ |
||||
uint64 result = 0; |
||||
result += static_cast<uint64>(c.x * detail::tvec3<T, P>::value_type(65535)) << 32; |
||||
result += static_cast<uint64>(c.y * detail::tvec3<T, P>::value_type(65535)) << 16; |
||||
result += static_cast<uint64>(c.z * detail::tvec3<T, P>::value_type(65535)) << 0; |
||||
return result; |
||||
} |
||||
|
||||
template <typename T> |
||||
GLM_FUNC_QUALIFIER uint64 u32_xbgr_cast(const detail::tvec3<T, P>& c) |
||||
{ |
||||
uint64 result = 0; |
||||
result += static_cast<uint64>(c.x * detail::tvec3<T, P>::value_type(65535)) << 48; |
||||
result += static_cast<uint64>(c.y * detail::tvec3<T, P>::value_type(65535)) << 32; |
||||
result += static_cast<uint64>(c.z * detail::tvec3<T, P>::value_type(65535)) << 16; |
||||
result += static_cast<uint64>(c.w * detail::tvec3<T, P>::value_type(65535)) << 0; |
||||
return result; |
||||
} |
||||
|
||||
template <typename T> |
||||
GLM_FUNC_QUALIFIER uint64 u64_rgba_cast(const detail::tvec4<T, P>& c) |
||||
{ |
||||
uint64 result = 0; |
||||
result += static_cast<uint64>(c.x * detail::tvec4<T, P>::value_type(65535)) << 0; |
||||
result += static_cast<uint64>(c.y * detail::tvec4<T, P>::value_type(65535)) << 16; |
||||
result += static_cast<uint64>(c.z * detail::tvec4<T, P>::value_type(65535)) << 32; |
||||
result += static_cast<uint64>(c.w * detail::tvec4<T, P>::value_type(65535)) << 48; |
||||
return result; |
||||
} |
||||
|
||||
template <typename T> |
||||
GLM_FUNC_QUALIFIER uint64 u64_argb_cast(const detail::tvec4<T, P>& c) |
||||
{ |
||||
uint64 result = 0; |
||||
result += static_cast<uint64>(c.x * detail::tvec4<T, P>::value_type(65535)) << 16; |
||||
result += static_cast<uint64>(c.y * detail::tvec4<T, P>::value_type(65535)) << 32; |
||||
result += static_cast<uint64>(c.z * detail::tvec4<T, P>::value_type(65535)) << 48; |
||||
result += static_cast<uint64>(c.w * detail::tvec4<T, P>::value_type(65535)) << 0; |
||||
return result; |
||||
} |
||||
|
||||
template <typename T> |
||||
GLM_FUNC_QUALIFIER uint64 u64_bgra_cast(const detail::tvec4<T, P>& c) |
||||
{ |
||||
uint64 result = 0; |
||||
result += static_cast<uint64>(c.x * detail::tvec4<T, P>::value_type(65535)) << 32; |
||||
result += static_cast<uint64>(c.y * detail::tvec4<T, P>::value_type(65535)) << 16; |
||||
result += static_cast<uint64>(c.z * detail::tvec4<T, P>::value_type(65535)) << 0; |
||||
result += static_cast<uint64>(c.w * detail::tvec4<T, P>::value_type(65535)) << 48; |
||||
return result; |
||||
} |
||||
|
||||
template <typename T> |
||||
GLM_FUNC_QUALIFIER uint64 u64_abgr_cast(const detail::tvec4<T, P>& c) |
||||
{ |
||||
uint64 result = 0; |
||||
result += static_cast<uint64>(c.x * detail::tvec4<T, P>::value_type(65535)) << 48; |
||||
result += static_cast<uint64>(c.y * detail::tvec4<T, P>::value_type(65535)) << 32; |
||||
result += static_cast<uint64>(c.z * detail::tvec4<T, P>::value_type(65535)) << 16; |
||||
result += static_cast<uint64>(c.w * detail::tvec4<T, P>::value_type(65535)) << 0; |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER f16 f16_channel_cast<uint32>(uint32 color) |
||||
{ |
||||
return f16(static_cast<float>(color >> 0) / static_cast<float>(255)); |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER f16vec3 f16_rgbx_cast<uint32>(uint32 color) |
||||
{ |
||||
f16vec3 result; |
||||
result.x = f16(static_cast<float>((color >> 0) & 0xFF) / static_cast<float>(255)); |
||||
result.y = f16(static_cast<float>((color >> 8) & 0xFF) / static_cast<float>(255)); |
||||
result.z = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255)); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER f16vec3 f16_xrgb_cast<uint32>(uint32 color) |
||||
{ |
||||
f16vec3 result; |
||||
result.x = f16(static_cast<float>((color >> 8) & 0xFF) / static_cast<float>(255)); |
||||
result.y = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255)); |
||||
result.z = f16(static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255)); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER f16vec3 f16_bgrx_cast<uint32>(uint32 color) |
||||
{ |
||||
f16vec3 result; |
||||
result.x = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255)); |
||||
result.y = f16(static_cast<float>((color >> 8) & 0xFF) / static_cast<float>(255)); |
||||
result.z = f16(static_cast<float>((color >> 0) & 0xFF) / static_cast<float>(255)); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER f16vec3 f16_xbgr_cast<uint32>(uint32 color) |
||||
{ |
||||
f16vec3 result; |
||||
result.x = f16(static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255)); |
||||
result.y = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255)); |
||||
result.z = f16(static_cast<float>((color >> 8) & 0xFF) / static_cast<float>(255)); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER f16vec4 f16_rgba_cast<uint32>(uint32 color) |
||||
{ |
||||
f16vec4 result; |
||||
result.x = f16(static_cast<float>((color >> 0) & 0xFF) / static_cast<float>(255)); |
||||
result.y = f16(static_cast<float>((color >> 8) & 0xFF) / static_cast<float>(255)); |
||||
result.z = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255)); |
||||
result.w = f16(static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255)); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER f16vec4 f16_argb_cast<uint32>(uint32 color) |
||||
{ |
||||
f16vec4 result; |
||||
result.x = f16(static_cast<float>((color >> 8) & 0xFF) / static_cast<float>(255)); |
||||
result.y = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255)); |
||||
result.z = f16(static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255)); |
||||
result.w = f16(static_cast<float>((color >> 0) & 0xFF) / static_cast<float>(255)); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER f16vec4 f16_bgra_cast<uint32>(uint32 color) |
||||
{ |
||||
f16vec4 result; |
||||
result.x = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255)); |
||||
result.y = f16(static_cast<float>((color >> 8) & 0xFF) / static_cast<float>(255)); |
||||
result.z = f16(static_cast<float>((color >> 0) & 0xFF) / static_cast<float>(255)); |
||||
result.w = f16(static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255)); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER f16vec4 f16_abgr_cast<uint32>(uint32 color) |
||||
{ |
||||
f16vec4 result; |
||||
result.x = f16(static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255)); |
||||
result.y = f16(static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255)); |
||||
result.z = f16(static_cast<float>((color >> 8) & 0xFF) / static_cast<float>(255)); |
||||
result.w = f16(static_cast<float>((color >> 0) & 0xFF) / static_cast<float>(255)); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER float f32_channel_cast<uint8>(uint8 color) |
||||
{ |
||||
return static_cast<float>(color >> 0) / static_cast<float>(255); |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec3<float> f32_rgbx_cast<uint32>(uint32 color) |
||||
{ |
||||
detail::tvec3<float> result; |
||||
result.x = static_cast<float>((color >> 0) & 0xFF) / static_cast<float>(255); |
||||
result.y = static_cast<float>((color >> 8) & 0xFF) / static_cast<float>(255); |
||||
result.z = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec3<float> f32_xrgb_cast<uint32>(uint32 color) |
||||
{ |
||||
detail::tvec3<float> result; |
||||
result.x = static_cast<float>((color >> 8) & 0xFF) / static_cast<float>(255); |
||||
result.y = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255); |
||||
result.z = static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec3<float> f32_bgrx_cast<uint32>(uint32 color) |
||||
{ |
||||
detail::tvec3<float> result; |
||||
result.x = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255); |
||||
result.y = static_cast<float>((color >> 8) & 0xFF) / static_cast<float>(255); |
||||
result.z = static_cast<float>((color >> 0) & 0xFF) / static_cast<float>(255); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec3<float> f32_xbgr_cast<uint32>(uint32 color) |
||||
{ |
||||
detail::tvec3<float> result; |
||||
result.x = static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255); |
||||
result.y = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255); |
||||
result.z = static_cast<float>((color >> 8) & 0xFF) / static_cast<float>(255); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec4<float> f32_rgba_cast<uint32>(uint32 color) |
||||
{ |
||||
detail::tvec4<float> result; |
||||
result.x = static_cast<float>((color >> 0) & 0xFF) / static_cast<float>(255); |
||||
result.y = static_cast<float>((color >> 8) & 0xFF) / static_cast<float>(255); |
||||
result.z = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255); |
||||
result.w = static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec4<float> f32_argb_cast<uint32>(uint32 color) |
||||
{ |
||||
detail::tvec4<float> result; |
||||
result.x = static_cast<float>((color >> 8) & 0xFF) / static_cast<float>(255); |
||||
result.y = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255); |
||||
result.z = static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255); |
||||
result.w = static_cast<float>((color >> 0) & 0xFF) / static_cast<float>(255); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec4<float> f32_bgra_cast<uint32>(uint32 color) |
||||
{ |
||||
detail::tvec4<float> result; |
||||
result.x = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255); |
||||
result.y = static_cast<float>((color >> 8) & 0xFF) / static_cast<float>(255); |
||||
result.z = static_cast<float>((color >> 0) & 0xFF) / static_cast<float>(255); |
||||
result.w = static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec4<float> f32_abgr_cast<uint32>(uint32 color) |
||||
{ |
||||
detail::tvec4<float> result; |
||||
result.x = static_cast<float>((color >> 24) & 0xFF) / static_cast<float>(255); |
||||
result.y = static_cast<float>((color >> 16) & 0xFF) / static_cast<float>(255); |
||||
result.z = static_cast<float>((color >> 8) & 0xFF) / static_cast<float>(255); |
||||
result.w = static_cast<float>((color >> 0) & 0xFF) / static_cast<float>(255); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER double f64_channel_cast<uint8>(uint8 color) |
||||
{ |
||||
return static_cast<double>(color >> 0) / static_cast<double>(255); |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec3<double> f64_rgbx_cast<uint32>(uint32 color) |
||||
{ |
||||
detail::tvec3<double> result; |
||||
result.x = static_cast<double>((color >> 0) & 0xFF) / static_cast<double>(255); |
||||
result.y = static_cast<double>((color >> 8) & 0xFF) / static_cast<double>(255); |
||||
result.z = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec3<double> f64_xrgb_cast<uint32>(uint32 color) |
||||
{ |
||||
detail::tvec3<double> result; |
||||
result.x = static_cast<double>((color >> 8) & 0xFF) / static_cast<double>(255); |
||||
result.y = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255); |
||||
result.z = static_cast<double>((color >> 24) & 0xFF) / static_cast<double>(255); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec3<double> f64_bgrx_cast<uint32>(uint32 color) |
||||
{ |
||||
detail::tvec3<double> result; |
||||
result.x = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255); |
||||
result.y = static_cast<double>((color >> 8) & 0xFF) / static_cast<double>(255); |
||||
result.z = static_cast<double>((color >> 0) & 0xFF) / static_cast<double>(255); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec3<double> f64_xbgr_cast<uint32>(uint32 color) |
||||
{ |
||||
detail::tvec3<double> result; |
||||
result.x = static_cast<double>((color >> 24) & 0xFF) / static_cast<double>(255); |
||||
result.y = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255); |
||||
result.z = static_cast<double>((color >> 8) & 0xFF) / static_cast<double>(255); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec4<double> f64_rgba_cast<uint32>(uint32 color) |
||||
{ |
||||
detail::tvec4<double> result; |
||||
result.x = static_cast<double>((color >> 0) & 0xFF) / static_cast<double>(255); |
||||
result.y = static_cast<double>((color >> 8) & 0xFF) / static_cast<double>(255); |
||||
result.z = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255); |
||||
result.w = static_cast<double>((color >> 24) & 0xFF) / static_cast<double>(255); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec4<double> f64_argb_cast<uint32>(uint32 color) |
||||
{ |
||||
detail::tvec4<double> result; |
||||
result.x = static_cast<double>((color >> 8) & 0xFF) / static_cast<double>(255); |
||||
result.y = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255); |
||||
result.z = static_cast<double>((color >> 24) & 0xFF) / static_cast<double>(255); |
||||
result.w = static_cast<double>((color >> 0) & 0xFF) / static_cast<double>(255); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec4<double> f64_bgra_cast<uint32>(uint32 color) |
||||
{ |
||||
detail::tvec4<double> result; |
||||
result.x = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255); |
||||
result.y = static_cast<double>((color >> 8) & 0xFF) / static_cast<double>(255); |
||||
result.z = static_cast<double>((color >> 0) & 0xFF) / static_cast<double>(255); |
||||
result.w = static_cast<double>((color >> 24) & 0xFF) / static_cast<double>(255); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec4<double> f64_abgr_cast<uint32>(uint32 color) |
||||
{ |
||||
detail::tvec4<double> result; |
||||
result.x = static_cast<double>((color >> 24) & 0xFF) / static_cast<double>(255); |
||||
result.y = static_cast<double>((color >> 16) & 0xFF) / static_cast<double>(255); |
||||
result.z = static_cast<double>((color >> 8) & 0xFF) / static_cast<double>(255); |
||||
result.w = static_cast<double>((color >> 0) & 0xFF) / static_cast<double>(255); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::half f16_channel_cast<uint16>(uint16 color) |
||||
{ |
||||
return detail::half(static_cast<float>(color >> 0) / static_cast<float>(65535)); |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec3<detail::half> f16_rgbx_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec3<detail::half> result; |
||||
result.x = detail::half(static_cast<float>((color >> 0) & 0xFFFF) / static_cast<float>(65535)); |
||||
result.y = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535)); |
||||
result.z = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535)); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec3<detail::half> f16_xrgb_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec3<detail::half> result; |
||||
result.x = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535)); |
||||
result.y = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535)); |
||||
result.z = detail::half(static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535)); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec3<detail::half> f16_bgrx_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec3<detail::half> result; |
||||
result.x = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535)); |
||||
result.y = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535)); |
||||
result.z = detail::half(static_cast<float>((color >> 0) & 0xFFFF) / static_cast<float>(65535)); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec3<detail::half> f16_xbgr_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec3<detail::half> result; |
||||
result.x = detail::half(static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535)); |
||||
result.y = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535)); |
||||
result.z = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535)); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec4<detail::half> f16_rgba_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec4<detail::half> result; |
||||
result.x = detail::half(static_cast<float>((color >> 0) & 0xFFFF) / static_cast<float>(65535)); |
||||
result.y = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535)); |
||||
result.z = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535)); |
||||
result.w = detail::half(static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535)); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec4<detail::half> f16_argb_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec4<detail::half> result; |
||||
result.x = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535)); |
||||
result.y = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535)); |
||||
result.z = detail::half(static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535)); |
||||
result.w = detail::half(static_cast<float>((color >> 0) & 0xFFFF) / static_cast<float>(65535)); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec4<detail::half> f16_bgra_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec4<detail::half> result; |
||||
result.x = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535)); |
||||
result.y = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535)); |
||||
result.z = detail::half(static_cast<float>((color >> 0) & 0xFFFF) / static_cast<float>(65535)); |
||||
result.w = detail::half(static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535)); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec4<detail::half> f16_abgr_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec4<detail::half> result; |
||||
result.x = detail::half(static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535)); |
||||
result.y = detail::half(static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535)); |
||||
result.z = detail::half(static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535)); |
||||
result.w = detail::half(static_cast<float>((color >> 0) & 0xFFFF) / static_cast<float>(65535)); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER float f32_channel_cast<uint16>(uint16 color) |
||||
{ |
||||
return static_cast<float>(color >> 0) / static_cast<float>(65535); |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec3<float> f32_rgbx_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec3<float> result; |
||||
result.x = static_cast<float>((color >> 0) & 0xFFFF) / static_cast<float>(65535); |
||||
result.y = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535); |
||||
result.z = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec3<float> f32_xrgb_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec3<float> result; |
||||
result.x = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535); |
||||
result.y = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535); |
||||
result.z = static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec3<float> f32_bgrx_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec3<float> result; |
||||
result.x = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535); |
||||
result.y = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535); |
||||
result.z = static_cast<float>((color >> 0) & 0xFFFF) / static_cast<float>(65535); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec3<float> f32_xbgr_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec3<float> result; |
||||
result.x = static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535); |
||||
result.y = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535); |
||||
result.z = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec4<float> f32_rgba_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec4<float> result; |
||||
result.x = static_cast<float>((color >> 0) & 0xFFFF) / static_cast<float>(65535); |
||||
result.y = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535); |
||||
result.z = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535); |
||||
result.w = static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec4<float> f32_argb_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec4<float> result; |
||||
result.x = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535); |
||||
result.y = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535); |
||||
result.z = static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535); |
||||
result.w = static_cast<float>((color >> 0) & 0xFFFF) / static_cast<float>(65535); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec4<float> f32_bgra_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec4<float> result; |
||||
result.x = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535); |
||||
result.y = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535); |
||||
result.z = static_cast<float>((color >> 0) & 0xFFFF) / static_cast<float>(65535); |
||||
result.w = static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec4<float> f32_abgr_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec4<float> result; |
||||
result.x = static_cast<float>((color >> 48) & 0xFFFF) / static_cast<float>(65535); |
||||
result.y = static_cast<float>((color >> 32) & 0xFFFF) / static_cast<float>(65535); |
||||
result.z = static_cast<float>((color >> 16) & 0xFFFF) / static_cast<float>(65535); |
||||
result.w = static_cast<float>((color >> 0) & 0xFFFF) / static_cast<float>(65535); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER double f64_channel_cast<uint16>(uint16 color) |
||||
{ |
||||
return static_cast<double>(color >> 0) / static_cast<double>(65535); |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec3<double> f64_rgbx_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec3<double> result; |
||||
result.x = static_cast<double>((color >> 0) & 0xFFFF) / static_cast<double>(65535); |
||||
result.y = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535); |
||||
result.z = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec3<double> f64_xrgb_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec3<double> result; |
||||
result.x = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535); |
||||
result.y = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535); |
||||
result.z = static_cast<double>((color >> 48) & 0xFFFF) / static_cast<double>(65535); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec3<double> f64_bgrx_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec3<double> result; |
||||
result.x = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535); |
||||
result.y = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535); |
||||
result.z = static_cast<double>((color >> 0) & 0xFFFF) / static_cast<double>(65535); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec3<double> f64_xbgr_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec3<double> result; |
||||
result.x = static_cast<double>((color >> 48) & 0xFFFF) / static_cast<double>(65535); |
||||
result.y = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535); |
||||
result.z = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec4<double> f64_rgba_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec4<double> result; |
||||
result.x = static_cast<double>((color >> 0) & 0xFFFF) / static_cast<double>(65535); |
||||
result.y = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535); |
||||
result.z = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535); |
||||
result.w = static_cast<double>((color >> 48) & 0xFFFF) / static_cast<double>(65535); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec4<double> f64_argb_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec4<double> result; |
||||
result.x = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535); |
||||
result.y = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535); |
||||
result.z = static_cast<double>((color >> 48) & 0xFFFF) / static_cast<double>(65535); |
||||
result.w = static_cast<double>((color >> 0) & 0xFFFF) / static_cast<double>(65535); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec4<double> f64_bgra_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec4<double> result; |
||||
result.x = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535); |
||||
result.y = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535); |
||||
result.z = static_cast<double>((color >> 0) & 0xFFFF) / static_cast<double>(65535); |
||||
result.w = static_cast<double>((color >> 48) & 0xFFFF) / static_cast<double>(65535); |
||||
return result; |
||||
} |
||||
|
||||
template <> |
||||
GLM_FUNC_QUALIFIER detail::tvec4<double> f64_abgr_cast<uint64>(uint64 color) |
||||
{ |
||||
detail::tvec4<double> result; |
||||
result.x = static_cast<double>((color >> 48) & 0xFFFF) / static_cast<double>(65535); |
||||
result.y = static_cast<double>((color >> 32) & 0xFFFF) / static_cast<double>(65535); |
||||
result.z = static_cast<double>((color >> 16) & 0xFFFF) / static_cast<double>(65535); |
||||
result.w = static_cast<double>((color >> 0) & 0xFFFF) / static_cast<double>(65535); |
||||
return result; |
||||
} |
||||
}//namespace glm |
||||
@ -0,0 +1,159 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
/// OpenGL Mathematics (glm.g-truc.net)
|
||||
///
|
||||
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
/// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
/// of this software and associated documentation files (the "Software"), to deal
|
||||
/// in the Software without restriction, including without limitation the rights
|
||||
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
/// copies of the Software, and to permit persons to whom the Software is
|
||||
/// furnished to do so, subject to the following conditions:
|
||||
///
|
||||
/// The above copyright notice and this permission notice shall be included in
|
||||
/// all copies or substantial portions of the Software.
|
||||
///
|
||||
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
/// THE SOFTWARE.
|
||||
///
|
||||
/// @ref gtx_io
|
||||
/// @file glm/gtx/io.hpp
|
||||
/// @date 2013-11-22
|
||||
/// @author Jan P Springer (regnirpsj@gmail.com)
|
||||
///
|
||||
/// @see core (dependence)
|
||||
/// @see gtx_quaternion (dependence)
|
||||
///
|
||||
/// @defgroup gtx_io GLM_GTX_io
|
||||
/// @ingroup gtx
|
||||
///
|
||||
/// @brief std::[w]ostream support for glm types
|
||||
///
|
||||
/// <glm/gtx/io.hpp> needs to be included to use these functionalities.
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLM_GTX_io |
||||
#define GLM_GTX_io GLM_VERSION |
||||
|
||||
// Dependency:
|
||||
#include "../glm.hpp" |
||||
#include "../gtx/quaternion.hpp" |
||||
|
||||
#if(defined(GLM_MESSAGES) && !defined(glm_ext)) |
||||
# pragma message("GLM: GLM_GTX_io extension included") |
||||
#endif |
||||
|
||||
#include <iosfwd> // std::basic_ostream<> (fwd) |
||||
#include <utility> // std::pair<> |
||||
|
||||
namespace glm |
||||
{ |
||||
/// @addtogroup gtx_io
|
||||
/// @{
|
||||
|
||||
namespace io |
||||
{ |
||||
|
||||
class precision_guard { |
||||
|
||||
public: |
||||
|
||||
GLM_FUNC_DECL explicit precision_guard(); |
||||
GLM_FUNC_DECL ~precision_guard(); |
||||
|
||||
private: |
||||
|
||||
unsigned precision_; |
||||
unsigned value_width_; |
||||
|
||||
}; |
||||
|
||||
enum class order_t { column_major, row_major, }; |
||||
|
||||
class format_guard { |
||||
|
||||
public: |
||||
|
||||
GLM_FUNC_DECL explicit format_guard(); |
||||
GLM_FUNC_DECL ~format_guard(); |
||||
|
||||
private: |
||||
|
||||
order_t order_; |
||||
char cr_; |
||||
|
||||
}; |
||||
|
||||
// decimal places (dflt: 3)
|
||||
GLM_FUNC_DECL unsigned& precision(); |
||||
|
||||
// sign + value + '.' + decimals (dflt: 1 + 4 + 1 + precision())
|
||||
GLM_FUNC_DECL unsigned& value_width(); |
||||
|
||||
// matrix output order (dflt: row_major)
|
||||
GLM_FUNC_DECL order_t& order(); |
||||
|
||||
// carriage/return char (dflt: '\n')
|
||||
GLM_FUNC_DECL char& cr(); |
||||
|
||||
// matrix output order -> column_major
|
||||
GLM_FUNC_DECL std::ios_base& column_major(std::ios_base&); |
||||
|
||||
// matrix output order -> row_major
|
||||
GLM_FUNC_DECL std::ios_base& row_major (std::ios_base&); |
||||
|
||||
// carriage/return char -> '\n'
|
||||
GLM_FUNC_DECL std::ios_base& formatted (std::ios_base&); |
||||
|
||||
// carriage/return char -> ' '
|
||||
GLM_FUNC_DECL std::ios_base& unformatted (std::ios_base&); |
||||
|
||||
}//namespace io
|
||||
|
||||
namespace detail |
||||
{ |
||||
|
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tquat<T,P> const&); |
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec2<T,P> const&); |
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec3<T,P> const&); |
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec4<T,P> const&); |
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x2<T,P> const&); |
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x3<T,P> const&); |
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x4<T,P> const&); |
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x2<T,P> const&); |
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x3<T,P> const&); |
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x4<T,P> const&); |
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x2<T,P> const&); |
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x3<T,P> const&); |
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x4<T,P> const&); |
||||
|
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, |
||||
std::pair<tmat4x4<T,P> const, |
||||
tmat4x4<T,P> const> const&); |
||||
|
||||
}//namespace detail
|
||||
|
||||
/// @}
|
||||
}//namespace glm
|
||||
|
||||
#include "io.inl" |
||||
|
||||
#endif//GLM_GTX_io
|
||||
@ -0,0 +1,420 @@ |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
// Created : 2013-11-22 |
||||
// Updated : 2013-11-22 |
||||
// Licence : This source is under MIT License |
||||
// File : glm/gtx/inl.inl |
||||
/////////////////////////////////////////////////////////////////////////////////////////////////// |
||||
|
||||
// #include <boost/io/ios_state.hpp> // boost::io::ios_all_saver |
||||
#include <iomanip> // std::setfill<>, std::fixed, std::setprecision, std::right, |
||||
// std::setw |
||||
#include <ostream> // std::basic_ostream<> |
||||
|
||||
namespace glm |
||||
{ |
||||
namespace io |
||||
{ |
||||
|
||||
/* explicit */ GLM_FUNC_QUALIFIER |
||||
precision_guard::precision_guard() |
||||
: precision_ (precision()), |
||||
value_width_(value_width()) |
||||
{} |
||||
|
||||
GLM_FUNC_QUALIFIER |
||||
precision_guard::~precision_guard() |
||||
{ |
||||
value_width() = value_width_; |
||||
precision() = precision_; |
||||
} |
||||
|
||||
/* explicit */ GLM_FUNC_QUALIFIER |
||||
format_guard::format_guard() |
||||
: order_(order()), |
||||
cr_ (cr()) |
||||
{} |
||||
|
||||
GLM_FUNC_QUALIFIER |
||||
format_guard::~format_guard() |
||||
{ |
||||
cr() = cr_; |
||||
order() = order_; |
||||
} |
||||
|
||||
GLM_FUNC_QUALIFIER unsigned& |
||||
precision() |
||||
{ |
||||
static unsigned p(3); |
||||
|
||||
return p; |
||||
} |
||||
|
||||
GLM_FUNC_QUALIFIER unsigned& |
||||
value_width() |
||||
{ |
||||
static unsigned p(9); |
||||
|
||||
return p; |
||||
} |
||||
|
||||
GLM_FUNC_QUALIFIER order_t& |
||||
order() |
||||
{ |
||||
static order_t p(order_t::row_major); |
||||
|
||||
return p; |
||||
} |
||||
|
||||
GLM_FUNC_QUALIFIER char& |
||||
cr() |
||||
{ |
||||
static char p('\n'); return p; |
||||
} |
||||
|
||||
GLM_FUNC_QUALIFIER std::ios_base& |
||||
column_major(std::ios_base& os) |
||||
{ |
||||
order() = order_t::column_major; |
||||
|
||||
return os; |
||||
} |
||||
|
||||
GLM_FUNC_QUALIFIER std::ios_base& |
||||
row_major(std::ios_base& os) |
||||
{ |
||||
order() = order_t::row_major; |
||||
|
||||
return os; |
||||
} |
||||
|
||||
GLM_FUNC_QUALIFIER std::ios_base& |
||||
formatted(std::ios_base& os) |
||||
{ |
||||
cr() = '\n'; |
||||
|
||||
return os; |
||||
} |
||||
|
||||
GLM_FUNC_QUALIFIER std::ios_base& |
||||
unformatted(std::ios_base& os) |
||||
{ |
||||
cr() = ' '; |
||||
|
||||
return os; |
||||
} |
||||
|
||||
} // namespace io |
||||
|
||||
namespace detail { |
||||
|
||||
// functions, inlined (inline) |
||||
|
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& |
||||
operator<<(std::basic_ostream<CTy,CTr>& os, tquat<T,P> const& a) |
||||
{ |
||||
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os); |
||||
|
||||
if (cerberus) { |
||||
// boost::io::ios_all_saver const ias(os); |
||||
|
||||
os << std::fixed << std::setprecision(io::precision()) |
||||
<< '[' |
||||
<< std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.w << ',' |
||||
<< std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.x << ',' |
||||
<< std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.y << ',' |
||||
<< std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.z |
||||
<< ']'; |
||||
} |
||||
|
||||
return os; |
||||
} |
||||
|
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& |
||||
operator<<(std::basic_ostream<CTy,CTr>& os, tvec2<T,P> const& a) |
||||
{ |
||||
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os); |
||||
|
||||
if (cerberus) { |
||||
// boost::io::ios_all_saver const ias(os); |
||||
|
||||
os << std::fixed << std::setprecision(io::precision()) |
||||
<< '[' |
||||
<< std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.x << ',' |
||||
<< std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.y |
||||
<< ']'; |
||||
} |
||||
|
||||
return os; |
||||
} |
||||
|
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& |
||||
operator<<(std::basic_ostream<CTy,CTr>& os, tvec3<T,P> const& a) |
||||
{ |
||||
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os); |
||||
|
||||
if (cerberus) { |
||||
// boost::io::ios_all_saver const ias(os); |
||||
|
||||
os << std::fixed << std::setprecision(io::precision()) |
||||
<< '[' |
||||
<< std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.x << ',' |
||||
<< std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.y << ',' |
||||
<< std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.z |
||||
<< ']'; |
||||
} |
||||
|
||||
return os; |
||||
} |
||||
|
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& |
||||
operator<<(std::basic_ostream<CTy,CTr>& os, tvec4<T,P> const& a) |
||||
{ |
||||
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os); |
||||
|
||||
if (cerberus) { |
||||
// boost::io::ios_all_saver const ias(os); |
||||
|
||||
os << std::fixed << std::setprecision(io::precision()) |
||||
<< '[' |
||||
<< std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.x << ',' |
||||
<< std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.y << ',' |
||||
<< std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.z << ',' |
||||
<< std::right << std::setfill<CTy>(' ') << std::setw(io::value_width()) << a.w |
||||
<< ']'; |
||||
} |
||||
|
||||
return os; |
||||
} |
||||
|
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& |
||||
operator<<(std::basic_ostream<CTy,CTr>& os, tmat2x2<T,P> const& a) |
||||
{ |
||||
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os); |
||||
|
||||
if (cerberus) { |
||||
tmat2x2<T,P> m(a); |
||||
|
||||
if (io::order_t::row_major == io::order()) { |
||||
m = transpose(a); |
||||
} |
||||
|
||||
os << io::cr() |
||||
<< '[' << m[0] << io::cr() |
||||
<< ' ' << m[1] << ']'; |
||||
} |
||||
|
||||
return os; |
||||
} |
||||
|
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& |
||||
operator<<(std::basic_ostream<CTy,CTr>& os, tmat2x3<T,P> const& a) |
||||
{ |
||||
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os); |
||||
|
||||
if (cerberus) { |
||||
tmat3x2<T,P> m(a); |
||||
|
||||
if (io::order_t::row_major == io::order()) { |
||||
m = transpose(a); |
||||
} |
||||
|
||||
os << io::cr() |
||||
<< '[' << m[0] << io::cr() |
||||
<< ' ' << m[1] << io::cr() |
||||
<< ' ' << m[2] << ']'; |
||||
} |
||||
|
||||
return os; |
||||
} |
||||
|
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& |
||||
operator<<(std::basic_ostream<CTy,CTr>& os, tmat2x4<T,P> const& a) |
||||
{ |
||||
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os); |
||||
|
||||
if (cerberus) { |
||||
tmat4x2<T,P> m(a); |
||||
|
||||
if (io::order_t::row_major == io::order()) { |
||||
m = transpose(a); |
||||
} |
||||
|
||||
os << io::cr() |
||||
<< '[' << m[0] << io::cr() |
||||
<< ' ' << m[1] << io::cr() |
||||
<< ' ' << m[2] << io::cr() |
||||
<< ' ' << m[3] << ']'; |
||||
} |
||||
|
||||
return os; |
||||
} |
||||
|
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& |
||||
operator<<(std::basic_ostream<CTy,CTr>& os, tmat3x2<T,P> const& a) |
||||
{ |
||||
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os); |
||||
|
||||
if (cerberus) { |
||||
tmat2x3<T,P> m(a); |
||||
|
||||
if (io::order_t::row_major == io::order()) { |
||||
m = transpose(a); |
||||
} |
||||
|
||||
os << io::cr() |
||||
<< '[' << m[0] << io::cr() |
||||
<< ' ' << m[1] << ']'; |
||||
} |
||||
|
||||
return os; |
||||
} |
||||
|
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& |
||||
operator<<(std::basic_ostream<CTy,CTr>& os, tmat3x3<T,P> const& a) |
||||
{ |
||||
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os); |
||||
|
||||
if (cerberus) { |
||||
tmat3x3<T,P> m(a); |
||||
|
||||
if (io::order_t::row_major == io::order()) { |
||||
m = transpose(a); |
||||
} |
||||
|
||||
os << io::cr() |
||||
<< '[' << m[0] << io::cr() |
||||
<< ' ' << m[1] << io::cr() |
||||
<< ' ' << m[2] << ']'; |
||||
} |
||||
|
||||
return os; |
||||
} |
||||
|
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& |
||||
operator<<(std::basic_ostream<CTy,CTr>& os, tmat3x4<T,P> const& a) |
||||
{ |
||||
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os); |
||||
|
||||
if (cerberus) { |
||||
tmat4x3<T,P> m(a); |
||||
|
||||
if (io::order_t::row_major == io::order()) { |
||||
m = transpose(a); |
||||
} |
||||
|
||||
os << io::cr() |
||||
<< '[' << m[0] << io::cr() |
||||
<< ' ' << m[1] << io::cr() |
||||
<< ' ' << m[2] << io::cr() |
||||
<< ' ' << m[3] << ']'; |
||||
} |
||||
|
||||
return os; |
||||
} |
||||
|
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& |
||||
operator<<(std::basic_ostream<CTy,CTr>& os, tmat4x2<T,P> const& a) |
||||
{ |
||||
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os); |
||||
|
||||
if (cerberus) { |
||||
tmat2x4<T,P> m(a); |
||||
|
||||
if (io::order_t::row_major == io::order()) { |
||||
m = transpose(a); |
||||
} |
||||
|
||||
os << io::cr() |
||||
<< '[' << m[0] << io::cr() |
||||
<< ' ' << m[1] << ']'; |
||||
} |
||||
|
||||
return os; |
||||
} |
||||
|
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& |
||||
operator<<(std::basic_ostream<CTy,CTr>& os, tmat4x3<T,P> const& a) |
||||
{ |
||||
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os); |
||||
|
||||
if (cerberus) { |
||||
tmat3x4<T,P> m(a); |
||||
|
||||
if (io::order_t::row_major == io::order()) { |
||||
m = transpose(a); |
||||
} |
||||
|
||||
os << io::cr() |
||||
<< '[' << m[0] << io::cr() |
||||
<< ' ' << m[1] << io::cr() |
||||
<< ' ' << m[2] << ']'; |
||||
} |
||||
|
||||
return os; |
||||
} |
||||
|
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& |
||||
operator<<(std::basic_ostream<CTy,CTr>& os, tmat4x4<T,P> const& a) |
||||
{ |
||||
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os); |
||||
|
||||
if (cerberus) { |
||||
tmat4x4<T,P> m(a); |
||||
|
||||
if (io::order_t::row_major == io::order()) { |
||||
m = transpose(a); |
||||
} |
||||
|
||||
os << io::cr() |
||||
<< '[' << m[0] << io::cr() |
||||
<< ' ' << m[1] << io::cr() |
||||
<< ' ' << m[2] << io::cr() |
||||
<< ' ' << m[3] << ']'; |
||||
} |
||||
|
||||
return os; |
||||
} |
||||
|
||||
template <typename CTy, typename CTr, typename T, precision P> |
||||
GLM_FUNC_QUALIFIER std::basic_ostream<CTy,CTr>& |
||||
operator<<(std::basic_ostream<CTy,CTr>& os, |
||||
std::pair<tmat4x4<T,P> const, tmat4x4<T,P> const> const& a) |
||||
{ |
||||
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os); |
||||
|
||||
if (cerberus) { |
||||
tmat4x4<T,P> ml(a.first); |
||||
tmat4x4<T,P> mr(a.second); |
||||
|
||||
if (io::order_t::row_major == io::order()) { |
||||
ml = transpose(a.first); |
||||
mr = transpose(a.second); |
||||
} |
||||
|
||||
os << io::cr() |
||||
<< '[' << ml[0] << " [" << mr[0] << io::cr() |
||||
<< ' ' << ml[1] << " " << mr[1] << io::cr() |
||||
<< ' ' << ml[2] << " " << mr[2] << io::cr() |
||||
<< ' ' << ml[3] << "] " << mr[3] << ']'; |
||||
} |
||||
|
||||
return os; |
||||
} |
||||
|
||||
}//namespace detail |
||||
}//namespace glm |
||||
@ -0,0 +1,21 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/associated_min_max.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <emmintrin.h> |
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/associated_min_max.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,21 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/associated_min_max.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <emmintrin.h> |
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/associated_min_max.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,21 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/color_space.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <emmintrin.h> |
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/color_space.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,21 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/color_space_YCoCg.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <emmintrin.h> |
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/color_space_YCoCg.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/compatibility.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/compatibility.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,21 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/component_wise.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <emmintrin.h> |
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/component_wise.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/extend.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/extend.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,21 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/associated_min_max.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <emmintrin.h> |
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/associated_min_max.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/associated_min_max.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/fast_exponential.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/fast_square_root.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/fast_square_root.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/fast_trigonometry.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/fast_trigonometry.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/handed_coordinate_space.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/handed_coordinate_space.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/inertia.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/inertia.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,21 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/associated_min_max.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <emmintrin.h> |
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/associated_min_max.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/intersect.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/intersect.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,140 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-11-22
|
||||
// Updated : 2013-11-22
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/io.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/io.hpp> |
||||
#include <iostream> |
||||
#include <typeinfo> |
||||
|
||||
namespace { |
||||
|
||||
template <typename CTy, typename CTr> |
||||
std::basic_ostream<CTy,CTr>& |
||||
operator<<(std::basic_ostream<CTy,CTr>& os, glm::precision const& a) |
||||
{ |
||||
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os); |
||||
|
||||
if (cerberus) { |
||||
switch (a) { |
||||
case glm::highp: os << "hi"; break; |
||||
case glm::mediump: os << "md"; break; |
||||
case glm::lowp: os << "lo"; break; |
||||
} |
||||
} |
||||
|
||||
return os; |
||||
} |
||||
|
||||
} // namespace {
|
||||
|
||||
template <typename T, glm::precision P, typename OS> |
||||
int test_io_vec(OS& os) |
||||
{ |
||||
os << '\n' |
||||
<< typeid(OS).name() |
||||
<< '\n'; |
||||
|
||||
glm::detail::tvec2<T,P> const v2(0, 1); |
||||
glm::detail::tvec3<T,P> const v3(2, 3, 4); |
||||
glm::detail::tvec4<T,P> const v4(5, 6, 7, 8); |
||||
|
||||
os << "vec2<" << typeid(T).name() << ',' << P << ">: " << v2 << '\n' |
||||
<< "vec3<" << typeid(T).name() << ',' << P << ">: " << v3 << '\n' |
||||
<< "vec4<" << typeid(T).name() << ',' << P << ">: " << v4 << '\n'; |
||||
|
||||
glm::io::precision_guard const iopg; |
||||
|
||||
glm::io::precision() = 2; |
||||
glm::io::value_width() = 1 + 2 + 1 + glm::io::precision(); |
||||
|
||||
os << "vec2<" << typeid(T).name() << ',' << P << ">: " << v2 << '\n' |
||||
<< "vec3<" << typeid(T).name() << ',' << P << ">: " << v3 << '\n' |
||||
<< "vec4<" << typeid(T).name() << ',' << P << ">: " << v4 << '\n'; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
template <typename T, glm::precision P, typename OS> |
||||
int test_io_mat(OS& os) |
||||
{ |
||||
os << '\n' |
||||
<< typeid(OS).name() |
||||
<< '\n'; |
||||
|
||||
glm::detail::tvec2<T,P> const v2_1( 0, 1); |
||||
glm::detail::tvec2<T,P> const v2_2( 2, 3); |
||||
glm::detail::tvec2<T,P> const v2_3( 4, 5); |
||||
glm::detail::tvec2<T,P> const v2_4( 6, 7); |
||||
glm::detail::tvec3<T,P> const v3_1( 8, 9, 10); |
||||
glm::detail::tvec3<T,P> const v3_2(11, 12, 13); |
||||
glm::detail::tvec3<T,P> const v3_3(14, 15, 16); |
||||
glm::detail::tvec3<T,P> const v3_4(17, 18, 19); |
||||
glm::detail::tvec4<T,P> const v4_1(20, 21, 22, 23); |
||||
glm::detail::tvec4<T,P> const v4_2(24, 25, 26, 27); |
||||
glm::detail::tvec4<T,P> const v4_3(28, 29, 30, 31); |
||||
glm::detail::tvec4<T,P> const v4_4(32, 33, 34, 35); |
||||
|
||||
#if 0 |
||||
os << "mat2x2<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat2x2<T,P>(v2_1, v2_2) << '\n' |
||||
<< "mat2x3<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat2x3<T,P>(v3_1, v3_2) << '\n' |
||||
<< "mat2x4<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat2x4<T,P>(v4_1, v4_2) << '\n' |
||||
<< "mat3x2<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat3x2<T,P>(v2_1, v2_2, v2_3) << '\n' |
||||
<< "mat3x3<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat3x3<T,P>(v3_1, v3_2, v3_3) << '\n' |
||||
<< "mat3x4<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat3x4<T,P>(v4_1, v4_2, v4_3) << '\n' |
||||
<< "mat4x2<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat4x2<T,P>(v2_1, v2_2, v2_3, v2_4) << '\n' |
||||
<< "mat4x3<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat4x3<T,P>(v3_1, v3_2, v3_3, v3_4) << '\n' |
||||
<< "mat4x4<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat4x4<T,P>(v4_1, v4_2, v4_3, v4_4) << '\n'; |
||||
#endif |
||||
|
||||
glm::io::precision_guard const iopg; |
||||
|
||||
glm::io::precision() = 2; |
||||
glm::io::value_width() = 1 + 2 + 1 + glm::io::precision(); |
||||
|
||||
os << "mat2x2<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat2x2<T,P>(v2_1, v2_2) << '\n' |
||||
<< "mat2x3<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat2x3<T,P>(v3_1, v3_2) << '\n' |
||||
<< "mat2x4<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat2x4<T,P>(v4_1, v4_2) << '\n' |
||||
<< "mat3x2<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat3x2<T,P>(v2_1, v2_2, v2_3) << '\n' |
||||
<< "mat3x3<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat3x3<T,P>(v3_1, v3_2, v3_3) << '\n' |
||||
<< "mat3x4<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat3x4<T,P>(v4_1, v4_2, v4_3) << '\n' |
||||
<< "mat4x2<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat4x2<T,P>(v2_1, v2_2, v2_3, v2_4) << '\n' |
||||
<< "mat4x3<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat4x3<T,P>(v3_1, v3_2, v3_3, v3_4) << '\n' |
||||
<< "mat4x4<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat4x4<T,P>(v4_1, v4_2, v4_3, v4_4) << '\n'; |
||||
|
||||
os << glm::io::column_major |
||||
<< "mat2x2<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat2x2<T,P>(v2_1, v2_2) << '\n' |
||||
<< "mat2x3<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat2x3<T,P>(v3_1, v3_2) << '\n' |
||||
<< "mat2x4<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat2x4<T,P>(v4_1, v4_2) << '\n' |
||||
<< "mat3x2<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat3x2<T,P>(v2_1, v2_2, v2_3) << '\n' |
||||
<< "mat3x3<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat3x3<T,P>(v3_1, v3_2, v3_3) << '\n' |
||||
<< "mat3x4<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat3x4<T,P>(v4_1, v4_2, v4_3) << '\n' |
||||
<< "mat4x2<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat4x2<T,P>(v2_1, v2_2, v2_3, v2_4) << '\n' |
||||
<< "mat4x3<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat4x3<T,P>(v3_1, v3_2, v3_3, v3_4) << '\n' |
||||
<< "mat4x4<" << typeid(T).name() << ',' << P << ">: " << glm::detail::tmat4x4<T,P>(v4_1, v4_2, v4_3, v4_4) << '\n'; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
Error += test_io_vec<float, glm::highp>(std::cout); |
||||
Error += test_io_vec<float, glm::highp>(std::wcout); |
||||
Error += test_io_vec<int, glm::mediump>(std::cout); |
||||
Error += test_io_vec<int, glm::mediump>(std::wcout); |
||||
Error += test_io_vec<glm::uint, glm::lowp>(std::cout); |
||||
Error += test_io_vec<glm::uint, glm::lowp>(std::wcout); |
||||
|
||||
Error += test_io_mat<float, glm::highp>(std::cout); |
||||
Error += test_io_mat<float, glm::lowp>(std::wcout); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/log_base.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/log_base.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/matrix_cross_product.hpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/matrix_cross_product.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/matrix_major_storage.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/matrix_major_storage.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/matrix_operation.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/matrix_operation.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,21 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/associated_min_max.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <emmintrin.h> |
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/associated_min_max.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/norm.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/norm.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/normal.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/normal.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/normalize_dot.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/normalize_dot.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/number_precision.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/number_precision.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/optimum_pow.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/optimum_pow.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/orthonormalize.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/orthonormalize.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/perpendicular.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/perpendicular.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/polar_coordinates.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/polar_coordinates.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/projection.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/projection.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/associated_min_max.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp> |
||||
#include <glm/gtc/type_precision.hpp> |
||||
#include <glm/gtx/spline.hpp> |
||||
|
||||
int main() |
||||
{ |
||||
int Error(0); |
||||
|
||||
return Error; |
||||
} |
||||
Loading…
Reference in New Issue