pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2026-06-23 00:08:23 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Updated version of glm

Browse Source
This commit is contained in:
KimLS
2015-01-22 16:52:50 -08:00
parent a71690b725
commit 03286f540a
270 changed files with 17903 additions and 16363 deletions
Download Patch File Download Diff File Expand all files Collapse all files
common/glm/glm/gtx/associated_min_max.hpp
+166 -41
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -22,7 +26,7 @@
///
/// @ref gtx_associated_min_max
/// @file glm/gtx/associated_min_max.hpp
/// @date 2008-03-10 / 2011-06-07
/// @date 2008-03-10 / 2014-10-11
/// @author Christophe Riccio
///
/// @see core (dependence)
@@ -35,8 +39,7 @@
/// <glm/gtx/associated_min_max.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_associated_min_max
#define GLM_GTX_associated_min_max
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -50,57 +53,179 @@ namespace glm
/// @addtogroup gtx_associated_min_max
/// @{
/// Min comparison between 2 variables
/// Minimum comparison between 2 variables and returns 2 associated variable values
/// @see gtx_associated_min_max
template<typename genTypeT, typename genTypeU>
GLM_FUNC_DECL genTypeU associatedMin(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b);
template<typename T, typename U, precision P>
GLM_FUNC_DECL U associatedMin(T x, U a, T y, U b);
/// Min comparison between 3 variables
/// Minimum comparison between 2 variables and returns 2 associated variable values
/// @see gtx_associated_min_max
template<typename genTypeT, typename genTypeU>
GLM_FUNC_DECL genTypeU associatedMin(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c);
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL tvec2<U, P> associatedMin(
vecType<T, P> const & x, vecType<U, P> const & a,
vecType<T, P> const & y, vecType<U, P> const & b);
/// Min comparison between 4 variables
/// Minimum comparison between 2 variables and returns 2 associated variable values
/// @see gtx_associated_min_max
template<typename genTypeT, typename genTypeU>
GLM_FUNC_DECL genTypeU associatedMin(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c,
const genTypeT& w, const genTypeU& d);
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<U, P> associatedMin(
T x, const vecType<U, P>& a,
T y, const vecType<U, P>& b);
/// Max comparison between 2 variables
/// Minimum comparison between 2 variables and returns 2 associated variable values
/// @see gtx_associated_min_max
template<typename genTypeT, typename genTypeU>
GLM_FUNC_DECL genTypeU associatedMax(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b);
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<U, P> associatedMin(
vecType<T, P> const & x, U a,
vecType<T, P> const & y, U b);
/// Max comparison between 3 variables
/// Minimum comparison between 3 variables and returns 3 associated variable values
/// @see gtx_associated_min_max
template<typename genTypeT, typename genTypeU>
GLM_FUNC_DECL genTypeU associatedMax(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c);
template<typename T, typename U>
GLM_FUNC_DECL U associatedMin(
T x, U a,
T y, U b,
T z, U c);
/// Max comparison between 4 variables
/// Minimum comparison between 3 variables and returns 3 associated variable values
/// @see gtx_associated_min_max
template<typename genTypeT, typename genTypeU>
GLM_FUNC_DECL genTypeU associatedMax(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c,
const genTypeT& w, const genTypeU& d);
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<U, P> associatedMin(
vecType<T, P> const & x, vecType<U, P> const & a,
vecType<T, P> const & y, vecType<U, P> const & b,
vecType<T, P> const & z, vecType<U, P> const & c);
/// Minimum comparison between 4 variables and returns 4 associated variable values
/// @see gtx_associated_min_max
template<typename T, typename U>
GLM_FUNC_DECL U associatedMin(
T x, U a,
T y, U b,
T z, U c,
T w, U d);
/// Minimum comparison between 4 variables and returns 4 associated variable values
/// @see gtx_associated_min_max
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<U, P> associatedMin(
vecType<T, P> const & x, vecType<U, P> const & a,
vecType<T, P> const & y, vecType<U, P> const & b,
vecType<T, P> const & z, vecType<U, P> const & c,
vecType<T, P> const & w, vecType<U, P> const & d);
/// Minimum comparison between 4 variables and returns 4 associated variable values
/// @see gtx_associated_min_max
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<U, P> associatedMin(
T x, vecType<U, P> const & a,
T y, vecType<U, P> const & b,
T z, vecType<U, P> const & c,
T w, vecType<U, P> const & d);
/// Minimum comparison between 4 variables and returns 4 associated variable values
/// @see gtx_associated_min_max
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<U, P> associatedMin(
vecType<T, P> const & x, U a,
vecType<T, P> const & y, U b,
vecType<T, P> const & z, U c,
vecType<T, P> const & w, U d);
/// Maximum comparison between 2 variables and returns 2 associated variable values
/// @see gtx_associated_min_max
template<typename T, typename U>
GLM_FUNC_DECL U associatedMax(T x, U a, T y, U b);
/// Maximum comparison between 2 variables and returns 2 associated variable values
/// @see gtx_associated_min_max
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL tvec2<U, P> associatedMax(
vecType<T, P> const & x, vecType<U, P> const & a,
vecType<T, P> const & y, vecType<U, P> const & b);
/// Maximum comparison between 2 variables and returns 2 associated variable values
/// @see gtx_associated_min_max
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> associatedMax(
T x, vecType<U, P> const & a,
T y, vecType<U, P> const & b);
/// Maximum comparison between 2 variables and returns 2 associated variable values
/// @see gtx_associated_min_max
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<U, P> associatedMax(
vecType<T, P> const & x, U a,
vecType<T, P> const & y, U b);
/// Maximum comparison between 3 variables and returns 3 associated variable values
/// @see gtx_associated_min_max
template<typename T, typename U>
GLM_FUNC_DECL U associatedMax(
T x, U a,
T y, U b,
T z, U c);
/// Maximum comparison between 3 variables and returns 3 associated variable values
/// @see gtx_associated_min_max
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<U, P> associatedMax(
vecType<T, P> const & x, vecType<U, P> const & a,
vecType<T, P> const & y, vecType<U, P> const & b,
vecType<T, P> const & z, vecType<U, P> const & c);
/// Maximum comparison between 3 variables and returns 3 associated variable values
/// @see gtx_associated_min_max
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> associatedMax(
T x, vecType<U, P> const & a,
T y, vecType<U, P> const & b,
T z, vecType<U, P> const & c);
/// Maximum comparison between 3 variables and returns 3 associated variable values
/// @see gtx_associated_min_max
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<U, P> associatedMax(
vecType<T, P> const & x, U a,
vecType<T, P> const & y, U b,
vecType<T, P> const & z, U c);
/// Maximum comparison between 4 variables and returns 4 associated variable values
/// @see gtx_associated_min_max
template<typename T, typename U>
GLM_FUNC_DECL U associatedMax(
T x, U a,
T y, U b,
T z, U c,
T w, U d);
/// Maximum comparison between 4 variables and returns 4 associated variable values
/// @see gtx_associated_min_max
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<U, P> associatedMax(
vecType<T, P> const & x, vecType<U, P> const & a,
vecType<T, P> const & y, vecType<U, P> const & b,
vecType<T, P> const & z, vecType<U, P> const & c,
vecType<T, P> const & w, vecType<U, P> const & d);
/// Maximum comparison between 4 variables and returns 4 associated variable values
/// @see gtx_associated_min_max
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<U, P> associatedMax(
T x, vecType<U, P> const & a,
T y, vecType<U, P> const & b,
T z, vecType<U, P> const & c,
T w, vecType<U, P> const & d);
/// Maximum comparison between 4 variables and returns 4 associated variable values
/// @see gtx_associated_min_max
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<U, P> associatedMax(
vecType<T, P> const & x, U a,
vecType<T, P> const & y, U b,
vecType<T, P> const & z, U c,
vecType<T, P> const & w, U d);
/// @}
} //namespace glm
#include "associated_min_max.inl"
#endif//GLM_GTX_associated_min_max
common/glm/glm/gtx/associated_min_max.inl
+142 -670
View File
@@ -1,10 +1,33 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2008-03-10
// Updated : 2008-03-15
// Licence : This source is under MIT License
// File : gtx_associated_min_max.inl
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_associated_min_max
/// @file glm/gtx/associated_min_max.inl
/// @date 2008-03-10 / 2014-10-11
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
@@ -16,121 +39,41 @@ GLM_FUNC_QUALIFIER U associatedMin(T x, U a, T y, U b)
return x < y ? a : b;
}
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<U, P> associatedMin
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER tvec2<U, P> associatedMin
(
const detail::tvec2<T, P>& x, const detail::tvec2<U, P>& a,
const detail::tvec2<T, P>& y, const detail::tvec2<U, P>& b
vecType<T, P> const & x, vecType<U, P> const & a,
vecType<T, P> const & y, vecType<U, P> const & b
)
{
detail::tvec2<U, P> Result;
//Result.x = x[0] < y[0] ? a[0] : b[0];
//Result.y = x[1] < y[1] ? a[1] : b[1];
for(typename detail::tvec2<U, P>::size_type i = 0; i < Result.length(); ++i)
vecType<U, P> Result(uninitialize);
for(detail::component_count_t i = 0; i < detail::component_count(Result); ++i)
Result[i] = x[i] < y[i] ? a[i] : b[i];
return Result;
}
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<U, P> associatedMin
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<U, P> associatedMin
(
const detail::tvec3<T, P>& x, const detail::tvec3<U, P>& a,
const detail::tvec3<T, P>& y, const detail::tvec3<U, P>& b
T x, const vecType<U, P>& a,
T y, const vecType<U, P>& b
)
{
detail::tvec3<U, P> Result;
for(typename detail::tvec3<U, P>::size_type i = 0; i < Result.length(); ++i)
Result[i] = x[i] < y[i] ? a[i] : b[i];
return Result;
}
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<U, P> associatedMin
(
const detail::tvec4<T, P>& x, const detail::tvec4<U, P>& a,
const detail::tvec4<T, P>& y, const detail::tvec4<U, P>& b
)
{
detail::tvec4<U, P> Result;
for(typename detail::tvec4<U, P>::size_type i = 0; i < Result.length(); ++i)
Result[i] = x[i] < y[i] ? a[i] : b[i];
return Result;
}
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<U, P> associatedMin
(
T x, const detail::tvec2<U, P>& a,
T y, const detail::tvec2<U, P>& b
)
{
detail::tvec2<U, P> Result;
for(typename detail::tvec2<U, P>::size_type i = 0; i < Result.length(); ++i)
vecType<U, P> Result(uninitialize);
for(detail::component_count_t i = 0; i < detail::component_count(Result); ++i)
Result[i] = x < y ? a[i] : b[i];
return Result;
}
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<U, P> associatedMin
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<U, P> associatedMin
(
T x, const detail::tvec3<U, P>& a,
T y, const detail::tvec3<U, P>& b
vecType<T, P> const & x, U a,
vecType<T, P> const & y, U b
)
{
detail::tvec3<U, P> Result;
for(typename detail::tvec3<U, P>::size_type i = 0; i < Result.length(); ++i)
Result[i] = x < y ? a[i] : b[i];
return Result;
}
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<U, P> associatedMin
(
T x, const detail::tvec4<U, P>& a,
T y, const detail::tvec4<U, P>& b
)
{
detail::tvec4<U, P> Result;
for(typename detail::tvec4<U, P>::size_type i = 0; i < Result.length(); ++i)
Result[i] = x < y ? a[i] : b[i];
return Result;
}
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<U, P> associatedMin
(
detail::tvec2<T, P> const & x, U a,
detail::tvec2<T, P> const & y, U b
)
{
detail::tvec2<U, P> Result;
for(typename detail::tvec2<U, P>::size_type i = 0; i < Result.length(); ++i)
Result[i] = x[i] < y[i] ? a : b;
return Result;
}
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<U, P> associatedMin
(
const detail::tvec3<T, P>& x, U a,
const detail::tvec3<T, P>& y, U b
)
{
detail::tvec3<U, P> Result;
for(typename detail::tvec3<U, P>::size_type i = 0; i < Result.length(); ++i)
Result[i] = x[i] < y[i] ? a : b;
return Result;
}
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<U, P> associatedMin
(
const detail::tvec4<T, P>& x, U a,
const detail::tvec4<T, P>& y, U b
)
{
detail::tvec4<U, P> Result;
for(typename detail::tvec4<U, P>::size_type i = 0; i < Result.length(); ++i)
vecType<U, P> Result(uninitialize);
for(detail::component_count_t i = 0; i < detail::component_count(Result); ++i)
Result[i] = x[i] < y[i] ? a : b;
return Result;
}
@@ -148,44 +91,16 @@ GLM_FUNC_QUALIFIER U associatedMin
return Result;
}
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<U, P> associatedMin
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<U, P> associatedMin
(
const detail::tvec2<T, P>& x, const detail::tvec2<U, P>& a,
const detail::tvec2<T, P>& y, const detail::tvec2<U, P>& b,
const detail::tvec2<T, P>& z, const detail::tvec2<U, P>& c
vecType<T, P> const & x, vecType<U, P> const & a,
vecType<T, P> const & y, vecType<U, P> const & b,
vecType<T, P> const & z, vecType<U, P> const & c
)
{
detail::tvec2<U, P> Result;
for(typename detail::tvec2<U, P>::size_type i = 0; i < Result.length(); ++i)
Result[i] = x[i] < y[i] ? (x[i] < z[i] ? a[i] : c[i]) : (y[i] < z[i] ? b[i] : c[i]);
return Result;
}
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<U, P> associatedMin
(
const detail::tvec3<T, P>& x, const detail::tvec3<U, P>& a,
const detail::tvec3<T, P>& y, const detail::tvec3<U, P>& b,
const detail::tvec3<T, P>& z, const detail::tvec3<U, P>& c
)
{
detail::tvec3<U, P> Result;
for(typename detail::tvec3<U, P>::size_type i = 0; i < Result.length(); ++i)
Result[i] = x[i] < y[i] ? (x[i] < z[i] ? a[i] : c[i]) : (y[i] < z[i] ? b[i] : c[i]);
return Result;
}
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<U, P> associatedMin
(
const detail::tvec4<T, P>& x, const detail::tvec4<U, P>& a,
const detail::tvec4<T, P>& y, const detail::tvec4<U, P>& b,
const detail::tvec4<T, P>& z, const detail::tvec4<U, P>& c
)
{
detail::tvec4<U, P> Result;
for(typename detail::tvec4<U, P>::size_type i = 0; i < Result.length(); ++i)
vecType<U, P> Result(uninitialize);
for(detail::component_count_t i = 0; i < detail::component_count(Result); ++i)
Result[i] = x[i] < y[i] ? (x[i] < z[i] ? a[i] : c[i]) : (y[i] < z[i] ? b[i] : c[i]);
return Result;
}
@@ -209,17 +124,17 @@ GLM_FUNC_QUALIFIER U associatedMin
}
// Min comparison between 4 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<U, P> associatedMin
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<U, P> associatedMin
(
const detail::tvec2<T, P>& x, const detail::tvec2<U, P>& a,
const detail::tvec2<T, P>& y, const detail::tvec2<U, P>& b,
const detail::tvec2<T, P>& z, const detail::tvec2<U, P>& c,
const detail::tvec2<T, P>& w, const detail::tvec2<U, P>& d
vecType<T, P> const & x, vecType<U, P> const & a,
vecType<T, P> const & y, vecType<U, P> const & b,
vecType<T, P> const & z, vecType<U, P> const & c,
vecType<T, P> const & w, vecType<U, P> const & d
)
{
detail::tvec2<U, P> Result;
for(typename detail::tvec2<U, P>::size_type i = 0; i < Result.length(); ++i)
vecType<U, P> Result(uninitialize);
for(detail::component_count_t i = 0; i < detail::component_count(Result); ++i)
{
T Test1 = min(x[i], y[i]);
T Test2 = min(z[i], w[i]);
@@ -231,64 +146,20 @@ GLM_FUNC_QUALIFIER detail::tvec2<U, P> associatedMin
}
// Min comparison between 4 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<U, P> associatedMin
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<U, P> associatedMin
(
const detail::tvec3<T, P>& x, const detail::tvec3<U, P>& a,
const detail::tvec3<T, P>& y, const detail::tvec3<U, P>& b,
const detail::tvec3<T, P>& z, const detail::tvec3<U, P>& c,
const detail::tvec3<T, P>& w, const detail::tvec3<U, P>& d
)
{
detail::tvec3<U, P> Result;
for(typename detail::tvec3<U, P>::size_type i = 0; i < Result.length(); ++i)
{
T Test1 = min(x[i], y[i]);
T Test2 = min(z[i], w[i]);
U Result1 = x[i] < y[i] ? a[i] : b[i];
U Result2 = z[i] < w[i] ? c[i] : d[i];
Result[i] = Test1 < Test2 ? Result1 : Result2;
}
return Result;
}
// Min comparison between 4 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<U, P> associatedMin
(
const detail::tvec4<T, P>& x, const detail::tvec4<U, P>& a,
const detail::tvec4<T, P>& y, const detail::tvec4<U, P>& b,
const detail::tvec4<T, P>& z, const detail::tvec4<U, P>& c,
const detail::tvec4<T, P>& w, const detail::tvec4<U, P>& d
)
{
detail::tvec4<U, P> Result;
for(typename detail::tvec4<U, P>::size_type i = 0; i < Result.length(); ++i)
{
T Test1 = min(x[i], y[i]);
T Test2 = min(z[i], w[i]);
U Result1 = x[i] < y[i] ? a[i] : b[i];
U Result2 = z[i] < w[i] ? c[i] : d[i];
Result[i] = Test1 < Test2 ? Result1 : Result2;
}
return Result;
}
// Min comparison between 4 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<U, P> associatedMin
(
T x, const detail::tvec2<U, P>& a,
T y, const detail::tvec2<U, P>& b,
T z, const detail::tvec2<U, P>& c,
T w, const detail::tvec2<U, P>& d
T x, vecType<U, P> const & a,
T y, vecType<U, P> const & b,
T z, vecType<U, P> const & c,
T w, vecType<U, P> const & d
)
{
T Test1 = min(x, y);
T Test2 = min(z, w);
detail::tvec2<U, P> Result;
for(typename detail::tvec2<U, P>::size_type i = 0; i < Result.length(); ++i)
vecType<U, P> Result(uninitialize);
for(detail::component_count_t i = 0; i < detail::component_count(Result); ++i)
{
U Result1 = x < y ? a[i] : b[i];
U Result2 = z < w ? c[i] : d[i];
@@ -298,107 +169,17 @@ GLM_FUNC_QUALIFIER detail::tvec2<U, P> associatedMin
}
// Min comparison between 4 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<U, P> associatedMin
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<U, P> associatedMin
(
T x, const detail::tvec3<U, P>& a,
T y, const detail::tvec3<U, P>& b,
T z, const detail::tvec3<U, P>& c,
T w, const detail::tvec3<U, P>& d
vecType<T, P> const & x, U a,
vecType<T, P> const & y, U b,
vecType<T, P> const & z, U c,
vecType<T, P> const & w, U d
)
{
T Test1 = min(x, y);
T Test2 = min(z, w);
detail::tvec3<U, P> Result;
for(typename detail::tvec3<U, P>::size_type i = 0; i < detail::tvec3<U, P>::value_size; ++i)
{
U Result1 = x < y ? a[i] : b[i];
U Result2 = z < w ? c[i] : d[i];
Result[i] = Test1 < Test2 ? Result1 : Result2;
}
return Result;
}
// Min comparison between 4 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<U, P> associatedMin
(
T x, const detail::tvec4<U, P>& a,
T y, const detail::tvec4<U, P>& b,
T z, const detail::tvec4<U, P>& c,
T w, const detail::tvec4<U, P>& d
)
{
T Test1 = min(x, y);
T Test2 = min(z, w);
detail::tvec4<U, P> Result;
for(typename detail::tvec4<U, P>::size_type i = 0; i < detail::tvec4<U, P>::value_size; ++i)
{
U Result1 = x < y ? a[i] : b[i];
U Result2 = z < w ? c[i] : d[i];
Result[i] = Test1 < Test2 ? Result1 : Result2;
}
return Result;
}
// Min comparison between 4 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<U, P> associatedMin
(
const detail::tvec2<T, P>& x, U a,
const detail::tvec2<T, P>& y, U b,
const detail::tvec2<T, P>& z, U c,
const detail::tvec2<T, P>& w, U d
)
{
detail::tvec2<U, P> Result;
for(typename detail::tvec2<T, P>::size_type i = 0; i < detail::tvec2<T, P>::value_size(); ++i)
{
T Test1 = min(x[i], y[i]);
T Test2 = min(z[i], w[i]);;
U Result1 = x[i] < y[i] ? a : b;
U Result2 = z[i] < w[i] ? c : d;
Result[i] = Test1 < Test2 ? Result1 : Result2;
}
return Result;
}
// Min comparison between 4 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<U, P> associatedMin
(
const detail::tvec3<T, P>& x, U a,
const detail::tvec3<T, P>& y, U b,
const detail::tvec3<T, P>& z, U c,
const detail::tvec3<T, P>& w, U d
)
{
detail::tvec3<U, P> Result;
for(typename detail::tvec3<T, P>::size_type i = 0; i < detail::tvec3<T, P>::value_size(); ++i)
{
T Test1 = min(x[i], y[i]);
T Test2 = min(z[i], w[i]);;
U Result1 = x[i] < y[i] ? a : b;
U Result2 = z[i] < w[i] ? c : d;
Result[i] = Test1 < Test2 ? Result1 : Result2;
}
return Result;
}
// Min comparison between 4 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<U, P> associatedMin
(
const detail::tvec4<T, P>& x, U a,
const detail::tvec4<T, P>& y, U b,
const detail::tvec4<T, P>& z, U c,
const detail::tvec4<T, P>& w, U d
)
{
detail::tvec4<U, P> Result;
for(typename detail::tvec4<T, P>::size_type i = 0; i < detail::tvec4<T, P>::value_size(); ++i)
vecType<U, P> Result(uninitialize);
for(detail::component_count_t i = 0; i < detail::component_count(Result); ++i)
{
T Test1 = min(x[i], y[i]);
T Test2 = min(z[i], w[i]);;
@@ -417,127 +198,43 @@ GLM_FUNC_QUALIFIER U associatedMax(T x, U a, T y, U b)
}
// Max comparison between 2 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<U, P> associatedMax
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER tvec2<U, P> associatedMax
(
const detail::tvec2<T, P>& x, const detail::tvec2<U, P>& a,
const detail::tvec2<T, P>& y, const detail::tvec2<U, P>& b
vecType<T, P> const & x, vecType<U, P> const & a,
vecType<T, P> const & y, vecType<U, P> const & b
)
{
detail::tvec2<U, P> Result;
for(typename detail::tvec2<U, P>::size_type i = 0; i < Result.length(); ++i)
vecType<U, P> Result(uninitialize);
for(detail::component_count_t i = 0; i < detail::component_count(Result); ++i)
Result[i] = x[i] > y[i] ? a[i] : b[i];
return Result;
}
// Max comparison between 2 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<U, P> associatedMax
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> associatedMax
(
const detail::tvec3<T, P>& x, const detail::tvec3<U, P>& a,
const detail::tvec3<T, P>& y, const detail::tvec3<U, P>& b
T x, vecType<U, P> const & a,
T y, vecType<U, P> const & b
)
{
detail::tvec3<U, P> Result;
for(typename detail::tvec3<U, P>::size_type i = 0; i < Result.length(); ++i)
Result[i] = x[i] > y[i] ? a[i] : b[i];
return Result;
}
// Max comparison between 2 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<U, P> associatedMax
(
const detail::tvec4<T, P>& x, const detail::tvec4<U, P>& a,
const detail::tvec4<T, P>& y, const detail::tvec4<U, P>& b
)
{
detail::tvec4<U, P> Result;
for(typename detail::tvec4<U, P>::size_type i = 0; i < Result.length(); ++i)
Result[i] = x[i] > y[i] ? a[i] : b[i];
return Result;
}
// Max comparison between 2 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<U, P> associatedMax
(
T x, const detail::tvec2<U, P>& a,
T y, const detail::tvec2<U, P>& b
)
{
detail::tvec2<U, P> Result;
for(typename detail::tvec2<U, P>::size_type i = 0; i < Result.length(); ++i)
vecType<U, P> Result(uninitialize);
for(detail::component_count_t i = 0; i < detail::component_count(Result); ++i)
Result[i] = x > y ? a[i] : b[i];
return Result;
}
// Max comparison between 2 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<U, P> associatedMax
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<U, P> associatedMax
(
T x, const detail::tvec3<U, P>& a,
T y, const detail::tvec3<U, P>& b
vecType<T, P> const & x, U a,
vecType<T, P> const & y, U b
)
{
detail::tvec3<U, P> Result;
for(typename detail::tvec3<U, P>::size_type i = 0; i < Result.length(); ++i)
Result[i] = x > y ? a[i] : b[i];
return Result;
}
// Max comparison between 2 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<U, P> associatedMax
(
T x, const detail::tvec4<U, P>& a,
T y, const detail::tvec4<U, P>& b
)
{
detail::tvec4<U, P> Result;
for(typename detail::tvec4<U, P>::size_type i = 0; i < Result.length(); ++i)
Result[i] = x > y ? a[i] : b[i];
return Result;
}
// Max comparison between 2 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<U, P> associatedMax
(
const detail::tvec2<T, P>& x, U a,
const detail::tvec2<T, P>& y, U b
)
{
detail::tvec2<U, P> Result;
for(typename detail::tvec2<T, P>::size_type i = 0; i < Result.length(); ++i)
Result[i] = x[i] > y[i] ? a : b;
return Result;
}
// Max comparison between 2 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<U, P> associatedMax
(
const detail::tvec3<T, P>& x, U a,
const detail::tvec3<T, P>& y, U b
)
{
detail::tvec3<U, P> Result;
for(typename detail::tvec3<T, P>::size_type i = 0; i < Result.length(); ++i)
Result[i] = x[i] > y[i] ? a : b;
return Result;
}
// Max comparison between 2 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<U, P> associatedMax
(
const detail::tvec4<T, P>& x, U a,
const detail::tvec4<T, P>& y, U b
)
{
detail::tvec4<U, P> Result;
for(typename detail::tvec4<T, P>::size_type i = 0; i < Result.length(); ++i)
vecType<T, P> Result(uninitialize);
for(detail::component_count_t i = 0; i < detail::component_count(Result); ++i)
Result[i] = x[i] > y[i] ? a : b;
return Result;
}
@@ -556,136 +253,46 @@ GLM_FUNC_QUALIFIER U associatedMax
}
// Max comparison between 3 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<U, P> associatedMax
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<U, P> associatedMax
(
const detail::tvec2<T, P>& x, const detail::tvec2<U, P>& a,
const detail::tvec2<T, P>& y, const detail::tvec2<U, P>& b,
const detail::tvec2<T, P>& z, const detail::tvec2<U, P>& c
vecType<T, P> const & x, vecType<U, P> const & a,
vecType<T, P> const & y, vecType<U, P> const & b,
vecType<T, P> const & z, vecType<U, P> const & c
)
{
detail::tvec2<U, P> Result;
for(typename detail::tvec2<U, P>::size_type i = 0; i < Result.length(); ++i)
vecType<U, P> Result(uninitialize);
for(detail::component_count_t i = 0; i < detail::component_count(Result); ++i)
Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a[i] : c[i]) : (y[i] > z[i] ? b[i] : c[i]);
return Result;
}
// Max comparison between 3 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<U, P> associatedMax
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> associatedMax
(
const detail::tvec3<T, P>& x, const detail::tvec3<U, P>& a,
const detail::tvec3<T, P>& y, const detail::tvec3<U, P>& b,
const detail::tvec3<T, P>& z, const detail::tvec3<U, P>& c
T x, vecType<U, P> const & a,
T y, vecType<U, P> const & b,
T z, vecType<U, P> const & c
)
{
detail::tvec3<U, P> Result;
for(typename detail::tvec3<U, P>::size_type i = 0; i < Result.length(); ++i)
Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a[i] : c[i]) : (y[i] > z[i] ? b[i] : c[i]);
return Result;
}
// Max comparison between 3 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<U, P> associatedMax
(
const detail::tvec4<T, P>& x, const detail::tvec4<U, P>& a,
const detail::tvec4<T, P>& y, const detail::tvec4<U, P>& b,
const detail::tvec4<T, P>& z, const detail::tvec4<U, P>& c
)
{
detail::tvec4<U, P> Result;
for(typename detail::tvec4<U, P>::size_type i = 0; i < Result.length(); ++i)
Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a[i] : c[i]) : (y[i] > z[i] ? b[i] : c[i]);
return Result;
}
// Max comparison between 3 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<U, P> associatedMax
(
T x, const detail::tvec2<U, P>& a,
T y, const detail::tvec2<U, P>& b,
T z, const detail::tvec2<U, P>& c
)
{
detail::tvec2<U, P> Result;
for(typename detail::tvec2<U, P>::size_type i = 0; i < Result.length(); ++i)
vecType<U, P> Result(uninitialize);
for(detail::component_count_t i = 0; i < detail::component_count(Result); ++i)
Result[i] = x > y ? (x > z ? a[i] : c[i]) : (y > z ? b[i] : c[i]);
return Result;
}
// Max comparison between 3 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<U, P> associatedMax
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<U, P> associatedMax
(
T x, const detail::tvec3<U, P>& a,
T y, const detail::tvec3<U, P>& b,
T z, const detail::tvec3<U, P>& c
vecType<T, P> const & x, U a,
vecType<T, P> const & y, U b,
vecType<T, P> const & z, U c
)
{
detail::tvec3<U, P> Result;
for(typename detail::tvec3<U, P>::size_type i = 0; i < Result.length(); ++i)
Result[i] = x > y ? (x > z ? a[i] : c[i]) : (y > z ? b[i] : c[i]);
return Result;
}
// Max comparison between 3 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<U, P> associatedMax
(
T x, const detail::tvec4<U, P>& a,
T y, const detail::tvec4<U, P>& b,
T z, const detail::tvec4<U, P>& c
)
{
detail::tvec4<U, P> Result;
for(typename detail::tvec4<U, P>::size_type i = 0; i < Result.length(); ++i)
Result[i] = x > y ? (x > z ? a[i] : c[i]) : (y > z ? b[i] : c[i]);
return Result;
}
// Max comparison between 3 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<U, P> associatedMax
(
const detail::tvec2<T, P>& x, U a,
const detail::tvec2<T, P>& y, U b,
const detail::tvec2<T, P>& z, U c
)
{
detail::tvec2<U, P> Result;
for(typename detail::tvec2<T, P>::size_type i = 0; i < Result.length(); ++i)
Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a : c) : (y[i] > z[i] ? b : c);
return Result;
}
// Max comparison between 3 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<U, P> associatedMax
(
const detail::tvec3<T, P>& x, U a,
const detail::tvec3<T, P>& y, U b,
const detail::tvec3<T, P>& z, U c
)
{
detail::tvec3<U, P> Result;
for(typename detail::tvec3<T, P>::size_type i = 0; i < Result.length(); ++i)
Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a : c) : (y[i] > z[i] ? b : c);
return Result;
}
// Max comparison between 3 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<U, P> associatedMax
(
const detail::tvec4<T, P>& x, U a,
const detail::tvec4<T, P>& y, U b,
const detail::tvec4<T, P>& z, U c
)
{
detail::tvec4<U, P> Result;
for(typename detail::tvec4<T, P>::size_type i = 0; i < Result.length(); ++i)
vecType<T, P> Result(uninitialize);
for(detail::component_count_t i = 0; i < detail::component_count(Result); ++i)
Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a : c) : (y[i] > z[i] ? b : c);
return Result;
}
@@ -709,17 +316,17 @@ GLM_FUNC_QUALIFIER U associatedMax
}
// Max comparison between 4 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<U, P> associatedMax
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<U, P> associatedMax
(
const detail::tvec2<T, P>& x, const detail::tvec2<U, P>& a,
const detail::tvec2<T, P>& y, const detail::tvec2<U, P>& b,
const detail::tvec2<T, P>& z, const detail::tvec2<U, P>& c,
const detail::tvec2<T, P>& w, const detail::tvec2<U, P>& d
vecType<T, P> const & x, vecType<U, P> const & a,
vecType<T, P> const & y, vecType<U, P> const & b,
vecType<T, P> const & z, vecType<U, P> const & c,
vecType<T, P> const & w, vecType<U, P> const & d
)
{
detail::tvec2<U, P> Result;
for(typename detail::tvec2<U, P>::size_type i = 0; i < Result.length(); ++i)
vecType<U, P> Result(uninitialize);
for(detail::component_count_t i = 0; i < detail::component_count(Result); ++i)
{
T Test1 = max(x[i], y[i]);
T Test2 = max(z[i], w[i]);
@@ -731,64 +338,20 @@ GLM_FUNC_QUALIFIER detail::tvec2<U, P> associatedMax
}
// Max comparison between 4 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<U, P> associatedMax
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<U, P> associatedMax
(
const detail::tvec3<T, P>& x, const detail::tvec3<U, P>& a,
const detail::tvec3<T, P>& y, const detail::tvec3<U, P>& b,
const detail::tvec3<T, P>& z, const detail::tvec3<U, P>& c,
const detail::tvec3<T, P>& w, const detail::tvec3<U, P>& d
)
{
detail::tvec3<U, P> Result;
for(typename detail::tvec3<U, P>::size_type i = 0; i < Result.length(); ++i)
{
T Test1 = max(x[i], y[i]);
T Test2 = max(z[i], w[i]);
U Result1 = x[i] > y[i] ? a[i] : b[i];
U Result2 = z[i] > w[i] ? c[i] : d[i];
Result[i] = Test1 > Test2 ? Result1 : Result2;
}
return Result;
}
// Max comparison between 4 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<U, P> associatedMax
(
const detail::tvec4<T, P>& x, const detail::tvec4<U, P>& a,
const detail::tvec4<T, P>& y, const detail::tvec4<U, P>& b,
const detail::tvec4<T, P>& z, const detail::tvec4<U, P>& c,
const detail::tvec4<T, P>& w, const detail::tvec4<U, P>& d
)
{
detail::tvec4<U, P> Result;
for(typename detail::tvec4<U, P>::size_type i = 0; i < Result.length(); ++i)
{
T Test1 = max(x[i], y[i]);
T Test2 = max(z[i], w[i]);
U Result1 = x[i] > y[i] ? a[i] : b[i];
U Result2 = z[i] > w[i] ? c[i] : d[i];
Result[i] = Test1 > Test2 ? Result1 : Result2;
}
return Result;
}
// Max comparison between 4 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<U, P> associatedMax
(
T x, const detail::tvec2<U, P>& a,
T y, const detail::tvec2<U, P>& b,
T z, const detail::tvec2<U, P>& c,
T w, const detail::tvec2<U, P>& d
T x, vecType<U, P> const & a,
T y, vecType<U, P> const & b,
T z, vecType<U, P> const & c,
T w, vecType<U, P> const & d
)
{
T Test1 = max(x, y);
T Test2 = max(z, w);
detail::tvec2<U, P> Result;
for(typename detail::tvec2<U, P>::size_type i = 0; i < Result.length(); ++i)
vecType<U, P> Result(uninitialize);
for(detail::component_count_t i = 0; i < detail::component_count(Result); ++i)
{
U Result1 = x > y ? a[i] : b[i];
U Result2 = z > w ? c[i] : d[i];
@@ -798,63 +361,17 @@ GLM_FUNC_QUALIFIER detail::tvec2<U, P> associatedMax
}
// Max comparison between 4 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<U, P> associatedMax
template<typename T, typename U, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<U, P> associatedMax
(
T x, const detail::tvec3<U, P>& a,
T y, const detail::tvec3<U, P>& b,
T z, const detail::tvec3<U, P>& c,
T w, const detail::tvec3<U, P>& d
vecType<T, P> const & x, U a,
vecType<T, P> const & y, U b,
vecType<T, P> const & z, U c,
vecType<T, P> const & w, U d
)
{
T Test1 = max(x, y);
T Test2 = max(z, w);
detail::tvec3<U, P> Result;
for(typename detail::tvec3<U, P>::size_type i = 0; i < Result.length(); ++i)
{
U Result1 = x > y ? a[i] : b[i];
U Result2 = z > w ? c[i] : d[i];
Result[i] = Test1 > Test2 ? Result1 : Result2;
}
return Result;
}
// Max comparison between 4 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<U, P> associatedMax
(
T x, const detail::tvec4<U, P>& a,
T y, const detail::tvec4<U, P>& b,
T z, const detail::tvec4<U, P>& c,
T w, const detail::tvec4<U, P>& d
)
{
T Test1 = max(x, y);
T Test2 = max(z, w);
detail::tvec4<U, P> Result;
for(typename detail::tvec4<U, P>::size_type i = 0; i < Result.length(); ++i)
{
U Result1 = x > y ? a[i] : b[i];
U Result2 = z > w ? c[i] : d[i];
Result[i] = Test1 > Test2 ? Result1 : Result2;
}
return Result;
}
// Max comparison between 4 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<U, P> associatedMax
(
const detail::tvec2<T, P>& x, U a,
const detail::tvec2<T, P>& y, U b,
const detail::tvec2<T, P>& z, U c,
const detail::tvec2<T, P>& w, U d
)
{
detail::tvec2<U, P> Result;
for(typename detail::tvec2<T, P>::size_type i = 0; i < Result.length(); ++i)
vecType<U, P> Result(uninitialize);
for(detail::component_count_t i = 0; i < detail::component_count(Result); ++i)
{
T Test1 = max(x[i], y[i]);
T Test2 = max(z[i], w[i]);;
@@ -864,49 +381,4 @@ GLM_FUNC_QUALIFIER detail::tvec2<U, P> associatedMax
}
return Result;
}
// Max comparison between 4 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<U, P> associatedMax
(
const detail::tvec3<T, P>& x, U a,
const detail::tvec3<T, P>& y, U b,
const detail::tvec3<T, P>& z, U c,
const detail::tvec3<T, P>& w, U d
)
{
detail::tvec3<U, P> Result;
for(typename detail::tvec3<T, P>::size_type i = 0; i < Result.length(); ++i)
{
T Test1 = max(x[i], y[i]);
T Test2 = max(z[i], w[i]);;
U Result1 = x[i] > y[i] ? a : b;
U Result2 = z[i] > w[i] ? c : d;
Result[i] = Test1 > Test2 ? Result1 : Result2;
}
return Result;
}
// Max comparison between 4 variables
template<typename T, typename U, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<U, P> associatedMax
(
const detail::tvec4<T, P>& x, U a,
const detail::tvec4<T, P>& y, U b,
const detail::tvec4<T, P>& z, U c,
const detail::tvec4<T, P>& w, U d
)
{
detail::tvec4<U, P> Result;
for(typename detail::tvec4<T, P>::size_type i = 0; i < Result.length(); ++i)
{
T Test1 = max(x[i], y[i]);
T Test2 = max(z[i], w[i]);;
U Result1 = x[i] > y[i] ? a : b;
U Result2 = z[i] > w[i] ? c : d;
Result[i] = Test1 > Test2 ? Result1 : Result2;
}
return Result;
}
}//namespace glm
common/glm/glm/gtx/bit.hpp
+51 -165
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -36,16 +40,13 @@
/// <glm/gtx/bit.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_bit
#define GLM_GTX_bit
#pragma once
// Dependencies
#include "../detail/type_int.hpp"
#include "../detail/setup.hpp"
#include <cstddef>
#include "../gtc/bitfield.hpp"
#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
# pragma message("GLM: GLM_GTX_bit extension included")
#if(defined(GLM_MESSAGES))
# pragma message("GLM: GLM_GTX_bit extension is deprecated, include GLM_GTC_bitfield and GLM_GTC_integer instead")
#endif
namespace glm
@@ -53,182 +54,67 @@ namespace glm
/// @addtogroup gtx_bit
/// @{
/// Build a mask of 'count' bits
/// @see gtx_bit
template <typename genIType>
GLM_FUNC_DECL genIType mask(genIType const & count);
//! Find the highest bit set to 1 in a integer variable and return its value.
/// @see gtx_bit
template <typename genType>
GLM_FUNC_DECL genType highestBitValue(genType const & value);
//! Return true if the value is a power of two number.
/// @see gtx_bit
template <typename genType>
GLM_FUNC_DECL bool isPowerOfTwo(genType const & value);
//! Return the power of two number which value is just higher the input value.
/// @see gtx_bit
template <typename genType>
GLM_FUNC_DECL genType powerOfTwoAbove(genType const & value);
//! Return the power of two number which value is just lower the input value.
/// @see gtx_bit
template <typename genType>
GLM_FUNC_DECL genType powerOfTwoBelow(genType const & value);
//! Return the power of two number which value is the closet to the input value.
/// @see gtx_bit
template <typename genType>
GLM_FUNC_DECL genType powerOfTwoNearest(genType const & value);
//! Revert all bits of any integer based type.
/// @see gtx_bit
template <typename genType>
GLM_DEPRECATED GLM_FUNC_DECL genType bitRevert(genType const & value);
//! Rotate all bits to the right.
/// @see gtx_bit
template <typename genType>
GLM_FUNC_DECL genType bitRotateRight(genType const & In, std::size_t Shift);
//! Rotate all bits to the left.
/// @see gtx_bit
template <typename genType>
GLM_FUNC_DECL genType bitRotateLeft(genType const & In, std::size_t Shift);
//! Set to 1 a range of bits.
/// @see gtx_bit
template <typename genIUType>
GLM_FUNC_DECL genIUType fillBitfieldWithOne(
genIUType const & Value,
int const & FromBit,
int const & ToBit);
GLM_FUNC_DECL genIUType highestBitValue(genIUType Value);
//! Set to 0 a range of bits.
/// Find the highest bit set to 1 in a integer variable and return its value.
///
/// @see gtx_bit
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> highestBitValue(vecType<T, P> const & value);
/// Return the power of two number which value is just higher the input value.
/// Deprecated, use ceilPowerOfTwo from GTC_round instead
///
/// @see gtc_round
/// @see gtx_bit
template <typename genIUType>
GLM_FUNC_DECL genIUType fillBitfieldWithZero(
genIUType const & Value,
int const & FromBit,
int const & ToBit);
GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoAbove(genIUType Value);
/// Interleaves the bits of x and y.
/// The first bit is the first bit of x followed by the first bit of y.
/// The other bits are interleaved following the previous sequence.
///
/// Return the power of two number which value is just higher the input value.
/// Deprecated, use ceilPowerOfTwo from GTC_round instead
///
/// @see gtc_round
/// @see gtx_bit
GLM_FUNC_DECL int16 bitfieldInterleave(int8 x, int8 y);
template <typename T, precision P, template <typename, precision> class vecType>
GLM_DEPRECATED GLM_FUNC_DECL vecType<T, P> powerOfTwoAbove(vecType<T, P> const & value);
/// Interleaves the bits of x and y.
/// The first bit is the first bit of x followed by the first bit of y.
/// The other bits are interleaved following the previous sequence.
///
/// Return the power of two number which value is just lower the input value.
/// Deprecated, use floorPowerOfTwo from GTC_round instead
///
/// @see gtc_round
/// @see gtx_bit
GLM_FUNC_DECL uint16 bitfieldInterleave(uint8 x, uint8 y);
template <typename genIUType>
GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoBelow(genIUType Value);
/// Interleaves the bits of x and y.
/// The first bit is the first bit of x followed by the first bit of y.
/// The other bits are interleaved following the previous sequence.
///
/// Return the power of two number which value is just lower the input value.
/// Deprecated, use floorPowerOfTwo from GTC_round instead
///
/// @see gtc_round
/// @see gtx_bit
GLM_FUNC_DECL int32 bitfieldInterleave(int16 x, int16 y);
template <typename T, precision P, template <typename, precision> class vecType>
GLM_DEPRECATED GLM_FUNC_DECL vecType<T, P> powerOfTwoBelow(vecType<T, P> const & value);
/// Interleaves the bits of x and y.
/// The first bit is the first bit of x followed by the first bit of y.
/// The other bits are interleaved following the previous sequence.
///
/// Return the power of two number which value is the closet to the input value.
/// Deprecated, use roundPowerOfTwo from GTC_round instead
///
/// @see gtc_round
/// @see gtx_bit
GLM_FUNC_DECL uint32 bitfieldInterleave(uint16 x, uint16 y);
template <typename genIUType>
GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoNearest(genIUType Value);
/// Interleaves the bits of x and y.
/// The first bit is the first bit of x followed by the first bit of y.
/// The other bits are interleaved following the previous sequence.
///
/// Return the power of two number which value is the closet to the input value.
/// Deprecated, use roundPowerOfTwo from GTC_round instead
///
/// @see gtc_round
/// @see gtx_bit
GLM_FUNC_DECL int64 bitfieldInterleave(int32 x, int32 y);
/// Interleaves the bits of x and y.
/// The first bit is the first bit of x followed by the first bit of y.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL uint64 bitfieldInterleave(uint32 x, uint32 y);
/// Interleaves the bits of x, y and z.
/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL int32 bitfieldInterleave(int8 x, int8 y, int8 z);
/// Interleaves the bits of x, y and z.
/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z);
/// Interleaves the bits of x, y and z.
/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL int64 bitfieldInterleave(int16 x, int16 y, int16 z);
/// Interleaves the bits of x, y and z.
/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z);
/// Interleaves the bits of x, y and z.
/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL int64 bitfieldInterleave(int32 x, int32 y, int32 z);
/// Interleaves the bits of x, y and z.
/// The first bit is the first bit of x followed by the first bit of y and the first bit of z.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL uint64 bitfieldInterleave(uint32 x, uint32 y, uint32 z);
/// Interleaves the bits of x, y, z and w.
/// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL int32 bitfieldInterleave(int8 x, int8 y, int8 z, int8 w);
/// Interleaves the bits of x, y, z and w.
/// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z, uint8 w);
/// Interleaves the bits of x, y, z and w.
/// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL int64 bitfieldInterleave(int16 x, int16 y, int16 z, int16 w);
/// Interleaves the bits of x, y, z and w.
/// The first bit is the first bit of x followed by the first bit of y, the first bit of z and finally the first bit of w.
/// The other bits are interleaved following the previous sequence.
///
/// @see gtx_bit
GLM_FUNC_DECL uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w);
template <typename T, precision P, template <typename, precision> class vecType>
GLM_DEPRECATED GLM_FUNC_DECL vecType<T, P> powerOfTwoNearest(vecType<T, P> const & value);
/// @}
} //namespace glm
#include "bit.inl"
#endif//GLM_GTX_bit
common/glm/glm/gtx/bit.inl
+64 -739
View File
@@ -1,37 +1,45 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2007-03-14
// Updated : 2013-12-25
// Licence : This source is under MIT License
// File : glm/gtx/bit.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
#include "../detail/_vectorize.hpp"
#include <limits>
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_bit
/// @file glm/gtx/bit.inl
/// @date 2014-11-25 / 2014-11-25
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
template <typename genIType>
GLM_FUNC_QUALIFIER genIType mask
(
genIType const & count
)
{
return ((genIType(1) << (count)) - genIType(1));
}
VECTORIZE_VEC(mask)
///////////////////
// highestBitValue
template <typename genType>
GLM_FUNC_QUALIFIER genType highestBitValue
(
genType const & value
)
template <typename genIUType>
GLM_FUNC_QUALIFIER genIUType highestBitValue(genIUType Value)
{
genType tmp = value;
genType result = genType(0);
genIUType tmp = Value;
genIUType result = genIUType(0);
while(tmp)
{
result = (tmp & (~tmp + 1)); // grab lowest bit
@@ -40,743 +48,60 @@ namespace glm
return result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<int, P> highestBitValue
(
detail::tvec2<T, P> const & value
)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> highestBitValue(vecType<T, P> const & v)
{
return detail::tvec2<int, P>(
highestBitValue(value[0]),
highestBitValue(value[1]));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<int, P> highestBitValue
(
detail::tvec3<T, P> const & value
)
{
return detail::tvec3<int, P>(
highestBitValue(value[0]),
highestBitValue(value[1]),
highestBitValue(value[2]));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<int, P> highestBitValue
(
detail::tvec4<T, P> const & value
)
{
return detail::tvec4<int, P>(
highestBitValue(value[0]),
highestBitValue(value[1]),
highestBitValue(value[2]),
highestBitValue(value[3]));
}
// isPowerOfTwo
template <typename genType>
GLM_FUNC_QUALIFIER bool isPowerOfTwo(genType const & Value)
{
//detail::If<std::numeric_limits<genType>::is_signed>::apply(abs, Value);
//return !(Value & (Value - 1));
// For old complier?
genType Result = Value;
if(std::numeric_limits<genType>::is_signed)
Result = abs(Result);
return !(Result & (Result - 1));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<bool, P> isPowerOfTwo
(
detail::tvec2<T, P> const & value
)
{
return detail::tvec2<bool, P>(
isPowerOfTwo(value[0]),
isPowerOfTwo(value[1]));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<bool, P> isPowerOfTwo
(
detail::tvec3<T, P> const & value
)
{
return detail::tvec3<bool, P>(
isPowerOfTwo(value[0]),
isPowerOfTwo(value[1]),
isPowerOfTwo(value[2]));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<bool, P> isPowerOfTwo
(
detail::tvec4<T, P> const & value
)
{
return detail::tvec4<bool, P>(
isPowerOfTwo(value[0]),
isPowerOfTwo(value[1]),
isPowerOfTwo(value[2]),
isPowerOfTwo(value[3]));
return detail::functor1<T, T, P, vecType>::call(highestBitValue, v);
}
///////////////////
// powerOfTwoAbove
template <typename genType>
GLM_FUNC_QUALIFIER genType powerOfTwoAbove(genType const & value)
GLM_FUNC_QUALIFIER genType powerOfTwoAbove(genType value)
{
return isPowerOfTwo(value) ? value : highestBitValue(value) << 1;
}
VECTORIZE_VEC(powerOfTwoAbove)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> powerOfTwoAbove(vecType<T, P> const & v)
{
return detail::functor1<T, T, P, vecType>::call(powerOfTwoAbove, v);
}
///////////////////
// powerOfTwoBelow
template <typename genType>
GLM_FUNC_QUALIFIER genType powerOfTwoBelow
(
genType const & value
)
GLM_FUNC_QUALIFIER genType powerOfTwoBelow(genType value)
{
return isPowerOfTwo(value) ? value : highestBitValue(value);
}
VECTORIZE_VEC(powerOfTwoBelow)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> powerOfTwoBelow(vecType<T, P> const & v)
{
return detail::functor1<T, T, P, vecType>::call(powerOfTwoBelow, v);
}
/////////////////////
// powerOfTwoNearest
template <typename genType>
GLM_FUNC_QUALIFIER genType powerOfTwoNearest
(
genType const & value
)
GLM_FUNC_QUALIFIER genType powerOfTwoNearest(genType value)
{
if(isPowerOfTwo(value))
return value;
genType prev = highestBitValue(value);
genType next = prev << 1;
genType const prev = highestBitValue(value);
genType const next = prev << 1;
return (next - value) < (value - prev) ? next : prev;
}
VECTORIZE_VEC(powerOfTwoNearest)
template <typename genType>
GLM_FUNC_QUALIFIER genType bitRevert(genType const & In)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> powerOfTwoNearest(vecType<T, P> const & v)
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_integer, "'bitRevert' only accept integer values");
genType Out = 0;
std::size_t BitSize = sizeof(genType) * 8;
for(std::size_t i = 0; i < BitSize; ++i)
if(In & (genType(1) << i))
Out |= genType(1) << (BitSize - 1 - i);
return Out;
}
VECTORIZE_VEC(bitRevert)
template <typename genType>
GLM_FUNC_QUALIFIER genType bitRotateRight(genType const & In, std::size_t Shift)
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_integer, "'bitRotateRight' only accept integer values");
std::size_t BitSize = sizeof(genType) * 8;
return (In << Shift) | (In >> (BitSize - Shift));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> bitRotateRight
(
detail::tvec2<T, P> const & Value,
std::size_t Shift
)
{
return detail::tvec2<T, P>(
bitRotateRight(Value[0], Shift),
bitRotateRight(Value[1], Shift));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> bitRotateRight
(
detail::tvec3<T, P> const & Value,
std::size_t Shift
)
{
return detail::tvec3<T, P>(
bitRotateRight(Value[0], Shift),
bitRotateRight(Value[1], Shift),
bitRotateRight(Value[2], Shift));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> bitRotateRight
(
detail::tvec4<T, P> const & Value,
std::size_t Shift
)
{
return detail::tvec4<T, P>(
bitRotateRight(Value[0], Shift),
bitRotateRight(Value[1], Shift),
bitRotateRight(Value[2], Shift),
bitRotateRight(Value[3], Shift));
}
template <typename genType>
GLM_FUNC_QUALIFIER genType bitRotateLeft(genType const & In, std::size_t Shift)
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_integer, "'bitRotateLeft' only accept integer values");
std::size_t BitSize = sizeof(genType) * 8;
return (In >> Shift) | (In << (BitSize - Shift));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> bitRotateLeft
(
detail::tvec2<T, P> const & Value,
std::size_t Shift
)
{
return detail::tvec2<T, P>(
bitRotateLeft(Value[0], Shift),
bitRotateLeft(Value[1], Shift));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> bitRotateLeft
(
detail::tvec3<T, P> const & Value,
std::size_t Shift
)
{
return detail::tvec3<T, P>(
bitRotateLeft(Value[0], Shift),
bitRotateLeft(Value[1], Shift),
bitRotateLeft(Value[2], Shift));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> bitRotateLeft
(
detail::tvec4<T, P> const & Value,
std::size_t Shift
)
{
return detail::tvec4<T, P>(
bitRotateLeft(Value[0], Shift),
bitRotateLeft(Value[1], Shift),
bitRotateLeft(Value[2], Shift),
bitRotateLeft(Value[3], Shift));
}
template <typename genIUType>
GLM_FUNC_QUALIFIER genIUType fillBitfieldWithOne
(
genIUType const & Value,
int const & FromBit,
int const & ToBit
)
{
assert(FromBit <= ToBit);
assert(ToBit <= sizeof(genIUType) * std::size_t(8));
genIUType Result = Value;
for(std::size_t i = 0; i <= ToBit; ++i)
Result |= (1 << i);
return Result;
}
template <typename genIUType>
GLM_FUNC_QUALIFIER genIUType fillBitfieldWithZero
(
genIUType const & Value,
int const & FromBit,
int const & ToBit
)
{
assert(FromBit <= ToBit);
assert(ToBit <= sizeof(genIUType) * std::size_t(8));
genIUType Result = Value;
for(std::size_t i = 0; i <= ToBit; ++i)
Result &= ~(1 << i);
return Result;
}
namespace detail
{
template <typename PARAM, typename RET>
GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y);
template <typename PARAM, typename RET>
GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y, PARAM z);
template <typename PARAM, typename RET>
GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y, PARAM z, PARAM w);
/*
template <typename PARAM, typename RET>
inline RET bitfieldInterleave(PARAM x, PARAM y)
{
RET Result = 0;
for (int i = 0; i < sizeof(PARAM) * 8; i++)
Result |= (x & 1U << i) << i | (y & 1U << i) << (i + 1);
return Result;
}
template <typename PARAM, typename RET>
inline RET bitfieldInterleave(PARAM x, PARAM y, PARAM z)
{
RET Result = 0;
for (RET i = 0; i < sizeof(PARAM) * 8; i++)
{
Result |= ((RET(x) & (RET(1) << i)) << ((i << 1) + 0));
Result |= ((RET(y) & (RET(1) << i)) << ((i << 1) + 1));
Result |= ((RET(z) & (RET(1) << i)) << ((i << 1) + 2));
}
return Result;
}
template <typename PARAM, typename RET>
inline RET bitfieldInterleave(PARAM x, PARAM y, PARAM z, PARAM w)
{
RET Result = 0;
for (int i = 0; i < sizeof(PARAM) * 8; i++)
{
Result |= ((((RET(x) >> i) & RET(1))) << RET((i << 2) + 0));
Result |= ((((RET(y) >> i) & RET(1))) << RET((i << 2) + 1));
Result |= ((((RET(z) >> i) & RET(1))) << RET((i << 2) + 2));
Result |= ((((RET(w) >> i) & RET(1))) << RET((i << 2) + 3));
}
return Result;
}
*/
template <>
GLM_FUNC_QUALIFIER glm::uint16 bitfieldInterleave(glm::uint8 x, glm::uint8 y)
{
glm::uint16 REG1(x);
glm::uint16 REG2(y);
REG1 = ((REG1 << 4) | REG1) & glm::uint16(0x0F0F);
REG2 = ((REG2 << 4) | REG2) & glm::uint16(0x0F0F);
REG1 = ((REG1 << 2) | REG1) & glm::uint16(0x3333);
REG2 = ((REG2 << 2) | REG2) & glm::uint16(0x3333);
REG1 = ((REG1 << 1) | REG1) & glm::uint16(0x5555);
REG2 = ((REG2 << 1) | REG2) & glm::uint16(0x5555);
return REG1 | (REG2 << 1);
}
template <>
GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint16 x, glm::uint16 y)
{
glm::uint32 REG1(x);
glm::uint32 REG2(y);
REG1 = ((REG1 << 8) | REG1) & glm::uint32(0x00FF00FF);
REG2 = ((REG2 << 8) | REG2) & glm::uint32(0x00FF00FF);
REG1 = ((REG1 << 4) | REG1) & glm::uint32(0x0F0F0F0F);
REG2 = ((REG2 << 4) | REG2) & glm::uint32(0x0F0F0F0F);
REG1 = ((REG1 << 2) | REG1) & glm::uint32(0x33333333);
REG2 = ((REG2 << 2) | REG2) & glm::uint32(0x33333333);
REG1 = ((REG1 << 1) | REG1) & glm::uint32(0x55555555);
REG2 = ((REG2 << 1) | REG2) & glm::uint32(0x55555555);
return REG1 | (REG2 << 1);
}
template <>
GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint32 x, glm::uint32 y)
{
glm::uint64 REG1(x);
glm::uint64 REG2(y);
REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x0000FFFF0000FFFF);
REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x0000FFFF0000FFFF);
REG1 = ((REG1 << 8) | REG1) & glm::uint64(0x00FF00FF00FF00FF);
REG2 = ((REG2 << 8) | REG2) & glm::uint64(0x00FF00FF00FF00FF);
REG1 = ((REG1 << 4) | REG1) & glm::uint64(0x0F0F0F0F0F0F0F0F);
REG2 = ((REG2 << 4) | REG2) & glm::uint64(0x0F0F0F0F0F0F0F0F);
REG1 = ((REG1 << 2) | REG1) & glm::uint64(0x3333333333333333);
REG2 = ((REG2 << 2) | REG2) & glm::uint64(0x3333333333333333);
REG1 = ((REG1 << 1) | REG1) & glm::uint64(0x5555555555555555);
REG2 = ((REG2 << 1) | REG2) & glm::uint64(0x5555555555555555);
return REG1 | (REG2 << 1);
}
template <>
GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint8 x, glm::uint8 y, glm::uint8 z)
{
glm::uint32 REG1(x);
glm::uint32 REG2(y);
glm::uint32 REG3(z);
REG1 = ((REG1 << 16) | REG1) & glm::uint32(0x00FF0000FF0000FF);
REG2 = ((REG2 << 16) | REG2) & glm::uint32(0x00FF0000FF0000FF);
REG3 = ((REG3 << 16) | REG3) & glm::uint32(0x00FF0000FF0000FF);
REG1 = ((REG1 << 8) | REG1) & glm::uint32(0xF00F00F00F00F00F);
REG2 = ((REG2 << 8) | REG2) & glm::uint32(0xF00F00F00F00F00F);
REG3 = ((REG3 << 8) | REG3) & glm::uint32(0xF00F00F00F00F00F);
REG1 = ((REG1 << 4) | REG1) & glm::uint32(0x30C30C30C30C30C3);
REG2 = ((REG2 << 4) | REG2) & glm::uint32(0x30C30C30C30C30C3);
REG3 = ((REG3 << 4) | REG3) & glm::uint32(0x30C30C30C30C30C3);
REG1 = ((REG1 << 2) | REG1) & glm::uint32(0x9249249249249249);
REG2 = ((REG2 << 2) | REG2) & glm::uint32(0x9249249249249249);
REG3 = ((REG3 << 2) | REG3) & glm::uint32(0x9249249249249249);
return REG1 | (REG2 << 1) | (REG3 << 2);
}
template <>
GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint16 x, glm::uint16 y, glm::uint16 z)
{
glm::uint64 REG1(x);
glm::uint64 REG2(y);
glm::uint64 REG3(z);
REG1 = ((REG1 << 32) | REG1) & glm::uint64(0xFFFF00000000FFFF);
REG2 = ((REG2 << 32) | REG2) & glm::uint64(0xFFFF00000000FFFF);
REG3 = ((REG3 << 32) | REG3) & glm::uint64(0xFFFF00000000FFFF);
REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x00FF0000FF0000FF);
REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x00FF0000FF0000FF);
REG3 = ((REG3 << 16) | REG3) & glm::uint64(0x00FF0000FF0000FF);
REG1 = ((REG1 << 8) | REG1) & glm::uint64(0xF00F00F00F00F00F);
REG2 = ((REG2 << 8) | REG2) & glm::uint64(0xF00F00F00F00F00F);
REG3 = ((REG3 << 8) | REG3) & glm::uint64(0xF00F00F00F00F00F);
REG1 = ((REG1 << 4) | REG1) & glm::uint64(0x30C30C30C30C30C3);
REG2 = ((REG2 << 4) | REG2) & glm::uint64(0x30C30C30C30C30C3);
REG3 = ((REG3 << 4) | REG3) & glm::uint64(0x30C30C30C30C30C3);
REG1 = ((REG1 << 2) | REG1) & glm::uint64(0x9249249249249249);
REG2 = ((REG2 << 2) | REG2) & glm::uint64(0x9249249249249249);
REG3 = ((REG3 << 2) | REG3) & glm::uint64(0x9249249249249249);
return REG1 | (REG2 << 1) | (REG3 << 2);
}
template <>
GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint32 x, glm::uint32 y, glm::uint32 z)
{
glm::uint64 REG1(x);
glm::uint64 REG2(y);
glm::uint64 REG3(z);
REG1 = ((REG1 << 32) | REG1) & glm::uint64(0xFFFF00000000FFFF);
REG2 = ((REG2 << 32) | REG2) & glm::uint64(0xFFFF00000000FFFF);
REG3 = ((REG3 << 32) | REG3) & glm::uint64(0xFFFF00000000FFFF);
REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x00FF0000FF0000FF);
REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x00FF0000FF0000FF);
REG3 = ((REG3 << 16) | REG3) & glm::uint64(0x00FF0000FF0000FF);
REG1 = ((REG1 << 8) | REG1) & glm::uint64(0xF00F00F00F00F00F);
REG2 = ((REG2 << 8) | REG2) & glm::uint64(0xF00F00F00F00F00F);
REG3 = ((REG3 << 8) | REG3) & glm::uint64(0xF00F00F00F00F00F);
REG1 = ((REG1 << 4) | REG1) & glm::uint64(0x30C30C30C30C30C3);
REG2 = ((REG2 << 4) | REG2) & glm::uint64(0x30C30C30C30C30C3);
REG3 = ((REG3 << 4) | REG3) & glm::uint64(0x30C30C30C30C30C3);
REG1 = ((REG1 << 2) | REG1) & glm::uint64(0x9249249249249249);
REG2 = ((REG2 << 2) | REG2) & glm::uint64(0x9249249249249249);
REG3 = ((REG3 << 2) | REG3) & glm::uint64(0x9249249249249249);
return REG1 | (REG2 << 1) | (REG3 << 2);
}
template <>
GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint8 x, glm::uint8 y, glm::uint8 z, glm::uint8 w)
{
glm::uint32 REG1(x);
glm::uint32 REG2(y);
glm::uint32 REG3(z);
glm::uint32 REG4(w);
REG1 = ((REG1 << 12) | REG1) & glm::uint32(0x000F000F000F000F);
REG2 = ((REG2 << 12) | REG2) & glm::uint32(0x000F000F000F000F);
REG3 = ((REG3 << 12) | REG3) & glm::uint32(0x000F000F000F000F);
REG4 = ((REG4 << 12) | REG4) & glm::uint32(0x000F000F000F000F);
REG1 = ((REG1 << 6) | REG1) & glm::uint32(0x0303030303030303);
REG2 = ((REG2 << 6) | REG2) & glm::uint32(0x0303030303030303);
REG3 = ((REG3 << 6) | REG3) & glm::uint32(0x0303030303030303);
REG4 = ((REG4 << 6) | REG4) & glm::uint32(0x0303030303030303);
REG1 = ((REG1 << 3) | REG1) & glm::uint32(0x1111111111111111);
REG2 = ((REG2 << 3) | REG2) & glm::uint32(0x1111111111111111);
REG3 = ((REG3 << 3) | REG3) & glm::uint32(0x1111111111111111);
REG4 = ((REG4 << 3) | REG4) & glm::uint32(0x1111111111111111);
return REG1 | (REG2 << 1) | (REG3 << 2) | (REG4 << 3);
}
template <>
GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint16 x, glm::uint16 y, glm::uint16 z, glm::uint16 w)
{
glm::uint64 REG1(x);
glm::uint64 REG2(y);
glm::uint64 REG3(z);
glm::uint64 REG4(w);
REG1 = ((REG1 << 24) | REG1) & glm::uint64(0x000000FF000000FF);
REG2 = ((REG2 << 24) | REG2) & glm::uint64(0x000000FF000000FF);
REG3 = ((REG3 << 24) | REG3) & glm::uint64(0x000000FF000000FF);
REG4 = ((REG4 << 24) | REG4) & glm::uint64(0x000000FF000000FF);
REG1 = ((REG1 << 12) | REG1) & glm::uint64(0x000F000F000F000F);
REG2 = ((REG2 << 12) | REG2) & glm::uint64(0x000F000F000F000F);
REG3 = ((REG3 << 12) | REG3) & glm::uint64(0x000F000F000F000F);
REG4 = ((REG4 << 12) | REG4) & glm::uint64(0x000F000F000F000F);
REG1 = ((REG1 << 6) | REG1) & glm::uint64(0x0303030303030303);
REG2 = ((REG2 << 6) | REG2) & glm::uint64(0x0303030303030303);
REG3 = ((REG3 << 6) | REG3) & glm::uint64(0x0303030303030303);
REG4 = ((REG4 << 6) | REG4) & glm::uint64(0x0303030303030303);
REG1 = ((REG1 << 3) | REG1) & glm::uint64(0x1111111111111111);
REG2 = ((REG2 << 3) | REG2) & glm::uint64(0x1111111111111111);
REG3 = ((REG3 << 3) | REG3) & glm::uint64(0x1111111111111111);
REG4 = ((REG4 << 3) | REG4) & glm::uint64(0x1111111111111111);
return REG1 | (REG2 << 1) | (REG3 << 2) | (REG4 << 3);
}
}//namespace detail
GLM_FUNC_QUALIFIER int16 bitfieldInterleave(int8 x, int8 y)
{
union sign8
{
int8 i;
uint8 u;
} sign_x, sign_y;
union sign16
{
int16 i;
uint16 u;
} result;
sign_x.i = x;
sign_y.i = y;
result.u = bitfieldInterleave(sign_x.u, sign_y.u);
return result.i;
}
GLM_FUNC_QUALIFIER uint16 bitfieldInterleave(uint8 x, uint8 y)
{
return detail::bitfieldInterleave<uint8, uint16>(x, y);
}
GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int16 x, int16 y)
{
union sign16
{
int16 i;
uint16 u;
} sign_x, sign_y;
union sign32
{
int32 i;
uint32 u;
} result;
sign_x.i = x;
sign_y.i = y;
result.u = bitfieldInterleave(sign_x.u, sign_y.u);
return result.i;
}
GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint16 x, uint16 y)
{
return detail::bitfieldInterleave<uint16, uint32>(x, y);
}
GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int32 x, int32 y)
{
union sign32
{
int32 i;
uint32 u;
} sign_x, sign_y;
union sign64
{
int64 i;
uint64 u;
} result;
sign_x.i = x;
sign_y.i = y;
result.u = bitfieldInterleave(sign_x.u, sign_y.u);
return result.i;
}
GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint32 x, uint32 y)
{
return detail::bitfieldInterleave<uint32, uint64>(x, y);
}
GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int8 x, int8 y, int8 z)
{
union sign8
{
int8 i;
uint8 u;
} sign_x, sign_y, sign_z;
union sign32
{
int32 i;
uint32 u;
} result;
sign_x.i = x;
sign_y.i = y;
sign_z.i = z;
result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u);
return result.i;
}
GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z)
{
return detail::bitfieldInterleave<uint8, uint32>(x, y, z);
}
GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int16 x, int16 y, int16 z)
{
union sign16
{
int16 i;
uint16 u;
} sign_x, sign_y, sign_z;
union sign64
{
int64 i;
uint64 u;
} result;
sign_x.i = x;
sign_y.i = y;
sign_z.i = z;
result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u);
return result.i;
}
GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z)
{
return detail::bitfieldInterleave<uint32, uint64>(x, y, z);
}
GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int32 x, int32 y, int32 z)
{
union sign16
{
int32 i;
uint32 u;
} sign_x, sign_y, sign_z;
union sign64
{
int64 i;
uint64 u;
} result;
sign_x.i = x;
sign_y.i = y;
sign_z.i = z;
result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u);
return result.i;
}
GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint32 x, uint32 y, uint32 z)
{
return detail::bitfieldInterleave<uint32, uint64>(x, y, z);
}
GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int8 x, int8 y, int8 z, int8 w)
{
union sign8
{
int8 i;
uint8 u;
} sign_x, sign_y, sign_z, sign_w;
union sign32
{
int32 i;
uint32 u;
} result;
sign_x.i = x;
sign_y.i = y;
sign_z.i = z;
sign_w.i = w;
result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u, sign_w.u);
return result.i;
}
GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z, uint8 w)
{
return detail::bitfieldInterleave<uint8, uint32>(x, y, z, w);
}
GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int16 x, int16 y, int16 z, int16 w)
{
union sign16
{
int16 i;
uint16 u;
} sign_x, sign_y, sign_z, sign_w;
union sign64
{
int64 i;
uint64 u;
} result;
sign_x.i = x;
sign_y.i = y;
sign_z.i = z;
sign_w.i = w;
result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u, sign_w.u);
return result.i;
}
GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w)
{
return detail::bitfieldInterleave<uint16, uint64>(x, y, z, w);
return detail::functor1<T, T, P, vecType>::call(powerOfTwoNearest, v);
}
}//namespace glm
common/glm/glm/gtx/closest_point.hpp
+18 -10
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -20,8 +24,8 @@
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref gtx_bit
/// @file glm/gtx/bit.hpp
/// @ref gtx_closest_point
/// @file glm/gtx/closest_point.hpp
/// @date 2005-12-30 / 2011-06-07
/// @author Christophe Riccio
///
@@ -35,8 +39,7 @@
/// <glm/gtx/closest_point.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_closest_point
#define GLM_GTX_closest_point
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -53,14 +56,19 @@ namespace glm
/// Find the point on a straight line which is the closet of a point.
/// @see gtx_closest_point
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> closestPointOnLine(
detail::tvec3<T, P> const & point,
detail::tvec3<T, P> const & a,
detail::tvec3<T, P> const & b);
GLM_FUNC_DECL tvec3<T, P> closestPointOnLine(
tvec3<T, P> const & point,
tvec3<T, P> const & a,
tvec3<T, P> const & b);
/// 2d lines work as well
template <typename T, precision P>
GLM_FUNC_DECL tvec2<T, P> closestPointOnLine(
tvec2<T, P> const & point,
tvec2<T, P> const & a,
tvec2<T, P> const & b);
/// @}
}// namespace glm
#include "closest_point.inl"
#endif//GLM_GTX_closest_point
common/glm/glm/gtx/closest_point.inl
+57 -18
View File
@@ -1,28 +1,48 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_closest_point
/// @file glm/gtx/closest_point.inl
/// @date 2005-12-30 / 2011-06-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2005-12-30
// Updated : 2008-10-05
// Licence : This source is under MIT License
// File : glm/gtx/closest_point.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
#ifndef glm_gtx_closest_point
#define glm_gtx_closest_point
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> closestPointOnLine
GLM_FUNC_QUALIFIER tvec3<T, P> closestPointOnLine
(
detail::tvec3<T, P> const & point,
detail::tvec3<T, P> const & a,
detail::tvec3<T, P> const & b
tvec3<T, P> const & point,
tvec3<T, P> const & a,
tvec3<T, P> const & b
)
{
T LineLength = distance(a, b);
detail::tvec3<T, P> Vector = point - a;
detail::tvec3<T, P> LineDirection = (b - a) / LineLength;
tvec3<T, P> Vector = point - a;
tvec3<T, P> LineDirection = (b - a) / LineLength;
// Project Vector to LineDirection to get the distance of point from a
T Distance = dot(Vector, LineDirection);
@@ -31,6 +51,25 @@ namespace glm
if(Distance >= LineLength) return b;
return a + LineDirection * Distance;
}
}//namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec2<T, P> closestPointOnLine
(
tvec2<T, P> const & point,
tvec2<T, P> const & a,
tvec2<T, P> const & b
)
{
T LineLength = distance(a, b);
tvec2<T, P> Vector = point - a;
tvec2<T, P> LineDirection = (b - a) / LineLength;
#endif//glm_gtx_closest_point
// Project Vector to LineDirection to get the distance of point from a
T Distance = dot(Vector, LineDirection);
if(Distance <= T(0)) return a;
if(Distance >= LineLength) return b;
return a + LineDirection * Distance;
}
}//namespace glm
common/glm/glm/gtx/color_space.hpp
+16 -15
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -35,8 +39,7 @@
/// <glm/gtx/color_space.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_color_space
#define GLM_GTX_color_space
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -53,44 +56,42 @@ namespace glm
/// Converts a color from HSV color space to its color in RGB color space.
/// @see gtx_color_space
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> rgbColor(
detail::tvec3<T, P> const & hsvValue);
GLM_FUNC_DECL tvec3<T, P> rgbColor(
tvec3<T, P> const & hsvValue);
/// Converts a color from RGB color space to its color in HSV color space.
/// @see gtx_color_space
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> hsvColor(
detail::tvec3<T, P> const & rgbValue);
GLM_FUNC_DECL tvec3<T, P> hsvColor(
tvec3<T, P> const & rgbValue);
/// Build a saturation matrix.
/// @see gtx_color_space
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> saturation(
template <typename T>
GLM_FUNC_DECL tmat4x4<T, defaultp> saturation(
T const s);
/// Modify the saturation of a color.
/// @see gtx_color_space
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> saturation(
GLM_FUNC_DECL tvec3<T, P> saturation(
T const s,
detail::tvec3<T, P> const & color);
tvec3<T, P> const & color);
/// Modify the saturation of a color.
/// @see gtx_color_space
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<T, P> saturation(
GLM_FUNC_DECL tvec4<T, P> saturation(
T const s,
detail::tvec4<T, P> const & color);
tvec4<T, P> const & color);
/// Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals.
/// @see gtx_color_space
template <typename T, precision P>
GLM_FUNC_DECL T luminosity(
detail::tvec3<T, P> const & color);
tvec3<T, P> const & color);
/// @}
}//namespace glm
#include "color_space.inl"
#endif//GLM_GTX_color_space
common/glm/glm/gtx/color_space.inl
+45 -22
View File
@@ -1,23 +1,46 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2005-12-21
// Updated : 2007-02-22
// Licence : This source is under MIT License
// File : glm/gtx/color_space.inl
/////////////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_space
/// @file glm/gtx/color_space.inl
/// @date 2005-12-21 / 2011-06-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> rgbColor(const detail::tvec3<T, P>& hsvColor)
GLM_FUNC_QUALIFIER tvec3<T, P> rgbColor(const tvec3<T, P>& hsvColor)
{
detail::tvec3<T, P> hsv = hsvColor;
detail::tvec3<T, P> rgbColor;
tvec3<T, P> hsv = hsvColor;
tvec3<T, P> rgbColor;
if(hsv.y == static_cast<T>(0))
// achromatic (grey)
rgbColor = detail::tvec3<T, P>(hsv.z);
rgbColor = tvec3<T, P>(hsv.z);
else
{
T sector = floor(hsv.x / T(60));
@@ -67,9 +90,9 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> hsvColor(const detail::tvec3<T, P>& rgbColor)
GLM_FUNC_QUALIFIER tvec3<T, P> hsvColor(const tvec3<T, P>& rgbColor)
{
detail::tvec3<T, P> hsv = rgbColor;
tvec3<T, P> hsv = rgbColor;
float Min = min(min(rgbColor.r, rgbColor.g), rgbColor.b);
float Max = max(max(rgbColor.r, rgbColor.g), rgbColor.b);
float Delta = Max - Min;
@@ -106,16 +129,16 @@ namespace glm
return hsv;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> saturation(const T s)
template <typename T>
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> saturation(T const s)
{
detail::tvec3<T, P> rgbw = detail::tvec3<T, P>(T(0.2126), T(0.7152), T(0.0722));
tvec3<T, defaultp> rgbw = tvec3<T, defaultp>(T(0.2126), T(0.7152), T(0.0722));
T col0 = (T(1) - s) * rgbw.r;
T col1 = (T(1) - s) * rgbw.g;
T col2 = (T(1) - s) * rgbw.b;
detail::tmat4x4<T, P> result(T(1));
tmat4x4<T, defaultp> result(T(1));
result[0][0] = col0 + s;
result[0][1] = col0;
result[0][2] = col0;
@@ -129,21 +152,21 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> saturation(const T s, const detail::tvec3<T, P>& color)
GLM_FUNC_QUALIFIER tvec3<T, P> saturation(const T s, const tvec3<T, P>& color)
{
return detail::tvec3<T, P>(saturation(s) * detail::tvec4<T, P>(color, T(0)));
return tvec3<T, P>(saturation(s) * tvec4<T, P>(color, T(0)));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> saturation(const T s, const detail::tvec4<T, P>& color)
GLM_FUNC_QUALIFIER tvec4<T, P> saturation(const T s, const tvec4<T, P>& color)
{
return saturation(s) * color;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER T luminosity(const detail::tvec3<T, P>& color)
GLM_FUNC_QUALIFIER T luminosity(const tvec3<T, P>& color)
{
const detail::tvec3<T, P> tmp = detail::tvec3<T, P>(0.33, 0.59, 0.11);
const tvec3<T, P> tmp = tvec3<T, P>(0.33, 0.59, 0.11);
return dot(color, tmp);
}
}//namespace glm
common/glm/glm/gtx/color_space_YCoCg.hpp
+13 -12
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -35,8 +39,7 @@
/// <glm/gtx/color_space_YCoCg.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef glm_gtx_color_space_YCoCg
#define glm_gtx_color_space_YCoCg
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -53,32 +56,30 @@ namespace glm
/// Convert a color from RGB color space to YCoCg color space.
/// @see gtx_color_space_YCoCg
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> rgb2YCoCg(
detail::tvec3<T, P> const & rgbColor);
GLM_FUNC_DECL tvec3<T, P> rgb2YCoCg(
tvec3<T, P> const & rgbColor);
/// Convert a color from YCoCg color space to RGB color space.
/// @see gtx_color_space_YCoCg
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> YCoCg2rgb(
detail::tvec3<T, P> const & YCoCgColor);
GLM_FUNC_DECL tvec3<T, P> YCoCg2rgb(
tvec3<T, P> const & YCoCgColor);
/// Convert a color from RGB color space to YCoCgR color space.
/// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
/// @see gtx_color_space_YCoCg
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> rgb2YCoCgR(
detail::tvec3<T, P> const & rgbColor);
GLM_FUNC_DECL tvec3<T, P> rgb2YCoCgR(
tvec3<T, P> const & rgbColor);
/// Convert a color from YCoCgR color space to RGB color space.
/// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
/// @see gtx_color_space_YCoCg
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> YCoCgR2rgb(
detail::tvec3<T, P> const & YCoCgColor);
GLM_FUNC_DECL tvec3<T, P> YCoCgR2rgb(
tvec3<T, P> const & YCoCgColor);
/// @}
}//namespace glm
#include "color_space_YCoCg.inl"
#endif//glm_gtx_color_space_YCoCg
common/glm/glm/gtx/color_space_YCoCg.inl
+42 -19
View File
@@ -1,21 +1,44 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2008-10-28
// Updated : 2008-10-28
// Licence : This source is under MIT License
// File : glm/gtx/color_space_YCoCg.inl
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_space_YCoCg
/// @file glm/gtx/color_space_YCoCg.inl
/// @date 2008-10-28 / 2011-06-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> rgb2YCoCg
GLM_FUNC_QUALIFIER tvec3<T, P> rgb2YCoCg
(
detail::tvec3<T, P> const & rgbColor
tvec3<T, P> const & rgbColor
)
{
detail::tvec3<T, P> result;
tvec3<T, P> result;
result.x/*Y */ = rgbColor.r / T(4) + rgbColor.g / T(2) + rgbColor.b / T(4);
result.y/*Co*/ = rgbColor.r / T(2) + rgbColor.g * T(0) - rgbColor.b / T(2);
result.z/*Cg*/ = - rgbColor.r / T(4) + rgbColor.g / T(2) - rgbColor.b / T(4);
@@ -23,12 +46,12 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> rgb2YCoCgR
GLM_FUNC_QUALIFIER tvec3<T, P> rgb2YCoCgR
(
detail::tvec3<T, P> const & rgbColor
tvec3<T, P> const & rgbColor
)
{
detail::tvec3<T, P> result;
tvec3<T, P> result;
result.x/*Y */ = rgbColor.g / T(2) + (rgbColor.r + rgbColor.b) / T(4);
result.y/*Co*/ = rgbColor.r - rgbColor.b;
result.z/*Cg*/ = rgbColor.g - (rgbColor.r + rgbColor.b) / T(2);
@@ -36,12 +59,12 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> YCoCg2rgb
GLM_FUNC_QUALIFIER tvec3<T, P> YCoCg2rgb
(
detail::tvec3<T, P> const & YCoCgColor
tvec3<T, P> const & YCoCgColor
)
{
detail::tvec3<T, P> result;
tvec3<T, P> result;
result.r = YCoCgColor.x + YCoCgColor.y - YCoCgColor.z;
result.g = YCoCgColor.x + YCoCgColor.z;
result.b = YCoCgColor.x - YCoCgColor.y - YCoCgColor.z;
@@ -49,12 +72,12 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> YCoCgR2rgb
GLM_FUNC_QUALIFIER tvec3<T, P> YCoCgR2rgb
(
detail::tvec3<T, P> const & YCoCgRColor
tvec3<T, P> const & YCoCgRColor
)
{
detail::tvec3<T, P> result;
tvec3<T, P> result;
T tmp = YCoCgRColor.x - (YCoCgRColor.z / T(2));
result.g = YCoCgRColor.z + tmp;
result.b = tmp - (YCoCgRColor.y / T(2));
common/glm/glm/gtx/common.hpp
+74
View File
@@ -0,0 +1,74 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_common
/// @file glm/gtx/common.hpp
/// @date 2014-09-08 / 2014-09-08
/// @author Christophe Riccio
///
/// @see core (dependence)
/// @see gtc_half_float (dependence)
///
/// @defgroup gtx_common GLM_GTX_common
/// @ingroup gtx
///
/// @brief Provide functions to increase the compatibility with Cg and HLSL languages
///
/// <glm/gtx/common.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#pragma once
// Dependencies:
#include "../vec2.hpp"
#include "../vec3.hpp"
#include "../vec4.hpp"
#include "../gtc/vec1.hpp"
#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
# pragma message("GLM: GLM_GTX_common extension included")
#endif
namespace glm
{
/// @addtogroup gtx_common
/// @{
/// Returns true if x is a denormalized number
/// Numbers whose absolute value is too small to be represented in the normal format are represented in an alternate, denormalized format.
/// This format is less precise but can represent values closer to zero.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isnan.xml">GLSL isnan man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template <typename genType>
GLM_FUNC_DECL typename genType::bool_type isdenormal(genType const & x);
/// @}
}//namespace glm
#include "common.inl"
common/glm/glm/gtx/common.inl
+102
View File
@@ -0,0 +1,102 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_common
/// @file glm/gtx/common.inl
/// @date 2014-09-08 / 2014-09-08
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#include <cmath>
namespace glm
{
template <typename T>
GLM_FUNC_QUALIFIER bool isdenormal(T const & x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
# if GLM_HAS_CXX11_STL
return std::fpclassify(x) == FP_SUBNORMAL;
# else
return x != static_cast<T>(0) && std::fabs(x) < std::numeric_limits<T>::min();
# endif
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename tvec1<T, P>::bool_type isdenormal
(
tvec1<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
return typename tvec1<T, P>::bool_type(
isdenormal(x.x));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type isdenormal
(
tvec2<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
return typename tvec2<T, P>::bool_type(
isdenormal(x.x),
isdenormal(x.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type isdenormal
(
tvec3<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
return typename tvec3<T, P>::bool_type(
isdenormal(x.x),
isdenormal(x.y),
isdenormal(x.z));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type isdenormal
(
tvec4<T, P> const & x
)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isdenormal' only accept floating-point inputs");
return typename tvec4<T, P>::bool_type(
isdenormal(x.x),
isdenormal(x.y),
isdenormal(x.z),
isdenormal(x.w));
}
}//namespace glm
common/glm/glm/gtx/compatibility.hpp
+69 -71
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -36,11 +40,10 @@
/// <glm/gtx/compatibility.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_compatibility
#define GLM_GTX_compatibility
#pragma once
// Dependency:
#include "../glm.hpp"
#include "../glm.hpp"
#include "../gtc/quaternion.hpp"
#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
@@ -62,99 +65,94 @@ namespace glm
/// @{
template <typename T> GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec2<T, P> lerp(const detail::tvec2<T, P>& x, const detail::tvec2<T, P>& y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec2<T, P> lerp(const tvec2<T, P>& x, const tvec2<T, P>& y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec3<T, P> lerp(const detail::tvec3<T, P>& x, const detail::tvec3<T, P>& y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec4<T, P> lerp(const detail::tvec4<T, P>& x, const detail::tvec4<T, P>& y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec2<T, P> lerp(const detail::tvec2<T, P>& x, const detail::tvec2<T, P>& y, const detail::tvec2<T, P>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec3<T, P> lerp(const detail::tvec3<T, P>& x, const detail::tvec3<T, P>& y, const detail::tvec3<T, P>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec4<T, P> lerp(const detail::tvec4<T, P>& x, const detail::tvec4<T, P>& y, const detail::tvec4<T, P>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER T slerp(detail::tquat<T, P> const & x, detail::tquat<T, P> const & y, T const & a){return mix(x, y, a);} //!< \brief Returns the slurp interpolation between two quaternions.
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec3<T, P> lerp(const tvec3<T, P>& x, const tvec3<T, P>& y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec4<T, P> lerp(const tvec4<T, P>& x, const tvec4<T, P>& y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec2<T, P> lerp(const tvec2<T, P>& x, const tvec2<T, P>& y, const tvec2<T, P>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec3<T, P> lerp(const tvec3<T, P>& x, const tvec3<T, P>& y, const tvec3<T, P>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec4<T, P> lerp(const tvec4<T, P>& x, const tvec4<T, P>& y, const tvec4<T, P>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec2<T, P> saturate(const detail::tvec2<T, P>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec3<T, P> saturate(const detail::tvec3<T, P>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec4<T, P> saturate(const detail::tvec4<T, P>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec2<T, P> saturate(const tvec2<T, P>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec3<T, P> saturate(const tvec3<T, P>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec4<T, P> saturate(const tvec4<T, P>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec2<T, P> atan2(const detail::tvec2<T, P>& x, const detail::tvec2<T, P>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec3<T, P> atan2(const detail::tvec3<T, P>& x, const detail::tvec3<T, P>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec4<T, P> atan2(const detail::tvec4<T, P>& x, const detail::tvec4<T, P>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec2<T, P> atan2(const tvec2<T, P>& x, const tvec2<T, P>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec3<T, P> atan2(const tvec3<T, P>& x, const tvec3<T, P>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_QUALIFIER tvec4<T, P> atan2(const tvec4<T, P>& x, const tvec4<T, P>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename genType> GLM_FUNC_DECL bool isfinite(genType const & x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_DECL detail::tvec2<bool, P> isfinite(const detail::tvec2<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_DECL detail::tvec3<bool, P> isfinite(const detail::tvec3<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_DECL detail::tvec4<bool, P> isfinite(const detail::tvec4<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_DECL tvec2<bool, P> isfinite(const tvec2<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_DECL tvec3<bool, P> isfinite(const tvec3<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename T, precision P> GLM_FUNC_DECL tvec4<bool, P> isfinite(const tvec4<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
typedef bool bool1; //!< \brief boolean type with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tvec2<bool, highp> bool2; //!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec3<bool, highp> bool3; //!< \brief boolean type with 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec4<bool, highp> bool4; //!< \brief boolean type with 4 components. (From GLM_GTX_compatibility extension)
typedef tvec2<bool, highp> bool2; //!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension)
typedef tvec3<bool, highp> bool3; //!< \brief boolean type with 3 components. (From GLM_GTX_compatibility extension)
typedef tvec4<bool, highp> bool4; //!< \brief boolean type with 4 components. (From GLM_GTX_compatibility extension)
typedef bool bool1x1; //!< \brief boolean matrix with 1 x 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x2<bool, highp> bool2x2; //!< \brief boolean matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x3<bool, highp> bool2x3; //!< \brief boolean matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x4<bool, highp> bool2x4; //!< \brief boolean matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x2<bool, highp> bool3x2; //!< \brief boolean matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x3<bool, highp> bool3x3; //!< \brief boolean matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x4<bool, highp> bool3x4; //!< \brief boolean matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x2<bool, highp> bool4x2; //!< \brief boolean matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x3<bool, highp> bool4x3; //!< \brief boolean matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x4<bool, highp> bool4x4; //!< \brief boolean matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat2x2<bool, highp> bool2x2; //!< \brief boolean matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat2x3<bool, highp> bool2x3; //!< \brief boolean matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat2x4<bool, highp> bool2x4; //!< \brief boolean matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat3x2<bool, highp> bool3x2; //!< \brief boolean matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat3x3<bool, highp> bool3x3; //!< \brief boolean matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat3x4<bool, highp> bool3x4; //!< \brief boolean matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat4x2<bool, highp> bool4x2; //!< \brief boolean matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat4x3<bool, highp> bool4x3; //!< \brief boolean matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat4x4<bool, highp> bool4x4; //!< \brief boolean matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
typedef int int1; //!< \brief integer vector with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tvec2<int, highp> int2; //!< \brief integer vector with 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec3<int, highp> int3; //!< \brief integer vector with 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec4<int, highp> int4; //!< \brief integer vector with 4 components. (From GLM_GTX_compatibility extension)
typedef tvec2<int, highp> int2; //!< \brief integer vector with 2 components. (From GLM_GTX_compatibility extension)
typedef tvec3<int, highp> int3; //!< \brief integer vector with 3 components. (From GLM_GTX_compatibility extension)
typedef tvec4<int, highp> int4; //!< \brief integer vector with 4 components. (From GLM_GTX_compatibility extension)
typedef int int1x1; //!< \brief integer matrix with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x2<int, highp> int2x2; //!< \brief integer matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x3<int, highp> int2x3; //!< \brief integer matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x4<int, highp> int2x4; //!< \brief integer matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x2<int, highp> int3x2; //!< \brief integer matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x3<int, highp> int3x3; //!< \brief integer matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x4<int, highp> int3x4; //!< \brief integer matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x2<int, highp> int4x2; //!< \brief integer matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x3<int, highp> int4x3; //!< \brief integer matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x4<int, highp> int4x4; //!< \brief integer matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat2x2<int, highp> int2x2; //!< \brief integer matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat2x3<int, highp> int2x3; //!< \brief integer matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat2x4<int, highp> int2x4; //!< \brief integer matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat3x2<int, highp> int3x2; //!< \brief integer matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat3x3<int, highp> int3x3; //!< \brief integer matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat3x4<int, highp> int3x4; //!< \brief integer matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat4x2<int, highp> int4x2; //!< \brief integer matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat4x3<int, highp> int4x3; //!< \brief integer matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat4x4<int, highp> int4x4; //!< \brief integer matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
typedef float float1; //!< \brief single-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tvec2<float, highp> float2; //!< \brief single-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec3<float, highp> float3; //!< \brief single-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec4<float, highp> float4; //!< \brief single-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
typedef tvec2<float, highp> float2; //!< \brief single-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
typedef tvec3<float, highp> float3; //!< \brief single-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
typedef tvec4<float, highp> float4; //!< \brief single-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
typedef float float1x1; //!< \brief single-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x2<float, highp> float2x2; //!< \brief single-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x3<float, highp> float2x3; //!< \brief single-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x4<float, highp> float2x4; //!< \brief single-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x2<float, highp> float3x2; //!< \brief single-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x3<float, highp> float3x3; //!< \brief single-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x4<float, highp> float3x4; //!< \brief single-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x2<float, highp> float4x2; //!< \brief single-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x3<float, highp> float4x3; //!< \brief single-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x4<float, highp> float4x4; //!< \brief single-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat2x2<float, highp> float2x2; //!< \brief single-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat2x3<float, highp> float2x3; //!< \brief single-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat2x4<float, highp> float2x4; //!< \brief single-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat3x2<float, highp> float3x2; //!< \brief single-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat3x3<float, highp> float3x3; //!< \brief single-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat3x4<float, highp> float3x4; //!< \brief single-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat4x2<float, highp> float4x2; //!< \brief single-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat4x3<float, highp> float4x3; //!< \brief single-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat4x4<float, highp> float4x4; //!< \brief single-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
typedef double double1; //!< \brief double-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tvec2<double, highp> double2; //!< \brief double-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec3<double, highp> double3; //!< \brief double-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec4<double, highp> double4; //!< \brief double-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
typedef tvec2<double, highp> double2; //!< \brief double-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
typedef tvec3<double, highp> double3; //!< \brief double-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
typedef tvec4<double, highp> double4; //!< \brief double-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
typedef double double1x1; //!< \brief double-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x2<double, highp> double2x2; //!< \brief double-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x3<double, highp> double2x3; //!< \brief double-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x4<double, highp> double2x4; //!< \brief double-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x2<double, highp> double3x2; //!< \brief double-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x3<double, highp> double3x3; //!< \brief double-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x4<double, highp> double3x4; //!< \brief double-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x2<double, highp> double4x2; //!< \brief double-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x3<double, highp> double4x3; //!< \brief double-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x4<double, highp> double4x4; //!< \brief double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat2x2<double, highp> double2x2; //!< \brief double-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat2x3<double, highp> double2x3; //!< \brief double-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat2x4<double, highp> double2x4; //!< \brief double-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat3x2<double, highp> double3x2; //!< \brief double-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat3x3<double, highp> double3x3; //!< \brief double-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat3x4<double, highp> double3x4; //!< \brief double-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef tmat4x2<double, highp> double4x2; //!< \brief double-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef tmat4x3<double, highp> double4x3; //!< \brief double-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef tmat4x4<double, highp> double4x4; //!< \brief double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
/// @}
}//namespace glm
#include "compatibility.inl"
#endif//GLM_GTX_compatibility
common/glm/glm/gtx/compatibility.inl
+45 -20
View File
@@ -1,11 +1,36 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_compatibility
/// @file glm/gtx/compatibility.inl
/// @date 2007-01-24 / 2011-06-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2007-03-16
// Updated : 2008-10-24
// Licence : This source is under MIT License
// File : glm/gtx/compatibility.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
#include <limits>
namespace glm
{
@@ -14,41 +39,41 @@ namespace glm
GLM_FUNC_QUALIFIER bool isfinite(
genType const & x)
{
# if(GLM_LANG & GLM_LANG_CXX11_FLAG)
# if GLM_HAS_CXX11_STL
return std::isfinite(x) != 0;
# elif(GLM_COMPILER & GLM_COMPILER_VC)
# elif GLM_COMPILER & GLM_COMPILER_VC
return _finite(x);
# elif(GLM_COMPILER & GLM_COMPILER_GCC && GLM_PLATFORM & GLM_PLATFORM_ANDROID)
# elif GLM_COMPILER & GLM_COMPILER_GCC && GLM_PLATFORM & GLM_PLATFORM_ANDROID
return _isfinite(x) != 0;
# else
return isfinite(x) != 0;
return x >= std::numeric_limits<genType>::min() && x <= std::numeric_limits<genType>::max();
# endif
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<bool, P> isfinite(
detail::tvec2<T, P> const & x)
GLM_FUNC_QUALIFIER tvec2<bool, P> isfinite(
tvec2<T, P> const & x)
{
return detail::tvec2<bool, P>(
return tvec2<bool, P>(
isfinite(x.x),
isfinite(x.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<bool, P> isfinite(
detail::tvec3<T, P> const & x)
GLM_FUNC_QUALIFIER tvec3<bool, P> isfinite(
tvec3<T, P> const & x)
{
return detail::tvec3<bool, P>(
return tvec3<bool, P>(
isfinite(x.x),
isfinite(x.y),
isfinite(x.z));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<bool, P> isfinite(
detail::tvec4<T, P> const & x)
GLM_FUNC_QUALIFIER tvec4<bool, P> isfinite(
tvec4<T, P> const & x)
{
return detail::tvec4<bool, P>(
return tvec4<bool, P>(
isfinite(x.x),
isfinite(x.y),
isfinite(x.z),
common/glm/glm/gtx/component_wise.hpp
+6 -4
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -35,11 +39,11 @@
/// <glm/gtx/component_wise.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_component_wise
#define GLM_GTX_component_wise
#pragma once
// Dependencies
#include "../detail/setup.hpp"
#include "../detail/precision.hpp"
#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
# pragma message("GLM: GLM_GTX_component_wise extension included")
@@ -78,5 +82,3 @@ namespace glm
}//namespace glm
#include "component_wise.inl"
#endif//GLM_GTX_component_wise
common/glm/glm/gtx/component_wise.inl
+34 -11
View File
@@ -1,10 +1,33 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2007-05-21
// Updated : 2010-02-12
// Licence : This source is under MIT License
// File : gtx_component_wise.inl
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_component_wise
/// @file glm/gtx/component_wise.inl
/// @date 2007-05-21 / 2011-06-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm
@@ -13,7 +36,7 @@ namespace glm
GLM_FUNC_QUALIFIER T compAdd(vecType<T, P> const & v)
{
T result(0);
for(length_t i = 0; i < v.length(); ++i)
for(detail::component_count_t i = 0; i < detail::component_count(v); ++i)
result += v[i];
return result;
}
@@ -22,7 +45,7 @@ namespace glm
GLM_FUNC_QUALIFIER T compMul(vecType<T, P> const & v)
{
T result(1);
for(length_t i = 0; i < v.length(); ++i)
for(detail::component_count_t i = 0; i < detail::component_count(v); ++i)
result *= v[i];
return result;
}
@@ -31,7 +54,7 @@ namespace glm
GLM_FUNC_QUALIFIER T compMin(vecType<T, P> const & v)
{
T result(v[0]);
for(length_t i = 1; i < v.length(); ++i)
for(detail::component_count_t i = 1; i < detail::component_count(v); ++i)
result = min(result, v[i]);
return result;
}
@@ -40,7 +63,7 @@ namespace glm
GLM_FUNC_QUALIFIER T compMax(vecType<T, P> const & v)
{
T result(v[0]);
for(length_t i = 1; i < v.length(); ++i)
for(detail::component_count_t i = 1; i < detail::component_count(v); ++i)
result = max(result, v[i]);
return result;
}
common/glm/glm/gtx/constants.hpp
-33
View File
@@ -1,33 +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.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_constants
#define GLM_GTX_constants
#include "../gtc/constants.hpp"
#if(defined(GLM_MESSAGES))
# pragma message("GLM: GLM_GTX_constants extension is deprecated, include GLM_GTC_constants (glm/gtc/constants.hpp) instead")
#endif
#endif//GLM_GTX_constants
common/glm/glm/gtx/dual_quaternion.hpp
+123 -104
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -30,16 +34,15 @@
/// @see gtc_constants (dependence)
/// @see gtc_quaternion (dependence)
///
/// @defgroup gtc_dual_quaternion GLM_GTX_dual_quaternion
/// @ingroup gtc
/// @defgroup gtx_dual_quaternion GLM_GTX_dual_quaternion
/// @ingroup gtx
///
/// @brief Defines a templated dual-quaternion type and several dual-quaternion operations.
///
/// <glm/gtx/dual_quaternion.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_dual_quaternion
#define GLM_GTX_dual_quaternion
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -50,213 +53,231 @@
# pragma message("GLM: GLM_GTX_dual_quaternion extension included")
#endif
namespace glm{
namespace detail
namespace glm
{
/// @addtogroup gtx_dual_quaternion
/// @{
template <typename T, precision P>
struct tdualquat
{
enum ctor{null};
typedef glm::detail::tquat<T, P> part_type;
typedef T value_type;
typedef glm::tquat<T, P> part_type;
public:
glm::detail::tquat<T, P> real, dual;
glm::tquat<T, P> real, dual;
GLM_FUNC_DECL GLM_CONSTEXPR int length() const;
// Constructors
//////////////////////////////////////
// Component accesses
# ifdef GLM_FORCE_SIZE_FUNC
typedef size_t size_type;
/// Return the count of components of a dual quaternion
GLM_FUNC_DECL GLM_CONSTEXPR size_type size() const;
GLM_FUNC_DECL part_type & operator[](size_type i);
GLM_FUNC_DECL part_type const & operator[](size_type i) const;
# else
typedef length_t length_type;
/// Return the count of components of a dual quaternion
GLM_FUNC_DECL GLM_CONSTEXPR length_type length() const;
GLM_FUNC_DECL part_type & operator[](length_type i);
GLM_FUNC_DECL part_type const & operator[](length_type i) const;
# endif//GLM_FORCE_SIZE_FUNC
//////////////////////////////////////
// Implicit basic constructors
GLM_FUNC_DECL tdualquat();
template <precision Q>
GLM_FUNC_DECL tdualquat(tdualquat<T, Q> const & d);
//////////////////////////////////////
// Explicit basic constructors
GLM_FUNC_DECL explicit tdualquat(ctor);
GLM_FUNC_DECL explicit tdualquat(tquat<T, P> const & real);
GLM_FUNC_DECL tdualquat(tquat<T, P> const & real,tquat<T, P> const & dual);
GLM_FUNC_DECL tdualquat(tquat<T, P> const & orientation,tvec3<T, P> const& translation);
GLM_FUNC_DECL tdualquat(tquat<T, P> const & orientation, tvec3<T, P> const & translation);
GLM_FUNC_DECL tdualquat(tquat<T, P> const & real, tquat<T, P> const & dual);
//////////////////////////////////////////////////////////////
// tdualquat conversions
# ifdef GLM_FORCE_EXPLICIT_CTOR
template <typename U, precision Q>
GLM_FUNC_DECL explicit tdualquat(tdualquat<U, Q> const & q);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tdualquat(tdualquat<U, Q> const & q);
# endif
GLM_FUNC_DECL explicit tdualquat(tmat2x4<T, P> const & holder_mat);
GLM_FUNC_DECL explicit tdualquat(tmat3x4<T, P> const & aug_mat);
// Accesses
GLM_FUNC_DECL part_type & operator[](int i);
GLM_FUNC_DECL part_type const & operator[](int i) const;
// Operators
GLM_FUNC_DECL tdualquat<T, P> & operator*=(T const & s);
GLM_FUNC_DECL tdualquat<T, P> & operator/=(T const & s);
};
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> operator- (
detail::tquat<T, P> const & q);
GLM_FUNC_DECL tquat<T, P> operator- (
tquat<T, P> const & q);
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> operator+ (
detail::tdualquat<T, P> const & q,
detail::tdualquat<T, P> const & p);
GLM_FUNC_DECL tdualquat<T, P> operator+ (
tdualquat<T, P> const & q,
tdualquat<T, P> const & p);
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> operator* (
detail::tdualquat<T, P> const & q,
detail::tdualquat<T, P> const & p);
GLM_FUNC_DECL tdualquat<T, P> operator* (
tdualquat<T, P> const & q,
tdualquat<T, P> const & p);
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> operator* (
detail::tquat<T, P> const & q,
detail::tvec3<T, P> const & v);
GLM_FUNC_DECL tvec3<T, P> operator* (
tquat<T, P> const & q,
tvec3<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> operator* (
detail::tvec3<T, P> const & v,
detail::tquat<T, P> const & q);
GLM_FUNC_DECL tvec3<T, P> operator* (
tvec3<T, P> const & v,
tquat<T, P> const & q);
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<T, P> operator* (
detail::tquat<T, P> const & q,
detail::tvec4<T, P> const & v);
GLM_FUNC_DECL tvec4<T, P> operator* (
tquat<T, P> const & q,
tvec4<T, P> const & v);
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<T, P> operator* (
detail::tvec4<T, P> const & v,
detail::tquat<T, P> const & q);
GLM_FUNC_DECL tvec4<T, P> operator* (
tvec4<T, P> const & v,
tquat<T, P> const & q);
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> operator* (
detail::tdualquat<T, P> const & q,
GLM_FUNC_DECL tdualquat<T, P> operator* (
tdualquat<T, P> const & q,
T const & s);
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> operator* (
GLM_FUNC_DECL tdualquat<T, P> operator* (
T const & s,
detail::tdualquat<T, P> const & q);
tdualquat<T, P> const & q);
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> operator/ (
detail::tdualquat<T, P> const & q,
GLM_FUNC_DECL tdualquat<T, P> operator/ (
tdualquat<T, P> const & q,
T const & s);
} //namespace detail
/// @addtogroup gtc_dual_quaternion
/// @{
/// Returns the normalized quaternion.
///
/// @see gtc_dual_quaternion
/// @see gtx_dual_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> normalize(
detail::tdualquat<T, P> const & q);
GLM_FUNC_DECL tdualquat<T, P> normalize(
tdualquat<T, P> const & q);
/// Returns the linear interpolation of two dual quaternion.
///
/// @see gtc_dual_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> lerp(
detail::tdualquat<T, P> const & x,
detail::tdualquat<T, P> const & y,
GLM_FUNC_DECL tdualquat<T, P> lerp(
tdualquat<T, P> const & x,
tdualquat<T, P> const & y,
T const & a);
/// Returns the q inverse.
///
/// @see gtc_dual_quaternion
/// @see gtx_dual_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> inverse(
detail::tdualquat<T, P> const & q);
GLM_FUNC_DECL tdualquat<T, P> inverse(
tdualquat<T, P> const & q);
/*
/// Extracts a rotation part from dual-quaternion to a 3 * 3 matrix.
/// TODO
///
/// @see gtc_dual_quaternion
template <typename T, precision P>
detail::tmat3x3<T, P> mat3_cast(
detail::tdualquat<T, P> const & x);
*/
/// Converts a quaternion to a 2 * 4 matrix.
///
/// @see gtc_dual_quaternion
/// @see gtx_dual_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat2x4<T, P> mat2x4_cast(
detail::tdualquat<T, P> const & x);
GLM_FUNC_DECL tmat2x4<T, P> mat2x4_cast(
tdualquat<T, P> const & x);
/// Converts a quaternion to a 3 * 4 matrix.
///
/// @see gtc_dual_quaternion
/// @see gtx_dual_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x4<T, P> mat3x4_cast(
detail::tdualquat<T, P> const & x);
GLM_FUNC_DECL tmat3x4<T, P> mat3x4_cast(
tdualquat<T, P> const & x);
/// Converts a 2 * 4 matrix (matrix which holds real and dual parts) to a quaternion.
///
/// @see gtc_dual_quaternion
/// @see gtx_dual_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> dualquat_cast(
detail::tmat2x4<T, P> const & x);
GLM_FUNC_DECL tdualquat<T, P> dualquat_cast(
tmat2x4<T, P> const & x);
/// Converts a 3 * 4 matrix (augmented matrix rotation + translation) to a quaternion.
///
/// @see gtc_dual_quaternion
/// @see gtx_dual_quaternion
template <typename T, precision P>
GLM_FUNC_DECL detail::tdualquat<T, P> dualquat_cast(
detail::tmat3x4<T, P> const & x);
GLM_FUNC_DECL tdualquat<T, P> dualquat_cast(
tmat3x4<T, P> const & x);
/// Dual-quaternion of low single-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<float, lowp> lowp_dualquat;
/// @see gtx_dual_quaternion
typedef tdualquat<float, lowp> lowp_dualquat;
/// Dual-quaternion of medium single-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<float, mediump> mediump_dualquat;
/// @see gtx_dual_quaternion
typedef tdualquat<float, mediump> mediump_dualquat;
/// Dual-quaternion of high single-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<float, highp> highp_dualquat;
/// @see gtx_dual_quaternion
typedef tdualquat<float, highp> highp_dualquat;
/// Dual-quaternion of low single-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<float, lowp> lowp_fdualquat;
/// @see gtx_dual_quaternion
typedef tdualquat<float, lowp> lowp_fdualquat;
/// Dual-quaternion of medium single-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<float, mediump> mediump_fdualquat;
/// @see gtx_dual_quaternion
typedef tdualquat<float, mediump> mediump_fdualquat;
/// Dual-quaternion of high single-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<float, highp> highp_fdualquat;
/// @see gtx_dual_quaternion
typedef tdualquat<float, highp> highp_fdualquat;
/// Dual-quaternion of low double-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<double, lowp> lowp_ddualquat;
/// @see gtx_dual_quaternion
typedef tdualquat<double, lowp> lowp_ddualquat;
/// Dual-quaternion of medium double-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<double, mediump> mediump_ddualquat;
/// @see gtx_dual_quaternion
typedef tdualquat<double, mediump> mediump_ddualquat;
/// Dual-quaternion of high double-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<double, highp> highp_ddualquat;
/// @see gtx_dual_quaternion
typedef tdualquat<double, highp> highp_ddualquat;
#if(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
/// Dual-quaternion of floating-point numbers.
///
/// @see gtc_dual_quaternion
/// @see gtx_dual_quaternion
typedef highp_fdualquat dualquat;
/// Dual-quaternion of single-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
/// @see gtx_dual_quaternion
typedef highp_fdualquat fdualquat;
#elif(defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
typedef highp_fdualquat dualquat;
@@ -275,7 +296,7 @@ namespace detail
#if(!defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE))
/// Dual-quaternion of default double-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
/// @see gtx_dual_quaternion
typedef highp_ddualquat ddualquat;
#elif(defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE))
typedef highp_ddualquat ddualquat;
@@ -291,5 +312,3 @@ namespace detail
} //namespace glm
#include "dual_quaternion.inl"
#endif//GLM_GTX_dual_quaternion
common/glm/glm/gtx/dual_quaternion.inl
+139 -185
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -29,99 +33,124 @@
#include "../geometric.hpp"
#include <limits>
namespace glm{
namespace detail
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR int tdualquat<T, P>::length() const
{
return 8;
}
//////////////////////////////////////
// Component accesses
# ifdef GLM_FORCE_SIZE_FUNC
template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tdualquat<T, P>::size_type tdualquat<T, P>::size() const
{
return 2;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename tdualquat<T, P>::part_type & tdualquat<T, P>::operator[](typename tdualquat<T, P>::size_type i)
{
assert(i >= 0 && static_cast<detail::component_count_t>(i) < detail::component_count(*this));
return (&real)[i];
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename tdualquat<T, P>::part_type const & tdualquat<T, P>::operator[](typename tdualquat<T, P>::size_type i) const
{
assert(i >= 0 && static_cast<detail::component_count_t>(i) < detail::component_count(*this));
return (&real)[i];
}
# else
template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tdualquat<T, P>::length_type tdualquat<T, P>::length() const
{
return 2;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename tdualquat<T, P>::part_type & tdualquat<T, P>::operator[](typename tdualquat<T, P>::length_type i)
{
assert(i >= 0 && static_cast<detail::component_count_t>(i) < detail::component_count(*this));
return (&real)[i];
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename tdualquat<T, P>::part_type const & tdualquat<T, P>::operator[](typename tdualquat<T, P>::length_type i) const
{
assert(i >= 0 && static_cast<detail::component_count_t>(i) < detail::component_count(*this));
return (&real)[i];
}
# endif//GLM_FORCE_SIZE_FUNC
//////////////////////////////////////
// Implicit basic constructors
template <typename T, precision P>
GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat() :
real(tquat<T, P>()),
dual(tquat<T, P>(T(0), T(0), T(0), T(0)))
GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat()
# ifndef GLM_FORCE_NO_CTOR_INIT
: real(tquat<T, P>())
, dual(tquat<T, P>(0, 0, 0, 0))
# endif
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat
(
tquat<T, P> const & r
) :
real(r),
dual(tquat<T, P>(T(0), T(0), T(0), T(0)))
template <precision Q>
GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tdualquat<T, Q> const & d)
: real(d.real)
, dual(d.dual)
{}
//////////////////////////////////////
// Explicit basic constructors
template <typename T, precision P>
GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(ctor)
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat
(
tquat<T, P> const & r,
tquat<T, P> const & d
) :
real(r),
dual(d)
GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tquat<T, P> const & r)
: real(r), dual(tquat<T, P>(0, 0, 0, 0))
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat
(
tquat<T, P> const & q,
tvec3<T, P> const& p
) :
real(q),
dual(
GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tquat<T, P> const & q, tvec3<T, P> const& p)
: real(q), dual(
T(-0.5) * ( p.x*q.x + p.y*q.y + p.z*q.z),
T(+0.5) * ( p.x*q.w + p.y*q.z - p.z*q.y),
T(+0.5) * (-p.x*q.z + p.y*q.w + p.z*q.x),
T(+0.5) * ( p.x*q.y - p.y*q.x + p.z*q.w))
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tquat<T, P> const & r, tquat<T, P> const & d)
: real(r), dual(d)
{}
//////////////////////////////////////////////////////////////
// tdualquat conversions
template <typename T, precision P>
GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat
(
tmat2x4<T, P> const & m
)
template <typename U, precision Q>
GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tdualquat<U, Q> const & q)
: real(q.real)
, dual(q.dual)
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tmat2x4<T, P> const & m)
{
*this = dualquat_cast(m);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat
(
tmat3x4<T, P> const & m
)
GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tmat3x4<T, P> const & m)
{
*this = dualquat_cast(m);
}
//////////////////////////////////////////////////////////////
// tdualquat<T, P> accesses
// tdualquat operators
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename tdualquat<T, P>::part_type & tdualquat<T, P>::operator [] (int i)
{
assert(i >= 0 && i < this->length());
return (&real)[i];
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER typename tdualquat<T, P>::part_type const & tdualquat<T, P>::operator [] (int i) const
{
assert(i >= 0 && i < this->length());
return (&real)[i];
}
//////////////////////////////////////////////////////////////
// tdualquat<valType> operators
template <typename T, precision P>
GLM_FUNC_QUALIFIER tdualquat<T, P> & tdualquat<T, P>::operator *=
(
T const & s
)
GLM_FUNC_QUALIFIER tdualquat<T, P> & tdualquat<T, P>::operator*=(T const & s)
{
this->real *= s;
this->dual *= s;
@@ -129,10 +158,7 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tdualquat<T, P> & tdualquat<T, P>::operator /=
(
T const & s
)
GLM_FUNC_QUALIFIER tdualquat<T, P> & tdualquat<T, P>::operator/=(T const & s)
{
this->real /= s;
this->dual /= s;
@@ -143,147 +169,91 @@ namespace detail
// tquat<valType> external operators
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tdualquat<T, P> operator-
(
detail::tdualquat<T, P> const & q
)
GLM_FUNC_QUALIFIER tdualquat<T, P> operator-(tdualquat<T, P> const & q)
{
return detail::tdualquat<T, P>(-q.real,-q.dual);
return tdualquat<T, P>(-q.real,-q.dual);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tdualquat<T, P> operator+
(
detail::tdualquat<T, P> const & q,
detail::tdualquat<T, P> const & p
)
GLM_FUNC_QUALIFIER tdualquat<T, P> operator+(tdualquat<T, P> const & q, tdualquat<T, P> const & p)
{
return detail::tdualquat<T, P>(q.real + p.real,q.dual + p.dual);
return tdualquat<T, P>(q.real + p.real,q.dual + p.dual);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tdualquat<T, P> operator*
(
detail::tdualquat<T, P> const & p,
detail::tdualquat<T, P> const & o
)
GLM_FUNC_QUALIFIER tdualquat<T, P> operator*(tdualquat<T, P> const & p, tdualquat<T, P> const & o)
{
return detail::tdualquat<T, P>(p.real * o.real,p.real * o.dual + p.dual * o.real);
return tdualquat<T, P>(p.real * o.real,p.real * o.dual + p.dual * o.real);
}
// Transformation
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> operator*
(
detail::tdualquat<T, P> const & q,
detail::tvec3<T, P> const & v
)
GLM_FUNC_QUALIFIER tvec3<T, P> operator*(tdualquat<T, P> const & q, tvec3<T, P> const & v)
{
detail::tvec3<T, P> const real_v3(q.real.x,q.real.y,q.real.z);
detail::tvec3<T, P> const dual_v3(q.dual.x,q.dual.y,q.dual.z);
tvec3<T, P> const real_v3(q.real.x,q.real.y,q.real.z);
tvec3<T, P> const dual_v3(q.dual.x,q.dual.y,q.dual.z);
return (cross(real_v3, cross(real_v3,v) + v * q.real.w + dual_v3) + dual_v3 * q.real.w - real_v3 * q.dual.w) * T(2) + v;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> operator*
(
detail::tvec3<T, P> const & v,
detail::tdualquat<T, P> const & q
)
GLM_FUNC_QUALIFIER tvec3<T, P> operator*(tvec3<T, P> const & v, tdualquat<T, P> const & q)
{
return glm::inverse(q) * v;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> operator*
(
detail::tdualquat<T, P> const & q,
detail::tvec4<T, P> const & v
)
GLM_FUNC_QUALIFIER tvec4<T, P> operator*(tdualquat<T, P> const & q, tvec4<T, P> const & v)
{
return detail::tvec4<T, P>(q * detail::tvec3<T, P>(v), v.w);
return tvec4<T, P>(q * tvec3<T, P>(v), v.w);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> operator*
(
detail::tvec4<T, P> const & v,
detail::tdualquat<T, P> const & q
)
GLM_FUNC_QUALIFIER tvec4<T, P> operator*(tvec4<T, P> const & v, tdualquat<T, P> const & q)
{
return glm::inverse(q) * v;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tdualquat<T, P> operator*
(
detail::tdualquat<T, P> const & q,
T const & s
)
GLM_FUNC_QUALIFIER tdualquat<T, P> operator*(tdualquat<T, P> const & q, T const & s)
{
return detail::tdualquat<T, P>(q.real * s, q.dual * s);
return tdualquat<T, P>(q.real * s, q.dual * s);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tdualquat<T, P> operator*
(
T const & s,
detail::tdualquat<T, P> const & q
)
GLM_FUNC_QUALIFIER tdualquat<T, P> operator*(T const & s, tdualquat<T, P> const & q)
{
return q * s;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tdualquat<T, P> operator/
(
detail::tdualquat<T, P> const & q,
T const & s
)
GLM_FUNC_QUALIFIER tdualquat<T, P> operator/(tdualquat<T, P> const & q, T const & s)
{
return detail::tdualquat<T, P>(q.real / s, q.dual / s);
return tdualquat<T, P>(q.real / s, q.dual / s);
}
//////////////////////////////////////
// Boolean operators
template <typename T, precision P>
GLM_FUNC_QUALIFIER bool operator==
(
detail::tdualquat<T, P> const & q1,
detail::tdualquat<T, P> const & q2
)
GLM_FUNC_QUALIFIER bool operator==(tdualquat<T, P> const & q1, tdualquat<T, P> const & q2)
{
return (q1.real == q2.real) && (q1.dual == q2.dual);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER bool operator!=
(
detail::tdualquat<T, P> const & q1,
detail::tdualquat<T, P> const & q2
)
GLM_FUNC_QUALIFIER bool operator!=(tdualquat<T, P> const & q1, tdualquat<T, P> const & q2)
{
return (q1.real != q2.dual) || (q1.real != q2.dual);
}
}//namespace detail
////////////////////////////////////////////////////////
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tdualquat<T, P> normalize
(
detail::tdualquat<T, P> const & q
)
GLM_FUNC_QUALIFIER tdualquat<T, P> normalize(tdualquat<T, P> const & q)
{
return q / length(q.real);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tdualquat<T, P> lerp
(
detail::tdualquat<T, P> const & x,
detail::tdualquat<T, P> const & y,
T const & a
)
GLM_FUNC_QUALIFIER tdualquat<T, P> lerp(tdualquat<T, P> const & x, tdualquat<T, P> const & y, T const & a)
{
// Dual Quaternion Linear blend aka DLB:
// Lerp is only defined in [0, 1]
@@ -291,38 +261,29 @@ namespace detail
assert(a <= static_cast<T>(1));
T const k = dot(x.real,y.real) < static_cast<T>(0) ? -a : a;
T const one(1);
return detail::tdualquat<T, P>(x * (one - a) + y * k);
return tdualquat<T, P>(x * (one - a) + y * k);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tdualquat<T, P> inverse
(
detail::tdualquat<T, P> const & q
)
GLM_FUNC_QUALIFIER tdualquat<T, P> inverse(tdualquat<T, P> const & q)
{
const glm::detail::tquat<T, P> real = conjugate(q.real);
const glm::detail::tquat<T, P> dual = conjugate(q.dual);
return detail::tdualquat<T, P>(real, dual + (real * (-2.0f * dot(real,dual))));
const glm::tquat<T, P> real = conjugate(q.real);
const glm::tquat<T, P> dual = conjugate(q.dual);
return tdualquat<T, P>(real, dual + (real * (-2.0f * dot(real,dual))));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat2x4<T, P> mat2x4_cast
(
detail::tdualquat<T, P> const & x
)
GLM_FUNC_QUALIFIER tmat2x4<T, P> mat2x4_cast(tdualquat<T, P> const & x)
{
return detail::tmat2x4<T, P>( x[0].x, x[0].y, x[0].z, x[0].w, x[1].x, x[1].y, x[1].z, x[1].w );
return tmat2x4<T, P>( x[0].x, x[0].y, x[0].z, x[0].w, x[1].x, x[1].y, x[1].z, x[1].w );
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x4<T, P> mat3x4_cast
(
detail::tdualquat<T, P> const & x
)
GLM_FUNC_QUALIFIER tmat3x4<T, P> mat3x4_cast(tdualquat<T, P> const & x)
{
detail::tquat<T, P> r = x.real / length2(x.real);
tquat<T, P> r = x.real / length2(x.real);
detail::tquat<T, P> const rr(r.w * x.real.w, r.x * x.real.x, r.y * x.real.y, r.z * x.real.z);
tquat<T, P> const rr(r.w * x.real.w, r.x * x.real.x, r.y * x.real.y, r.z * x.real.z);
r *= static_cast<T>(2);
T const xy = r.x * x.real.y;
@@ -332,48 +293,42 @@ namespace detail
T const wy = r.w * x.real.y;
T const wz = r.w * x.real.z;
detail::tvec4<T, P> const a(
tvec4<T, P> const a(
rr.w + rr.x - rr.y - rr.z,
xy - wz,
xz + wy,
-(x.dual.w * r.x - x.dual.x * r.w + x.dual.y * r.z - x.dual.z * r.y));
detail::tvec4<T, P> const b(
tvec4<T, P> const b(
xy + wz,
rr.w + rr.y - rr.x - rr.z,
yz - wx,
-(x.dual.w * r.y - x.dual.x * r.z - x.dual.y * r.w + x.dual.z * r.x));
detail::tvec4<T, P> const c(
tvec4<T, P> const c(
xz - wy,
yz + wx,
rr.w + rr.z - rr.x - rr.y,
-(x.dual.w * r.z + x.dual.x * r.y - x.dual.y * r.x - x.dual.z * r.w));
return detail::tmat3x4<T, P>(a, b, c);
return tmat3x4<T, P>(a, b, c);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tdualquat<T, P> dualquat_cast
(
detail::tmat2x4<T, P> const & x
)
GLM_FUNC_QUALIFIER tdualquat<T, P> dualquat_cast(tmat2x4<T, P> const & x)
{
return detail::tdualquat<T, P>(
detail::tquat<T, P>( x[0].w, x[0].x, x[0].y, x[0].z ),
detail::tquat<T, P>( x[1].w, x[1].x, x[1].y, x[1].z ));
return tdualquat<T, P>(
tquat<T, P>( x[0].w, x[0].x, x[0].y, x[0].z ),
tquat<T, P>( x[1].w, x[1].x, x[1].y, x[1].z ));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tdualquat<T, P> dualquat_cast
(
detail::tmat3x4<T, P> const & x
)
GLM_FUNC_QUALIFIER tdualquat<T, P> dualquat_cast(tmat3x4<T, P> const & x)
{
detail::tquat<T, P> real;
tquat<T, P> real(uninitialize);
T const trace = x[0].x + x[1].y + x[2].z;
if(trace > T(0))
if(trace > static_cast<T>(0))
{
T const r = sqrt(T(1) + trace);
T const invr = static_cast<T>(0.5) / r;
@@ -410,12 +365,11 @@ namespace detail
real.w = (x[1].x - x[0].y) * invr;
}
detail::tquat<T, P> dual;
dual.x = T(0.5) * ( x[0].w * real.w + x[1].w * real.z - x[2].w * real.y);
dual.y = T(0.5) * (-x[0].w * real.z + x[1].w * real.w + x[2].w * real.x);
dual.z = T(0.5) * ( x[0].w * real.y - x[1].w * real.x + x[2].w * real.w);
dual.w = -T(0.5) * ( x[0].w * real.x + x[1].w * real.y + x[2].w * real.z);
return detail::tdualquat<T, P>(real, dual);
tquat<T, P> dual(uninitialize);
dual.x = static_cast<T>(0.5) * ( x[0].w * real.w + x[1].w * real.z - x[2].w * real.y);
dual.y = static_cast<T>(0.5) * (-x[0].w * real.z + x[1].w * real.w + x[2].w * real.x);
dual.z = static_cast<T>(0.5) * ( x[0].w * real.y - x[1].w * real.x + x[2].w * real.w);
dual.w = -static_cast<T>(0.5) * ( x[0].w * real.x + x[1].w * real.y + x[2].w * real.z);
return tdualquat<T, P>(real, dual);
}
}//namespace glm
common/glm/glm/gtx/epsilon.hpp
-29
View File
@@ -1,29 +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.
///////////////////////////////////////////////////////////////////////////////////
#if(defined(GLM_MESSAGES))
# pragma message("GLM: GLM_GTX_epsilon extension is deprecated, include GLM_GTC_epsilon (glm/gtc/epsilon) instead")
#endif
// Promoted:
#include "../gtc/epsilon.hpp"
common/glm/glm/gtx/euler_angles.hpp
+20 -19
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -36,8 +40,7 @@
/// <glm/gtx/euler_angles.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_euler_angles
#define GLM_GTX_euler_angles
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -54,67 +57,67 @@ namespace glm
/// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X.
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleX(
GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleX(
T const & angleX);
/// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Y.
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleY(
GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleY(
T const & angleY);
/// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Z.
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleZ(
GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleZ(
T const & angleZ);
/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y).
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleXY(
GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleXY(
T const & angleX,
T const & angleY);
/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X).
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleYX(
GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleYX(
T const & angleY,
T const & angleX);
/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z).
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleXZ(
GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleXZ(
T const & angleX,
T const & angleZ);
/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X).
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleZX(
GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleZX(
T const & angle,
T const & angleX);
/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z).
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleYZ(
GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleYZ(
T const & angleY,
T const & angleZ);
/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y).
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleZY(
GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleZY(
T const & angleZ,
T const & angleY);
/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> eulerAngleYXZ(
GLM_FUNC_DECL tmat4x4<T, defaultp> eulerAngleYXZ(
T const & yaw,
T const & pitch,
T const & roll);
@@ -122,7 +125,7 @@ namespace glm
/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat4x4<T, defaultp> yawPitchRoll(
GLM_FUNC_DECL tmat4x4<T, defaultp> yawPitchRoll(
T const & yaw,
T const & pitch,
T const & roll);
@@ -130,26 +133,24 @@ namespace glm
/// Creates a 2D 2 * 2 rotation matrix from an euler angle.
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat2x2<T, defaultp> orientate2(T const & angle);
GLM_FUNC_DECL tmat2x2<T, defaultp> orientate2(T const & angle);
/// Creates a 2D 4 * 4 homogeneous rotation matrix from an euler angle.
/// @see gtx_euler_angles
template <typename T>
GLM_FUNC_DECL detail::tmat3x3<T, defaultp> orientate3(T const & angle);
GLM_FUNC_DECL tmat3x3<T, defaultp> orientate3(T const & angle);
/// Creates a 3D 3 * 3 rotation matrix from euler angles (Y * X * Z).
/// @see gtx_euler_angles
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> orientate3(detail::tvec3<T, P> const & angles);
GLM_FUNC_DECL tmat3x3<T, P> orientate3(tvec3<T, P> const & angles);
/// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
/// @see gtx_euler_angles
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> orientate4(detail::tvec3<T, P> const & angles);
GLM_FUNC_DECL tmat4x4<T, P> orientate4(tvec3<T, P> const & angles);
/// @}
}//namespace glm
#include "euler_angles.inl"
#endif//GLM_GTX_euler_angles
common/glm/glm/gtx/euler_angles.inl
+57 -34
View File
@@ -1,16 +1,39 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2005-12-21
// Updated : 2007-08-14
// Licence : This source is under MIT License
// File : glm/gtx/euler_angles.inl
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_euler_angles
/// @file glm/gtx/euler_angles.inl
/// @date 2005-12-21 / 2011-06-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm
{
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleX
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleX
(
T const & angleX
)
@@ -18,7 +41,7 @@ namespace glm
T cosX = glm::cos(angleX);
T sinX = glm::sin(angleX);
return detail::tmat4x4<T, defaultp>(
return tmat4x4<T, defaultp>(
T(1), T(0), T(0), T(0),
T(0), cosX, sinX, T(0),
T(0),-sinX, cosX, T(0),
@@ -26,7 +49,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleY
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleY
(
T const & angleY
)
@@ -34,7 +57,7 @@ namespace glm
T cosY = glm::cos(angleY);
T sinY = glm::sin(angleY);
return detail::tmat4x4<T, defaultp>(
return tmat4x4<T, defaultp>(
cosY, T(0), -sinY, T(0),
T(0), T(1), T(0), T(0),
sinY, T(0), cosY, T(0),
@@ -42,7 +65,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleZ
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleZ
(
T const & angleZ
)
@@ -50,7 +73,7 @@ namespace glm
T cosZ = glm::cos(angleZ);
T sinZ = glm::sin(angleZ);
return detail::tmat4x4<T, defaultp>(
return tmat4x4<T, defaultp>(
cosZ, sinZ, T(0), T(0),
-sinZ, cosZ, T(0), T(0),
T(0), T(0), T(1), T(0),
@@ -58,7 +81,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleXY
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleXY
(
T const & angleX,
T const & angleY
@@ -69,7 +92,7 @@ namespace glm
T cosY = glm::cos(angleY);
T sinY = glm::sin(angleY);
return detail::tmat4x4<T, defaultp>(
return tmat4x4<T, defaultp>(
cosY, -sinX * -sinY, cosX * -sinY, T(0),
T(0), cosX, sinX, T(0),
sinY, -sinX * cosY, cosX * cosY, T(0),
@@ -77,7 +100,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleYX
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleYX
(
T const & angleY,
T const & angleX
@@ -88,7 +111,7 @@ namespace glm
T cosY = glm::cos(angleY);
T sinY = glm::sin(angleY);
return detail::tmat4x4<T, defaultp>(
return tmat4x4<T, defaultp>(
cosY, 0, -sinY, T(0),
sinY * sinX, cosX, cosY * sinX, T(0),
sinY * cosX, -sinX, cosY * cosX, T(0),
@@ -96,7 +119,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleXZ
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleXZ
(
T const & angleX,
T const & angleZ
@@ -106,7 +129,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleZX
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleZX
(
T const & angleZ,
T const & angleX
@@ -116,7 +139,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleYZ
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleYZ
(
T const & angleY,
T const & angleZ
@@ -126,7 +149,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleZY
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleZY
(
T const & angleZ,
T const & angleY
@@ -136,7 +159,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> eulerAngleYXZ
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> eulerAngleYXZ
(
T const & yaw,
T const & pitch,
@@ -150,7 +173,7 @@ namespace glm
T tmp_cb = glm::cos(roll);
T tmp_sb = glm::sin(roll);
detail::tmat4x4<T, defaultp> Result;
tmat4x4<T, defaultp> Result;
Result[0][0] = tmp_ch * tmp_cb + tmp_sh * tmp_sp * tmp_sb;
Result[0][1] = tmp_sb * tmp_cp;
Result[0][2] = -tmp_sh * tmp_cb + tmp_ch * tmp_sp * tmp_sb;
@@ -171,7 +194,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, defaultp> yawPitchRoll
GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> yawPitchRoll
(
T const & yaw,
T const & pitch,
@@ -185,7 +208,7 @@ namespace glm
T tmp_cb = glm::cos(roll);
T tmp_sb = glm::sin(roll);
detail::tmat4x4<T, defaultp> Result;
tmat4x4<T, defaultp> Result;
Result[0][0] = tmp_ch * tmp_cb + tmp_sh * tmp_sp * tmp_sb;
Result[0][1] = tmp_sb * tmp_cp;
Result[0][2] = -tmp_sh * tmp_cb + tmp_ch * tmp_sp * tmp_sb;
@@ -206,7 +229,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat2x2<T, defaultp> orientate2
GLM_FUNC_QUALIFIER tmat2x2<T, defaultp> orientate2
(
T const & angle
)
@@ -214,7 +237,7 @@ namespace glm
T c = glm::cos(angle);
T s = glm::sin(angle);
detail::tmat2x2<T, defaultp> Result;
tmat2x2<T, defaultp> Result;
Result[0][0] = c;
Result[0][1] = s;
Result[1][0] = -s;
@@ -223,7 +246,7 @@ namespace glm
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, defaultp> orientate3
GLM_FUNC_QUALIFIER tmat3x3<T, defaultp> orientate3
(
T const & angle
)
@@ -231,7 +254,7 @@ namespace glm
T c = glm::cos(angle);
T s = glm::sin(angle);
detail::tmat3x3<T, defaultp> Result;
tmat3x3<T, defaultp> Result;
Result[0][0] = c;
Result[0][1] = s;
Result[0][2] = 0.0f;
@@ -245,18 +268,18 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> orientate3
GLM_FUNC_QUALIFIER tmat3x3<T, P> orientate3
(
detail::tvec3<T, P> const & angles
tvec3<T, P> const & angles
)
{
return detail::tmat3x3<T, P>(yawPitchRoll(angles.x, angles.y, angles.z));
return tmat3x3<T, P>(yawPitchRoll(angles.z, angles.x, angles.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> orientate4
GLM_FUNC_QUALIFIER tmat4x4<T, P> orientate4
(
detail::tvec3<T, P> const & angles
tvec3<T, P> const & angles
)
{
return yawPitchRoll(angles.z, angles.x, angles.y);
common/glm/glm/gtx/extend.hpp
+5 -4
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -35,8 +39,7 @@
/// <glm/gtx/extend.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_extend
#define GLM_GTX_extend
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -62,5 +65,3 @@ namespace glm
}//namespace glm
#include "extend.inl"
#endif//GLM_GTX_extend
common/glm/glm/gtx/extend.inl
+39 -16
View File
@@ -1,10 +1,33 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2006-01-07
// Updated : 2008-10-05
// Licence : This source is under MIT License
// File : glm/gtx/extend.inl
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_extend
/// @file glm/gtx/extend.inl
/// @date 2006-01-07 / 2011-06-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm
@@ -21,10 +44,10 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> extend
GLM_FUNC_QUALIFIER tvec2<T, P> extend
(
detail::tvec2<T, P> const & Origin,
detail::tvec2<T, P> const & Source,
tvec2<T, P> const & Origin,
tvec2<T, P> const & Source,
T const & Distance
)
{
@@ -32,10 +55,10 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> extend
GLM_FUNC_QUALIFIER tvec3<T, P> extend
(
detail::tvec3<T, P> const & Origin,
detail::tvec3<T, P> const & Source,
tvec3<T, P> const & Origin,
tvec3<T, P> const & Source,
T const & Distance
)
{
@@ -43,10 +66,10 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> extend
GLM_FUNC_QUALIFIER tvec4<T, P> extend
(
detail::tvec4<T, P> const & Origin,
detail::tvec4<T, P> const & Source,
tvec4<T, P> const & Origin,
tvec4<T, P> const & Source,
T const & Distance
)
{
common/glm/glm/gtx/extented_min_max.hpp
+5 -4
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -36,8 +40,7 @@
/// <glm/gtx/extented_min_max.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_extented_min_max
#define GLM_GTX_extented_min_max
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -157,5 +160,3 @@ namespace glm
}//namespace glm
#include "extented_min_max.inl"
#endif//GLM_GTX_extented_min_max
common/glm/glm/gtx/extented_min_max.inl
+30 -7
View File
@@ -1,10 +1,33 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2007-03-14
// Updated : 2010-02-19
// Licence : This source is under MIT License
// File : gtx_extented_min_max.inl
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_extented_min_max
/// @file glm/gtx/extented_min_max.inl
/// @date 2007-03-14 / 2011-06-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm
common/glm/glm/gtx/fast_exponential.hpp
+48 -26
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -36,8 +40,7 @@
/// <glm/gtx/fast_exponential.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_fast_exponential
#define GLM_GTX_fast_exponential
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -53,46 +56,65 @@ namespace glm
/// Faster than the common pow function but less accurate.
/// @see gtx_fast_exponential
template <typename genType>
GLM_FUNC_DECL genType fastPow(
genType const & x,
genType const & y);
template <typename genType>
GLM_FUNC_DECL genType fastPow(genType x, genType y);
/// Faster than the common pow function but less accurate.
/// @see gtx_fast_exponential
template <typename genTypeT, typename genTypeU>
GLM_FUNC_DECL genTypeT fastPow(
genTypeT const & x,
genTypeU const & y);
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> fastPow(vecType<T, P> const & x, vecType<T, P> const & y);
/// Faster than the common pow function but less accurate.
/// @see gtx_fast_exponential
template <typename genTypeT, typename genTypeU>
GLM_FUNC_DECL genTypeT fastPow(genTypeT x, genTypeU y);
/// Faster than the common pow function but less accurate.
/// @see gtx_fast_exponential
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> fastPow(vecType<T, P> const & x);
/// Faster than the common exp function but less accurate.
/// @see gtx_fast_exponential
template <typename T>
GLM_FUNC_DECL T fastExp(const T& x);
template <typename T>
GLM_FUNC_DECL T fastExp(T x);
/// Faster than the common exp function but less accurate.
/// @see gtx_fast_exponential
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> fastExp(vecType<T, P> const & x);
/// Faster than the common log function but less accurate.
/// @see gtx_fast_exponential
template <typename T>
GLM_FUNC_DECL T fastLog(const T& x);
template <typename T>
GLM_FUNC_DECL T fastLog(T x);
/// Faster than the common exp2 function but less accurate.
/// @see gtx_fast_exponential
template <typename T>
GLM_FUNC_DECL T fastExp2(const T& x);
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> fastLog(vecType<T, P> const & x);
/// Faster than the common exp2 function but less accurate.
/// @see gtx_fast_exponential
template <typename T>
GLM_FUNC_DECL T fastExp2(T x);
/// Faster than the common exp2 function but less accurate.
/// @see gtx_fast_exponential
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> fastExp2(vecType<T, P> const & x);
/// Faster than the common log2 function but less accurate.
/// @see gtx_fast_exponential
template <typename T>
GLM_FUNC_DECL T fastLog2(const T& x);
template <typename T>
GLM_FUNC_DECL T fastLog2(T x);
/// Faster than the common ln function but less accurate.
/// Faster than the common log2 function but less accurate.
/// @see gtx_fast_exponential
template <typename T>
GLM_FUNC_DECL T fastLn(const T& x);
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> fastLog2(vecType<T, P> const & x);
/// @}
}//namespace glm
#include "fast_exponential.inl"
#endif//GLM_GTX_fast_exponential
common/glm/glm/gtx/fast_exponential.inl
+67 -49
View File
@@ -1,25 +1,52 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2006-01-09
// Updated : 2006-01-09
// Licence : This source is under MIT License
// File : glm/gtx/fast_exponential.inl
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_fast_exponential
/// @file glm/gtx/fast_exponential.inl
/// @date 2006-01-09 / 2011-06-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm
{
// fastPow:
template <typename genType>
GLM_FUNC_QUALIFIER genType fastPow(genType const & x, genType const & y)
GLM_FUNC_QUALIFIER genType fastPow(genType x, genType y)
{
return exp(y * log(x));
}
VECTORIZE_VEC_VEC(fastPow)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> fastPow(vecType<T, P> const & x, vecType<T, P> const & y)
{
return exp(y * log(x));
}
template <typename T>
GLM_FUNC_QUALIFIER T fastPow(const T x, int y)
GLM_FUNC_QUALIFIER T fastPow(T x, int y)
{
T f = static_cast<T>(1);
for(int i = 0; i < y; ++i)
@@ -27,43 +54,19 @@ namespace glm
return f;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> fastPow(
const detail::tvec2<T, P>& x,
const detail::tvec2<int, P>& y)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> fastPow(vecType<T, P> const & x, vecType<int, P> const & y)
{
return detail::tvec2<T, P>(
fastPow(x.x, y.x),
fastPow(x.y, y.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> fastPow(
const detail::tvec3<T, P>& x,
const detail::tvec3<int, P>& y)
{
return detail::tvec3<T, P>(
fastPow(x.x, y.x),
fastPow(x.y, y.y),
fastPow(x.z, y.z));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> fastPow(
const detail::tvec4<T, P>& x,
const detail::tvec4<int, P>& y)
{
return detail::tvec4<T, P>(
fastPow(x.x, y.x),
fastPow(x.y, y.y),
fastPow(x.z, y.z),
fastPow(x.w, y.w));
vecType<T, P> Result(uninitialize);
for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
Result[i] = fastPow(x[i], y[i]);
return Result;
}
// fastExp
// Note: This function provides accurate results only for value between -1 and 1, else avoid it.
template <typename T>
GLM_FUNC_QUALIFIER T fastExp(const T x)
GLM_FUNC_QUALIFIER T fastExp(T x)
{
// This has a better looking and same performance in release mode than the following code. However, in debug mode it's slower.
// return 1.0f + x * (1.0f + x * 0.5f * (1.0f + x * 0.3333333333f * (1.0f + x * 0.25 * (1.0f + x * 0.2f))));
@@ -107,11 +110,15 @@ namespace glm
}
*/
VECTORIZE_VEC(fastExp)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> fastExp(vecType<T, P> const & x)
{
return detail::functor1<T, T, P, vecType>::call(fastExp, x);
}
// fastLog
template <typename genType>
GLM_FUNC_QUALIFIER genType fastLog(genType const & x)
GLM_FUNC_QUALIFIER genType fastLog(genType x)
{
return std::log(x);
}
@@ -125,24 +132,35 @@ namespace glm
}
*/
VECTORIZE_VEC(fastLog)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> fastLog(vecType<T, P> const & x)
{
return detail::functor1<T, T, P, vecType>::call(fastLog, x);
}
//fastExp2, ln2 = 0.69314718055994530941723212145818f
template <typename genType>
GLM_FUNC_QUALIFIER genType fastExp2(genType const & x)
GLM_FUNC_QUALIFIER genType fastExp2(genType x)
{
return fastExp(0.69314718055994530941723212145818f * x);
}
VECTORIZE_VEC(fastExp2)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> fastExp2(vecType<T, P> const & x)
{
return detail::functor1<T, T, P, vecType>::call(fastExp2, x);
}
// fastLog2, ln2 = 0.69314718055994530941723212145818f
template <typename genType>
GLM_FUNC_QUALIFIER genType fastLog2(genType const & x)
GLM_FUNC_QUALIFIER genType fastLog2(genType x)
{
return fastLog(x) / 0.69314718055994530941723212145818f;
}
VECTORIZE_VEC(fastLog2)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> fastLog2(vecType<T, P> const & x)
{
return detail::functor1<T, T, P, vecType>::call(fastLog2, x);
}
}//namespace glm
common/glm/glm/gtx/fast_square_root.hpp
+50 -23
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -37,11 +41,12 @@
/// <glm/gtx/fast_square_root.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_fast_square_root
#define GLM_GTX_fast_square_root
#pragma once
// Dependency:
#include "../glm.hpp"
#include "../common.hpp"
#include "../exponential.hpp"
#include "../geometric.hpp"
#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
# pragma message("GLM: GLM_GTX_fast_square_root extension included")
@@ -52,33 +57,57 @@ namespace glm
/// @addtogroup gtx_fast_square_root
/// @{
//! Faster than the common sqrt function but less accurate.
//! From GLM_GTX_fast_square_root extension.
/// Faster than the common sqrt function but less accurate.
///
/// @see gtx_fast_square_root extension.
template <typename genType>
GLM_FUNC_DECL genType fastSqrt(genType const & x);
GLM_FUNC_DECL genType fastSqrt(genType x);
//! Faster than the common inversesqrt function but less accurate.
//! From GLM_GTX_fast_square_root extension.
/// Faster than the common sqrt function but less accurate.
///
/// @see gtx_fast_square_root extension.
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> fastSqrt(vecType<T, P> const & x);
/// Faster than the common inversesqrt function but less accurate.
///
/// @see gtx_fast_square_root extension.
template <typename genType>
GLM_FUNC_DECL genType fastInverseSqrt(genType const & x);
GLM_FUNC_DECL genType fastInverseSqrt(genType x);
//! Faster than the common inversesqrt function but less accurate.
//! From GLM_GTX_fast_square_root extension.
/// Faster than the common inversesqrt function but less accurate.
///
/// @see gtx_fast_square_root extension.
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> fastInverseSqrt(vecType<T, P> const & x);
//! Faster than the common length function but less accurate.
//! From GLM_GTX_fast_square_root extension.
template <typename genType>
GLM_FUNC_DECL typename genType::value_type fastLength(genType const & x);
/// Faster than the common length function but less accurate.
///
/// @see gtx_fast_square_root extension.
template <typename genType>
GLM_FUNC_DECL genType fastLength(genType x);
//! Faster than the common distance function but less accurate.
//! From GLM_GTX_fast_square_root extension.
template <typename genType>
GLM_FUNC_DECL typename genType::value_type fastDistance(genType const & x, genType const & y);
/// Faster than the common length function but less accurate.
///
/// @see gtx_fast_square_root extension.
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL T fastLength(vecType<T, P> const & x);
//! Faster than the common normalize function but less accurate.
//! From GLM_GTX_fast_square_root extension.
/// Faster than the common distance function but less accurate.
///
/// @see gtx_fast_square_root extension.
template <typename genType>
GLM_FUNC_DECL genType fastDistance(genType x, genType y);
/// Faster than the common distance function but less accurate.
///
/// @see gtx_fast_square_root extension.
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL T fastDistance(vecType<T, P> const & x, vecType<T, P> const & y);
/// Faster than the common normalize function but less accurate.
///
/// @see gtx_fast_square_root extension.
template <typename genType>
GLM_FUNC_DECL genType fastNormalize(genType const & x);
@@ -86,5 +115,3 @@ namespace glm
}// namespace glm
#include "fast_square_root.inl"
#endif//GLM_GTX_fast_square_root
common/glm/glm/gtx/fast_square_root.inl
+60 -100
View File
@@ -1,150 +1,110 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2006-01-04
// Updated : 2011-10-14
// Licence : This source is under MIT License
// File : glm/gtx/fast_square_root.inl
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_fast_square_root
/// @file glm/gtx/fast_square_root.inl
/// @date 2006-01-04 / 2011-06-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm
{
// fastSqrt
template <typename genType>
GLM_FUNC_QUALIFIER genType fastSqrt
(
genType const & x
)
GLM_FUNC_QUALIFIER genType fastSqrt(genType x)
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'fastSqrt' only accept floating-point input");
return genType(1) / fastInverseSqrt(x);
}
VECTORIZE_VEC(fastSqrt)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> fastSqrt(vecType<T, P> const & x)
{
return detail::functor1<T, T, P, vecType>::call(fastSqrt, x);
}
// fastInversesqrt
template <>
GLM_FUNC_QUALIFIER float fastInverseSqrt<float>(float const & x)
template <typename genType>
GLM_FUNC_QUALIFIER genType fastInverseSqrt(genType x)
{
# ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
detail::tvec1<T, P> tmp(detail::compute_inversesqrt<detail::tvec1, float, lowp>::call(detail::tvec1<float, lowp>(x)));
tvec1<T, P> tmp(detail::compute_inversesqrt<tvec1, genType, lowp>::call(tvec1<genType, lowp>(x)));
return tmp.x;
# else
return detail::compute_inversesqrt<detail::tvec1, float, lowp>::call(detail::tvec1<float, lowp>(x)).x;
return detail::compute_inversesqrt<tvec1, genType, lowp>::call(tvec1<genType, lowp>(x)).x;
# endif
}
template <>
GLM_FUNC_QUALIFIER double fastInverseSqrt<double>(double const & x)
{
# ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
detail::tvec1<T, P> tmp(detail::compute_inversesqrt<detail::tvec1, double, lowp>::call(detail::tvec1<double, lowp>(x)));
return tmp.x;
# else
return detail::compute_inversesqrt<detail::tvec1, double, lowp>::call(detail::tvec1<double, lowp>(x)).x;
# endif
}
template <template <class, precision> class vecType, typename T, precision P>
GLM_FUNC_QUALIFIER vecType<T, P> fastInverseSqrt
(
vecType<T, P> const & x
)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> fastInverseSqrt(vecType<T, P> const & x)
{
return detail::compute_inversesqrt<vecType, T, P>::call(x);
}
VECTORIZE_VEC(fastInverseSqrt)
// fastLength
template <typename genType>
GLM_FUNC_QUALIFIER genType fastLength
(
genType const & x
)
GLM_FUNC_QUALIFIER genType fastLength(genType x)
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'fastLength' only accept floating-point inputs");
return abs(x);
}
template <typename valType, precision P>
GLM_FUNC_QUALIFIER valType fastLength
(
detail::tvec2<valType, P> const & x
)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER T fastLength(vecType<T, P> const & x)
{
valType sqr = x.x * x.x + x.y * x.y;
return fastSqrt(sqr);
}
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fastLength' only accept floating-point inputs");
template <typename valType, precision P>
GLM_FUNC_QUALIFIER valType fastLength
(
detail::tvec3<valType, P> const & x
)
{
valType sqr = x.x * x.x + x.y * x.y + x.z * x.z;
return fastSqrt(sqr);
}
template <typename valType, precision P>
GLM_FUNC_QUALIFIER valType fastLength
(
detail::tvec4<valType, P> const & x
)
{
valType sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;
return fastSqrt(sqr);
return fastSqrt(dot(x, x));
}
// fastDistance
template <typename genType>
GLM_FUNC_QUALIFIER genType fastDistance
(
genType const & x,
genType const & y
)
GLM_FUNC_QUALIFIER genType fastDistance(genType x, genType y)
{
return fastLength(y - x);
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER T fastDistance(vecType<T, P> const & x, vecType<T, P> const & y)
{
return fastLength(y - x);
}
// fastNormalize
template <typename genType>
GLM_FUNC_QUALIFIER genType fastNormalize
(
genType const & x
)
GLM_FUNC_QUALIFIER genType fastNormalize(genType x)
{
return x > genType(0) ? genType(1) : -genType(1);
}
template <typename valType, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<valType, P> fastNormalize
(
detail::tvec2<valType, P> const & x
)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> fastNormalize(vecType<T, P> const & x)
{
valType sqr = x.x * x.x + x.y * x.y;
return x * fastInverseSqrt(sqr);
}
template <typename valType, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<valType, P> fastNormalize
(
detail::tvec3<valType, P> const & x
)
{
valType sqr = x.x * x.x + x.y * x.y + x.z * x.z;
return x * fastInverseSqrt(sqr);
}
template <typename valType, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<valType, P> fastNormalize
(
detail::tvec4<valType, P> const & x
)
{
valType sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;
return x * fastInverseSqrt(sqr);
return x * fastInverseSqrt(dot(x, x));
}
}//namespace glm
common/glm/glm/gtx/fast_trigonometry.hpp
+38 -34
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -35,11 +39,10 @@
/// <glm/gtx/fast_trigonometry.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_fast_trigonometry
#define GLM_GTX_fast_trigonometry
#pragma once
// Dependency:
#include "../glm.hpp"
#include "../gtc/constants.hpp"
#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
# pragma message("GLM: GLM_GTX_fast_trigonometry extension included")
@@ -50,51 +53,52 @@ namespace glm
/// @addtogroup gtx_fast_trigonometry
/// @{
//! Faster than the common sin function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
/// Wrap an angle to [0 2pi[
/// From GLM_GTX_fast_trigonometry extension.
template <typename T>
GLM_FUNC_DECL T fastSin(const T& angle);
GLM_FUNC_DECL T wrapAngle(T angle);
//! Faster than the common cos function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
template <typename T>
GLM_FUNC_DECL T fastCos(const T& angle);
/// Faster than the common sin function but less accurate.
/// From GLM_GTX_fast_trigonometry extension.
template <typename T>
GLM_FUNC_DECL T fastSin(T angle);
//! Faster than the common tan function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
/// Faster than the common cos function but less accurate.
/// From GLM_GTX_fast_trigonometry extension.
template <typename T>
GLM_FUNC_DECL T fastTan(const T& angle);
GLM_FUNC_DECL T fastCos(T angle);
//! Faster than the common asin function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
/// Faster than the common tan function but less accurate.
/// Defined between -2pi and 2pi.
/// From GLM_GTX_fast_trigonometry extension.
template <typename T>
GLM_FUNC_DECL T fastAsin(const T& angle);
GLM_FUNC_DECL T fastTan(T angle);
//! Faster than the common acos function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
/// Faster than the common asin function but less accurate.
/// Defined between -2pi and 2pi.
/// From GLM_GTX_fast_trigonometry extension.
template <typename T>
GLM_FUNC_DECL T fastAcos(const T& angle);
GLM_FUNC_DECL T fastAsin(T angle);
//! Faster than the common atan function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
/// Faster than the common acos function but less accurate.
/// Defined between -2pi and 2pi.
/// From GLM_GTX_fast_trigonometry extension.
template <typename T>
GLM_FUNC_DECL T fastAtan(const T& y, const T& x);
GLM_FUNC_DECL T fastAcos(T angle);
//! Faster than the common atan function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
/// Faster than the common atan function but less accurate.
/// Defined between -2pi and 2pi.
/// From GLM_GTX_fast_trigonometry extension.
template <typename T>
GLM_FUNC_DECL T fastAtan(const T& angle);
GLM_FUNC_DECL T fastAtan(T y, T x);
/// Faster than the common atan function but less accurate.
/// Defined between -2pi and 2pi.
/// From GLM_GTX_fast_trigonometry extension.
template <typename T>
GLM_FUNC_DECL T fastAtan(T angle);
/// @}
}//namespace glm
#include "fast_trigonometry.inl"
#endif//GLM_GTX_fast_trigonometry
common/glm/glm/gtx/fast_trigonometry.inl
+114 -27
View File
@@ -1,75 +1,162 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2006-01-08
// Updated : 2011-10-14
// Licence : This source is under MIT License
// File : glm/gtx/fast_trigonometry.inl
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_fast_trigonometry
/// @file glm/gtx/fast_trigonometry.inl
/// @date 2006-01-08 / 2014-11-25
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm
namespace glm{
namespace detail
{
// sin
template <typename T>
GLM_FUNC_QUALIFIER T fastSin(T const & x)
template <typename T>
GLM_FUNC_QUALIFIER T cos_52s(T x)
{
return x - ((x * x * x) / T(6)) + ((x * x * x * x * x) / T(120)) - ((x * x * x * x * x * x * x) / T(5040));
T const xx(x * x);
return (T(0.9999932946) + xx * (T(-0.4999124376) + xx * (T(0.0414877472) + xx * T(-0.0012712095))));
}
VECTORIZE_VEC(fastSin)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> cos_52s(vecType<T, P> const & x)
{
return detail::functor1<T, T, P, vecType>::call(cos_52s, x);
}
}//namespace detail
// wrapAngle
template <typename T>
GLM_FUNC_QUALIFIER T wrapAngle(T angle)
{
return abs<T>(mod<T>(angle, two_pi<T>()));
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> wrapAngle(vecType<T, P> const & x)
{
return detail::functor1<T, T, P, vecType>::call(wrapAngle, x);
}
// cos
template <typename T>
GLM_FUNC_QUALIFIER T fastCos(T const & x)
GLM_FUNC_QUALIFIER T fastCos(T x)
{
return T(1) - (x * x * T(0.5)) + (x * x * x * x * T(0.041666666666)) - (x * x * x * x * x * x * T(0.00138888888888));
T const angle(wrapAngle<T>(x));
if(angle<half_pi<T>())
return detail::cos_52s(angle);
if(angle<pi<T>())
return -detail::cos_52s(pi<T>() - angle);
if(angle<(T(3) * half_pi<T>()))
return -detail::cos_52s(angle - pi<T>());
return detail::cos_52s(two_pi<T>() - angle);
}
VECTORIZE_VEC(fastCos)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> fastCos(vecType<T, P> const & x)
{
return detail::functor1<T, T, P, vecType>::call(fastCos, x);
}
// sin
template <typename T>
GLM_FUNC_QUALIFIER T fastSin(T x)
{
return fastCos<T>(half_pi<T>() - x);
}
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> fastSin(vecType<T, P> const & x)
{
return detail::functor1<T, T, P, vecType>::call(fastSin, x);
}
// tan
template <typename T>
GLM_FUNC_QUALIFIER T fastTan(T const & x)
GLM_FUNC_QUALIFIER T fastTan(T x)
{
return x + (x * x * x * T(0.3333333333)) + (x * x * x * x * x * T(0.1333333333333)) + (x * x * x * x * x * x * x * T(0.0539682539));
}
VECTORIZE_VEC(fastTan)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> fastTan(vecType<T, P> const & x)
{
return detail::functor1<T, T, P, vecType>::call(fastTan, x);
}
// asin
template <typename T>
GLM_FUNC_QUALIFIER T fastAsin(T const & x)
GLM_FUNC_QUALIFIER T fastAsin(T x)
{
return x + (x * x * x * T(0.166666667)) + (x * x * x * x * x * T(0.075)) + (x * x * x * x * x * x * x * T(0.0446428571)) + (x * x * x * x * x * x * x * x * x * T(0.0303819444));// + (x * x * x * x * x * x * x * x * x * x * x * T(0.022372159));
}
VECTORIZE_VEC(fastAsin)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> fastAsin(vecType<T, P> const & x)
{
return detail::functor1<T, T, P, vecType>::call(fastAsin, x);
}
// acos
template <typename T>
GLM_FUNC_QUALIFIER T fastAcos(T const & x)
GLM_FUNC_QUALIFIER T fastAcos(T x)
{
return T(1.5707963267948966192313216916398) - fastAsin(x); //(PI / 2)
}
VECTORIZE_VEC(fastAcos)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> fastAcos(vecType<T, P> const & x)
{
return detail::functor1<T, T, P, vecType>::call(fastAcos, x);
}
// atan
template <typename T>
GLM_FUNC_QUALIFIER T fastAtan(T const & y, T const & x)
GLM_FUNC_QUALIFIER T fastAtan(T y, T x)
{
T sgn = sign(y) * sign(x);
return abs(fastAtan(y / x)) * sgn;
}
VECTORIZE_VEC_VEC(fastAtan)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> fastAtan(vecType<T, P> const & y, vecType<T, P> const & x)
{
return detail::functor2<T, P, vecType>::call(fastAtan, y, x);
}
template <typename T>
GLM_FUNC_QUALIFIER T fastAtan(T const & x)
GLM_FUNC_QUALIFIER T fastAtan(T x)
{
return x - (x * x * x * T(0.333333333333)) + (x * x * x * x * x * T(0.2)) - (x * x * x * x * x * x * x * T(0.1428571429)) + (x * x * x * x * x * x * x * x * x * T(0.111111111111)) - (x * x * x * x * x * x * x * x * x * x * x * T(0.0909090909));
}
VECTORIZE_VEC(fastAtan)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> fastAtan(vecType<T, P> const & x)
{
return detail::functor1<T, T, P, vecType>::call(fastAtan, x);
}
}//namespace glm
common/glm/glm/gtx/gradient_paint.hpp
+11 -10
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -35,8 +39,7 @@
/// <glm/gtx/gradient_paint.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_gradient_paint
#define GLM_GTX_gradient_paint
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -55,22 +58,20 @@ namespace glm
/// @see - gtx_gradient_paint
template <typename T, precision P>
GLM_FUNC_DECL T radialGradient(
detail::tvec2<T, P> const & Center,
tvec2<T, P> const & Center,
T const & Radius,
detail::tvec2<T, P> const & Focal,
detail::tvec2<T, P> const & Position);
tvec2<T, P> const & Focal,
tvec2<T, P> const & Position);
/// Return a color from a linear gradient.
/// @see - gtx_gradient_paint
template <typename T, precision P>
GLM_FUNC_DECL T linearGradient(
detail::tvec2<T, P> const & Point0,
detail::tvec2<T, P> const & Point1,
detail::tvec2<T, P> const & Position);
tvec2<T, P> const & Point0,
tvec2<T, P> const & Point1,
tvec2<T, P> const & Position);
/// @}
}// namespace glm
#include "gradient_paint.inl"
#endif//GLM_GTX_gradient_paint
common/glm/glm/gtx/gradient_paint.inl
+39 -16
View File
@@ -1,10 +1,33 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2009-03-06
// Updated : 2013-04-09
// Licence : This source is under MIT License
// File : glm/gtx/gradient_paint.inl
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_gradient_paint
/// @file glm/gtx/gradient_paint.inl
/// @date 2009-03-06 / 2013-04-09
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm
@@ -12,14 +35,14 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER T radialGradient
(
detail::tvec2<T, P> const & Center,
tvec2<T, P> const & Center,
T const & Radius,
detail::tvec2<T, P> const & Focal,
detail::tvec2<T, P> const & Position
tvec2<T, P> const & Focal,
tvec2<T, P> const & Position
)
{
detail::tvec2<T, P> F = Focal - Center;
detail::tvec2<T, P> D = Position - Focal;
tvec2<T, P> F = Focal - Center;
tvec2<T, P> D = Position - Focal;
T Radius2 = pow2(Radius);
T Fx2 = pow2(F.x);
T Fy2 = pow2(F.y);
@@ -32,12 +55,12 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER T linearGradient
(
detail::tvec2<T, P> const & Point0,
detail::tvec2<T, P> const & Point1,
detail::tvec2<T, P> const & Position
tvec2<T, P> const & Point0,
tvec2<T, P> const & Point1,
tvec2<T, P> const & Position
)
{
detail::tvec2<T, P> Dist = Point1 - Point0;
tvec2<T, P> Dist = Point1 - Point0;
return (Dist.x * (Position.x - Point0.x) + Dist.y * (Position.y - Point0.y)) / glm::dot(Dist, Dist);
}
}//namespace glm
common/glm/glm/gtx/handed_coordinate_space.hpp
+11 -10
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -35,8 +39,7 @@
/// <glm/gtx/handed_coordinate_system.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_handed_coordinate_space
#define GLM_GTX_handed_coordinate_space
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -54,21 +57,19 @@ namespace glm
//! From GLM_GTX_handed_coordinate_space extension.
template <typename T, precision P>
GLM_FUNC_DECL bool rightHanded(
detail::tvec3<T, P> const & tangent,
detail::tvec3<T, P> const & binormal,
detail::tvec3<T, P> const & normal);
tvec3<T, P> const & tangent,
tvec3<T, P> const & binormal,
tvec3<T, P> const & normal);
//! Return if a trihedron left handed or not.
//! From GLM_GTX_handed_coordinate_space extension.
template <typename T, precision P>
GLM_FUNC_DECL bool leftHanded(
detail::tvec3<T, P> const & tangent,
detail::tvec3<T, P> const & binormal,
detail::tvec3<T, P> const & normal);
tvec3<T, P> const & tangent,
tvec3<T, P> const & binormal,
tvec3<T, P> const & normal);
/// @}
}// namespace glm
#include "handed_coordinate_space.inl"
#endif//GLM_GTX_handed_coordinate_space
common/glm/glm/gtx/handed_coordinate_space.inl
+36 -13
View File
@@ -1,10 +1,33 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2005-12-21
// Updated : 2009-02-19
// Licence : This source is under MIT License
// File : glm/gtx/handed_coordinate_space.inl
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_handed_coordinate_space
/// @file glm/gtx/handed_coordinate_space.inl
/// @date 2005-12-21 / 2009-02-19
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm
@@ -12,9 +35,9 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER bool rightHanded
(
detail::tvec3<T, P> const & tangent,
detail::tvec3<T, P> const & binormal,
detail::tvec3<T, P> const & normal
tvec3<T, P> const & tangent,
tvec3<T, P> const & binormal,
tvec3<T, P> const & normal
)
{
return dot(cross(normal, tangent), binormal) > T(0);
@@ -23,9 +46,9 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER bool leftHanded
(
detail::tvec3<T, P> const & tangent,
detail::tvec3<T, P> const & binormal,
detail::tvec3<T, P> const & normal
tvec3<T, P> const & tangent,
tvec3<T, P> const & binormal,
tvec3<T, P> const & normal
)
{
return dot(cross(normal, tangent), binormal) < T(0);
common/glm/glm/gtx/inertia.hpp
-116
View File
@@ -1,116 +0,0 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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_inertia
/// @file glm/gtx/inertia.hpp
/// @date 2006-04-21 / 2011-06-07
/// @author Christophe Riccio
///
/// @see core (dependence)
/// @see gtx_extented_min_max (dependence)
///
/// @defgroup gtx_inertia GLM_GTX_inertia
/// @ingroup gtx
///
/// @brief Create inertia matrices
///
/// <glm/gtx/inertia.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_inertia
#define GLM_GTX_inertia
// Dependency:
#include "../glm.hpp"
#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
# pragma message("GLM: GLM_GTX_inertia extension included")
#endif
namespace glm
{
/*
/// @addtogroup gtx_inertia
/// @{
//! Build an inertia matrix for a box.
//! From GLM_GTX_inertia extension.
template <typename T, precision P>
detail::tmat3x3<T, P> boxInertia3(
T const & Mass,
detail::tvec3<T, P> const & Scale);
//! Build an inertia matrix for a box.
//! From GLM_GTX_inertia extension.
template <typename T, precision P>
detail::tmat4x4<T, P> boxInertia4(
T const & Mass,
detail::tvec3<T, P> const & Scale);
//! Build an inertia matrix for a disk.
//! From GLM_GTX_inertia extension.
template <typename T, precision P>
detail::tmat3x3<T, P> diskInertia3(
T const & Mass,
T const & Radius);
//! Build an inertia matrix for a disk.
//! From GLM_GTX_inertia extension.
template <typename T, precision P>
detail::tmat4x4<T, P> diskInertia4(
T const & Mass,
T const & Radius);
//! Build an inertia matrix for a ball.
//! From GLM_GTX_inertia extension.
template <typename T, precision P>
detail::tmat3x3<T, P> ballInertia3(
T const & Mass,
T const & Radius);
//! Build an inertia matrix for a ball.
//! From GLM_GTX_inertia extension.
template <typename T, precision P>
detail::tmat4x4<T, P> ballInertia4(
T const & Mass,
T const & Radius);
//! Build an inertia matrix for a sphere.
//! From GLM_GTX_inertia extension.
template <typename T, precision P>
detail::tmat3x3<T, P> sphereInertia3(
T const & Mass,
T const & Radius);
//! Build an inertia matrix for a sphere.
//! From GLM_GTX_inertia extension.
template <typename T, precision P>
detail::tmat4x4<T, P> sphereInertia4(
T const & Mass,
T const & Radius);
*/
/// @}
}// namespace glm
#include "inertia.inl"
#endif//GLM_GTX_inertia
common/glm/glm/gtx/inertia.inl
-116
View File
@@ -1,116 +0,0 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2006-04-21
// Updated : 2006-12-06
// Licence : This source is under MIT License
// File : glm/gtx/inertia.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm
{
/*
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> boxInertia3
(
T const & Mass,
detail::tvec3<T, P> const & Scale
)
{
detail::tmat3x3<T, P> Result(T(1));
Result[0][0] = (Scale.y * Scale.y + Scale.z * Scale.z) * Mass / T(12);
Result[1][1] = (Scale.x * Scale.x + Scale.z * Scale.z) * Mass / T(12);
Result[2][2] = (Scale.x * Scale.x + Scale.y * Scale.y) * Mass / T(12);
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> boxInertia4
(
T const & Mass,
detail::tvec3<T, P> const & Scale
)
{
detail::tmat4x4<T, P> Result(T(1));
Result[0][0] = (Scale.y * Scale.y + Scale.z * Scale.z) * Mass / T(12);
Result[1][1] = (Scale.x * Scale.x + Scale.z * Scale.z) * Mass / T(12);
Result[2][2] = (Scale.x * Scale.x + Scale.y * Scale.y) * Mass / T(12);
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> diskInertia3
(
T const & Mass,
T const & Radius
)
{
T a = Mass * Radius * Radius / T(2);
detail::tmat3x3<T, P> Result(a);
Result[2][2] *= static_cast<T>(2);
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> diskInertia4
(
T const & Mass,
T const & Radius
)
{
T a = Mass * Radius * Radius / T(2);
detail::tmat4x4<T, P> Result(a);
Result[2][2] *= static_cast<T>(2);
Result[3][3] = static_cast<T>(1);
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> ballInertia3
(
T const & Mass,
T const & Radius
)
{
T a = static_cast<T>(2) * Mass * Radius * Radius / T(5);
return detail::tmat3x3<T, P>(a);
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> ballInertia4
(
T const & Mass,
T const & Radius
)
{
T a = static_cast<T>(2) * Mass * Radius * Radius / T(5);
detail::tmat4x4<T, P> Result(a);
Result[3][3] = static_cast<T>(1);
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> sphereInertia3
(
T const & Mass,
T const & Radius
)
{
T a = static_cast<T>(2) * Mass * Radius * Radius / T(3);
return detail::tmat3x3<T, P>(a);
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> sphereInertia4
(
T const & Mass,
T const & Radius
)
{
T a = static_cast<T>(2) * Mass * Radius * Radius / T(3);
detail::tmat4x4<T, P> Result(a);
Result[3][3] = static_cast<T>(1);
return Result;
}
*/
}//namespace glm
common/glm/glm/gtx/int_10_10_10_2.inl
-33
View File
@@ -1,33 +0,0 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
GLM_FUNC_QUALIFIER dword uint10_10_10_2_cast
(
glm::vec4 const & v
)
{
return dword(uint(v.x * 2047.f) << 0 | uint(v.y * 2047.f) << 10 | uint(v.z * 2047.f) << 20 | uint(v.w * 3.f) << 30);
}
}//namespace glm
common/glm/glm/gtx/integer.hpp
+6 -9
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -35,11 +39,11 @@
/// <glm/gtx/integer.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_integer
#define GLM_GTX_integer
#pragma once
// Dependency:
#include "../glm.hpp"
#include "../gtc/integer.hpp"
#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
# pragma message("GLM: GLM_GTX_integer extension included")
@@ -58,11 +62,6 @@ namespace glm
//! From GLM_GTX_integer extension.
GLM_FUNC_DECL int sqrt(int x);
//! Returns the log2 of x. Can be reliably using to compute mipmap count from the texture size.
//! From GLM_GTX_integer extension.
template <typename genIUType>
GLM_FUNC_DECL genIUType log2(genIUType x);
//! Returns the floor log2 of x.
//! From GLM_GTX_integer extension.
GLM_FUNC_DECL unsigned int floor_log2(unsigned int x);
@@ -100,5 +99,3 @@ namespace glm
}//namespace glm
#include "integer.inl"
#endif//GLM_GTX_integer
common/glm/glm/gtx/integer.inl
+40 -31
View File
@@ -1,10 +1,33 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2005-12-24
// Updated : 2011-10-13
// Licence : This source is under MIT License
// File : glm/gtx/integer.inl
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_integer
/// @file glm/gtx/integer.inl
/// @date 2005-12-24 / 2011-10-13
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm
@@ -53,21 +76,7 @@ namespace detail
x += (x >> 16);
return(x & 0x0000003f);
}
template <>
struct compute_log2<false>
{
template <typename T>
GLM_FUNC_QUALIFIER T operator() (T const & Value) const
{
#if(GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_GCC))
return Value <= static_cast<T>(1) ? T(0) : T(32) - nlz(Value - T(1));
#else
return T(32) - nlz(Value - T(1));
#endif
}
};
}//namespace _detail
}//namespace detail
// Henry Gordon Dietz: http://aggregate.org/MAGIC/
/*
@@ -100,29 +109,29 @@ namespace detail
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> factorial(
detail::tvec2<T, P> const & x)
GLM_FUNC_QUALIFIER tvec2<T, P> factorial(
tvec2<T, P> const & x)
{
return detail::tvec2<T, P>(
return tvec2<T, P>(
factorial(x.x),
factorial(x.y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> factorial(
detail::tvec3<T, P> const & x)
GLM_FUNC_QUALIFIER tvec3<T, P> factorial(
tvec3<T, P> const & x)
{
return detail::tvec3<T, P>(
return tvec3<T, P>(
factorial(x.x),
factorial(x.y),
factorial(x.z));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> factorial(
detail::tvec4<T, P> const & x)
GLM_FUNC_QUALIFIER tvec4<T, P> factorial(
tvec4<T, P> const & x)
{
return detail::tvec4<T, P>(
return tvec4<T, P>(
factorial(x.x),
factorial(x.y),
factorial(x.z),
common/glm/glm/gtx/intersect.hpp
+5 -4
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -36,8 +40,7 @@
/// <glm/gtx/intersect.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_intersect
#define GLM_GTX_intersect
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -107,5 +110,3 @@ namespace glm
}//namespace glm
#include "intersect.inl"
#endif//GLM_GTX_intersect
common/glm/glm/gtx/io.hpp
+158 -84
View File
@@ -1,7 +1,7 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 G-Truc Creation (www.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
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -22,129 +26,199 @@
///
/// @ref gtx_io
/// @file glm/gtx/io.hpp
/// @date 2013-11-22
/// @date 2013-11-22 / 2014-11-25
/// @author Jan P Springer (regnirpsj@gmail.com)
///
/// @see core (dependence)
/// @see gtx_quaternion (dependence)
/// @see gtc_quaternion (dependence)
///
/// @defgroup gtx_io GLM_GTX_io
/// @ingroup gtx
///
/// @brief std::[w]ostream support for glm types
///
/// std::[w]ostream support for glm types + precision/width/etc. manipulators
/// based on howard hinnant's std::chrono io proposal
/// [http://home.roadrunner.com/~hinnant/bloomington/chrono_io.html]
///
/// <glm/gtx/io.hpp> needs to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_io
#define GLM_GTX_io
#pragma once
// Dependency:
#include "../detail/setup.hpp"
#include "../gtc/quaternion.hpp"
#include "../glm.hpp"
#include "../gtx/quaternion.hpp"
#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
# pragma message("GLM: GLM_GTX_io extension included")
#if(defined(GLM_MESSAGES) && !defined(glm_ext))
# pragma message("GLM: GLM_GTX_io extension included")
#endif
#include <iosfwd> // std::basic_ostream<> (fwd)
#include <locale> // std::locale, std::locale::facet, std::locale::id
#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_;
};
class format_guard
namespace io
{
public:
enum order_t { column_major, row_major, };
enum order_type { column_major, row_major};
GLM_FUNC_DECL explicit format_guard();
GLM_FUNC_DECL ~format_guard();
template <typename CTy>
class format_punct : public std::locale::facet
{
typedef CTy char_type;
private:
public:
order_t order_;
char cr_;
};
static std::locale::id id;
// decimal places (dflt: 3)
GLM_FUNC_DECL unsigned& precision();
bool formatted;
unsigned precision;
unsigned width;
char_type separator;
char_type delim_left;
char_type delim_right;
char_type space;
char_type newline;
order_type order;
// sign + value + '.' + decimals (dflt: 1 + 4 + 1 + precision())
GLM_FUNC_DECL unsigned& value_width();
explicit format_punct(size_t a = 0);
explicit format_punct(format_punct const&);
};
// matrix output order (dflt: row_major)
GLM_FUNC_DECL format_guard::order_t& order();
template <typename CTy, typename CTr = std::char_traits<CTy> >
class basic_state_saver {
// carriage/return char (dflt: '\n')
GLM_FUNC_DECL char& cr();
public:
// matrix output order -> column_major
GLM_FUNC_DECL std::ios_base& column_major(std::ios_base&);
explicit basic_state_saver(std::basic_ios<CTy,CTr>&);
~basic_state_saver();
// matrix output order -> row_major
GLM_FUNC_DECL std::ios_base& row_major (std::ios_base&);
private:
// carriage/return char -> '\n'
GLM_FUNC_DECL std::ios_base& formatted (std::ios_base&);
typedef ::std::basic_ios<CTy,CTr> state_type;
typedef typename state_type::char_type char_type;
typedef ::std::ios_base::fmtflags flags_type;
typedef ::std::streamsize streamsize_type;
typedef ::std::locale const locale_type;
// carriage/return char -> ' '
GLM_FUNC_DECL std::ios_base& unformatted (std::ios_base&);
state_type& state_;
flags_type flags_;
streamsize_type precision_;
streamsize_type width_;
char_type fill_;
locale_type locale_;
}//namespace io
basic_state_saver& operator=(basic_state_saver const&);
};
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&);
typedef basic_state_saver<char> state_saver;
typedef basic_state_saver<wchar_t> wstate_saver;
/// @}
}//namespace detail
template <typename CTy, typename CTr = std::char_traits<CTy> >
class basic_format_saver
{
public:
explicit basic_format_saver(std::basic_ios<CTy,CTr>&);
~basic_format_saver();
private:
basic_state_saver<CTy> const bss_;
basic_format_saver& operator=(basic_format_saver const&);
};
typedef basic_format_saver<char> format_saver;
typedef basic_format_saver<wchar_t> wformat_saver;
struct precision
{
unsigned value;
explicit precision(unsigned);
};
struct width
{
unsigned value;
explicit width(unsigned);
};
template <typename CTy>
struct delimeter
{
CTy value[3];
explicit delimeter(CTy /* left */, CTy /* right */, CTy /* separator */ = ',');
};
struct order
{
order_type value;
explicit order(order_type);
};
// functions, inlined (inline)
template <typename FTy, typename CTy, typename CTr>
FTy const& get_facet(std::basic_ios<CTy,CTr>&);
template <typename FTy, typename CTy, typename CTr>
std::basic_ios<CTy,CTr>& formatted(std::basic_ios<CTy,CTr>&);
template <typename FTy, typename CTy, typename CTr>
std::basic_ios<CTy,CTr>& unformattet(std::basic_ios<CTy,CTr>&);
template <typename CTy, typename CTr>
std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, precision const&);
template <typename CTy, typename CTr>
std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, width const&);
template <typename CTy, typename CTr>
std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, delimeter<CTy> const&);
template <typename CTy, typename CTr>
std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, order const&);
}//namespace io
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 glm
#include "io.inl"
#endif//GLM_GTX_io
common/glm/glm/gtx/io.inl
+556 -266
View File
@@ -1,328 +1,618 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 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
///////////////////////////////////////////////////////////////////////////////////
/// 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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.inl
/// @date 2013-11-22 / 2014-11-25
/// @author Jan P Springer (regnirpsj@gmail.com)
///////////////////////////////////////////////////////////////////////////////////////////////////
#include "../matrix.hpp"
// #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<>
#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())
{}
template <typename CTy>
/* explicit */ GLM_FUNC_QUALIFIER
format_punct<CTy>::format_punct(size_t a)
: std::locale::facet(a),
formatted (true),
precision (3),
width (1 + 4 + 1 + precision),
separator (','),
delim_left ('['),
delim_right (']'),
space (' '),
newline ('\n'),
order (row_major)
{}
GLM_FUNC_QUALIFIER
precision_guard::~precision_guard()
{
value_width() = value_width_;
precision() = precision_;
}
template <typename CTy>
/* explicit */ GLM_FUNC_QUALIFIER
format_punct<CTy>::format_punct(format_punct const& a)
: std::locale::facet(0),
formatted (a.formatted),
precision (a.precision),
width (a.width),
separator (a.separator),
delim_left (a.delim_left),
delim_right (a.delim_right),
space (a.space),
newline (a.newline),
order (a.order)
{}
/* explicit */ GLM_FUNC_QUALIFIER
format_guard::format_guard()
: order_(order()),
cr_ (cr())
{}
template <typename CTy> std::locale::id format_punct<CTy>::id;
GLM_FUNC_QUALIFIER
format_guard::~format_guard()
{
cr() = cr_;
order() = order_;
}
template <typename CTy, typename CTr>
/* explicit */ GLM_FUNC_QUALIFIER basic_state_saver<CTy,CTr>::basic_state_saver(std::basic_ios<CTy,CTr>& a)
: state_ (a),
flags_ (a.flags()),
precision_(a.precision()),
width_ (a.width()),
fill_ (a.fill()),
locale_ (a.getloc())
{}
GLM_FUNC_QUALIFIER unsigned& precision()
{
static unsigned p(3);
template <typename CTy, typename CTr>
GLM_FUNC_QUALIFIER basic_state_saver<CTy,CTr>::~basic_state_saver()
{
state_.imbue(locale_);
state_.fill(fill_);
state_.width(width_);
state_.precision(precision_);
state_.flags(flags_);
}
return p;
}
GLM_FUNC_QUALIFIER unsigned& value_width()
{
static unsigned p(9);
template <typename CTy, typename CTr>
/* explicit */ GLM_FUNC_QUALIFIER basic_format_saver<CTy,CTr>::basic_format_saver(std::basic_ios<CTy,CTr>& a)
: bss_(a)
{
a.imbue(std::locale(a.getloc(), new format_punct<CTy>(get_facet<format_punct<CTy> >(a))));
}
return p;
}
GLM_FUNC_QUALIFIER format_guard::order_t& order()
{
static format_guard::order_t p(format_guard::row_major);
template <typename CTy, typename CTr>
GLM_FUNC_QUALIFIER
basic_format_saver<CTy,CTr>::~basic_format_saver()
{}
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() = format_guard::column_major;
return os;
}
GLM_FUNC_QUALIFIER std::ios_base& row_major(std::ios_base& os)
{
order() = format_guard::row_major;
return os;
}
/* explicit */ GLM_FUNC_QUALIFIER precision::precision(unsigned a)
: value(a)
{}
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;
}
/* explicit */ GLM_FUNC_QUALIFIER width::width(unsigned a)
: value(a)
{}
template <typename CTy>
/* explicit */ GLM_FUNC_QUALIFIER delimeter<CTy>::delimeter(CTy a, CTy b, CTy c)
: value()
{
value[0] = a;
value[1] = b;
value[2] = c;
}
/* explicit */ GLM_FUNC_QUALIFIER
order::order(order_type a)
: value(a)
{}
template <typename FTy, typename CTy, typename CTr>
GLM_FUNC_QUALIFIER FTy const& get_facet(std::basic_ios<CTy,CTr>& ios)
{
if (!std::has_facet<FTy>(ios.getloc())) {
ios.imbue(std::locale(ios.getloc(), new FTy));
}
return std::use_facet<FTy>(ios.getloc());
}
template <typename CTy, typename CTr>
GLM_FUNC_QUALIFIER std::basic_ios<CTy,CTr>& formatted(std::basic_ios<CTy,CTr>& ios)
{
const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(ios)).formatted = true;
return ios;
}
template <typename CTy, typename CTr>
GLM_FUNC_QUALIFIER std::basic_ios<CTy,CTr>& unformatted(std::basic_ios<CTy,CTr>& ios)
{
const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(ios)).formatted = false;
return ios;
}
template <typename CTy, typename CTr>
GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>& os, precision const& a)
{
const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(os)).precision = a.value;
return os;
}
template <typename CTy, typename CTr>
GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>& os, width const& a)
{
const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(os)).width = a.value;
return os;
}
template <typename CTy, typename CTr>
std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>& os, delimeter<CTy> const& a)
{
format_punct<CTy> & fmt(const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(os)));
fmt.delim_left = a.value[0];
fmt.delim_right = a.value[1];
fmt.separator = a.value[2];
return os;
}
template <typename CTy, typename CTr>
GLM_FUNC_QUALIFIER std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>& os, order const& a)
{
const_cast<format_punct<CTy>&>(get_facet<format_punct<CTy> >(os)).order = a.value;
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);
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
<< ']';
}
if(cerberus)
{
io::format_punct<CTy> const & fmt(io::get_facet<io::format_punct<CTy> >(os));
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(fmt.formatted)
{
io::basic_state_saver<CTy> const bss(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
<< ']';
}
os << std::fixed
<< std::right
<< std::setprecision(fmt.precision)
<< std::setfill(fmt.space)
<< fmt.delim_left
<< std::setw(fmt.width) << a.w << fmt.separator
<< std::setw(fmt.width) << a.x << fmt.separator
<< std::setw(fmt.width) << a.y << fmt.separator
<< std::setw(fmt.width) << a.z
<< fmt.delim_right;
}
else
{
os << a.w << fmt.space << a.x << fmt.space << a.y << fmt.space << 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, tvec3<T,P> const& a)
{
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
return 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
<< ']';
}
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);
return os;
}
if(cerberus)
{
io::format_punct<CTy> const & fmt(io::get_facet<io::format_punct<CTy> >(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(fmt.formatted)
{
io::basic_state_saver<CTy> const bss(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
<< ']';
}
os << std::fixed
<< std::right
<< std::setprecision(fmt.precision)
<< std::setfill(fmt.space)
<< fmt.delim_left
<< std::setw(fmt.width) << a.x << fmt.separator
<< std::setw(fmt.width) << a.y
<< fmt.delim_right;
}
else
{
os << a.x << fmt.space << a.y;
}
}
return os;
}
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& m)
{
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(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) {
os << io::cr()
<< '[' << m[0] << io::cr()
<< ' ' << m[1] << ']';
}
if(cerberus)
{
io::format_punct<CTy> const & fmt(io::get_facet<io::format_punct<CTy> >(os));
return os;
}
if(fmt.formatted)
{
io::basic_state_saver<CTy> const bss(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& m)
{
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
os << std::fixed
<< std::right
<< std::setprecision(fmt.precision)
<< std::setfill(fmt.space)
<< fmt.delim_left
<< std::setw(fmt.width) << a.x << fmt.separator
<< std::setw(fmt.width) << a.y << fmt.separator
<< std::setw(fmt.width) << a.z
<< fmt.delim_right;
}
else
{
os << a.x << fmt.space << a.y << fmt.space << a.z;
}
}
if (cerberus) {
return os;
}
os << io::cr()
<< '[' << m[0] << io::cr()
<< ' ' << m[1] << ']';
}
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);
return os;
}
if(cerberus)
{
io::format_punct<CTy> const & fmt(io::get_facet<io::format_punct<CTy> >(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& m)
{
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
if(fmt.formatted)
{
io::basic_state_saver<CTy> const bss(os);
if (cerberus) {
os << std::fixed
<< std::right
<< std::setprecision(fmt.precision)
<< std::setfill(fmt.space)
<< fmt.delim_left
<< std::setw(fmt.width) << a.x << fmt.separator
<< std::setw(fmt.width) << a.y << fmt.separator
<< std::setw(fmt.width) << a.z << fmt.separator
<< std::setw(fmt.width) << a.w
<< fmt.delim_right;
}
else
{
os << a.x << fmt.space << a.y << fmt.space << a.z << fmt.space << a.w;
}
}
os << io::cr()
<< '[' << m[0] << io::cr()
<< ' ' << m[1] << ']';
}
return os;
}
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);
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& m)
{
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
if(cerberus)
{
io::format_punct<CTy> const & fmt(io::get_facet<io::format_punct<CTy> >(os));
tmat2x2<T,P> m(a);
if (cerberus) {
if(io::row_major == fmt.order)
m = transpose(a);
os << io::cr()
<< '[' << m[0] << io::cr()
<< ' ' << m[1] << io::cr()
<< ' ' << m[2] << ']';
}
if(fmt.formatted)
{
os << fmt.newline
<< fmt.delim_left << m[0] << fmt.newline
<< fmt.space << m[1] << fmt.delim_right;
}
else
{
os << m[0] << fmt.space << m[1];
}
}
return os;
}
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& m)
{
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(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) {
if(cerberus)
{
io::format_punct<CTy> const & fmt(io::get_facet<io::format_punct<CTy> >(os));
tmat3x2<T,P> m(a);
os << io::cr()
<< '[' << m[0] << io::cr()
<< ' ' << m[1] << io::cr()
<< ' ' << m[2] << ']';
}
if(io::row_major == fmt.order)
m = transpose(a);
return os;
}
if(fmt.formatted)
{
os << fmt.newline
<< fmt.delim_left << m[0] << fmt.newline
<< fmt.space << m[1] << fmt.newline
<< fmt.space << m[2] << fmt.delim_right;
}
else
{
os << m[0] << fmt.space << m[1] << fmt.space << m[2];
}
}
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& m)
{
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
return os;
}
if (cerberus) {
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);
os << io::cr()
<< '[' << m[0] << io::cr()
<< ' ' << m[1] << io::cr()
<< ' ' << m[2] << ']';
}
if(cerberus)
{
io::format_punct<CTy> const & fmt(io::get_facet<io::format_punct<CTy> >(os));
tmat4x2<T,P> m(a);
return os;
}
if(io::row_major == fmt.order)
m = transpose(a);
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& m)
{
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
if (cerberus) {
if(fmt.formatted)
{
os << fmt.newline
<< fmt.delim_left << m[0] << fmt.newline
<< fmt.space << m[1] << fmt.newline
<< fmt.space << m[2] << fmt.newline
<< fmt.space << m[3] << fmt.delim_right;
}
else
{
os << m[0] << fmt.space << m[1] << fmt.space << m[2] << fmt.space << m[3];
}
}
os << io::cr()
<< '[' << m[0] << io::cr()
<< ' ' << m[1] << io::cr()
<< ' ' << m[2] << io::cr()
<< ' ' << m[3] << ']';
}
return os;
}
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);
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& m)
{
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
if(cerberus)
{
io::format_punct<CTy> const & fmt(io::get_facet<io::format_punct<CTy> >(os));
tmat2x3<T,P> m(a);
if (cerberus) {
if(io::row_major == fmt.order)
m = transpose(a);
os << io::cr()
<< '[' << m[0] << io::cr()
<< ' ' << m[1] << io::cr()
<< ' ' << m[2] << io::cr()
<< ' ' << m[3] << ']';
}
if(fmt.formatted)
{
os << fmt.newline
<< fmt.delim_left << m[0] << fmt.newline
<< fmt.space << m[1] << fmt.delim_right;
}
else
{
os << m[0] << fmt.space << m[1];
}
}
return os;
}
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& m)
{
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(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) {
if(cerberus)
{
io::format_punct<CTy> const & fmt(io::get_facet<io::format_punct<CTy> >(os));
tmat3x3<T,P> m(a);
os << io::cr()
<< '[' << m[0] << io::cr()
<< ' ' << m[1] << io::cr()
<< ' ' << m[2] << io::cr()
<< ' ' << m[3] << ']';
}
if(io::row_major == fmt.order)
m = transpose(a);
return os;
}
if(fmt.formatted)
{
os << fmt.newline
<< fmt.delim_left << m[0] << fmt.newline
<< fmt.space << m[1] << fmt.newline
<< fmt.space << m[2] << fmt.delim_right;
}
else
{
os << m[0] << fmt.space << m[1] << fmt.space << m[2];
}
}
}//namespace detail
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)
{
io::format_punct<CTy> const & fmt(io::get_facet<io::format_punct<CTy> >(os));
tmat4x3<T,P> m(a);
if(io::row_major == fmt.order)
m = transpose(a);
if (fmt.formatted)
{
os << fmt.newline
<< fmt.delim_left << m[0] << fmt.newline
<< fmt.space << m[1] << fmt.newline
<< fmt.space << m[2] << fmt.newline
<< fmt.space << m[3] << fmt.delim_right;
}
else
{
os << m[0] << fmt.space << m[1] << fmt.space << m[2] << fmt.space << 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)
{
io::format_punct<CTy> const & fmt(io::get_facet<io::format_punct<CTy> >(os));
tmat2x4<T,P> m(a);
if(io::row_major == fmt.order)
m = transpose(a);
if (fmt.formatted)
{
os << fmt.newline
<< fmt.delim_left << m[0] << fmt.newline
<< fmt.space << m[1] << fmt.delim_right;
}
else
{
os << m[0] << fmt.space << 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)
{
io::format_punct<CTy> const & fmt(io::get_facet<io::format_punct<CTy> >(os));
tmat3x4<T,P> m(a);
if(io::row_major == fmt.order)
m = transpose(a);
if(fmt.formatted)
{
os << fmt.newline
<< fmt.delim_left << m[0] << fmt.newline
<< fmt.space << m[1] << fmt.newline
<< fmt.space << m[2] << fmt.delim_right;
}
else
{
os << m[0] << fmt.space << m[1] << fmt.space << 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)
{
io::format_punct<CTy> const & fmt(io::get_facet<io::format_punct<CTy> >(os));
tmat4x4<T,P> m(a);
if (io::row_major == fmt.order)
m = transpose(a);
if(fmt.formatted)
{
os << fmt.newline
<< fmt.delim_left << m[0] << fmt.newline
<< fmt.space << m[1] << fmt.newline
<< fmt.space << m[2] << fmt.newline
<< fmt.space << m[3] << fmt.delim_right;
}
else
{
os << m[0] << fmt.space << m[1] << fmt.space << m[2] << fmt.space << 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)
{
io::format_punct<CTy> const & fmt(io::get_facet<io::format_punct<CTy> >(os));
tmat4x4<T,P> ml(a.first);
tmat4x4<T,P> mr(a.second);
if(io::row_major == fmt.order)
{
ml = transpose(a.first);
mr = transpose(a.second);
}
if(fmt.formatted)
{
CTy const & l(fmt.delim_left);
CTy const & r(fmt.delim_right);
CTy const & s(fmt.space);
os << fmt.newline
<< l << ml[0] << s << s << l << mr[0] << fmt.newline
<< s << ml[1] << s << s << s << mr[1] << fmt.newline
<< s << ml[2] << s << s << s << mr[2] << fmt.newline
<< s << ml[3] << r << s << s << mr[3] << r;
}
else
{
os << ml << fmt.space << mr;
}
}
return os;
}
}//namespace glm
common/glm/glm/gtx/log_base.hpp
+15 -7
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -35,8 +39,7 @@
/// <glm/gtx/log_base.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_log_base
#define GLM_GTX_log_base
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -52,14 +55,19 @@ namespace glm
//! Logarithm for any base.
//! From GLM_GTX_log_base.
template <typename genType>
template <typename genType>
GLM_FUNC_DECL genType log(
genType const & x,
genType const & base);
genType x,
genType base);
//! Logarithm for any base.
//! From GLM_GTX_log_base.
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<T, P> sign(
vecType<T, P> const & x,
vecType<T, P> const & base);
/// @}
}//namespace glm
#include "log_base.inl"
#endif//GLM_GTX_log_base
common/glm/glm/gtx/log_base.inl
+37 -14
View File
@@ -1,24 +1,47 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2008-10-24
// Updated : 2008-10-24
// Licence : This source is under MIT License
// File : glm/gtx/log_base.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_log_base
/// @file glm/gtx/log_base.inl
/// @date 2008-10-24 / 2014-11-25
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
template <typename genType>
GLM_FUNC_QUALIFIER genType log(
genType const & x,
genType const & base)
GLM_FUNC_QUALIFIER genType log(genType const & x, genType const & base)
{
assert(x != genType(0));
return glm::log(x) / glm::log(base);
}
VECTORIZE_VEC_SCA(log)
VECTORIZE_VEC_VEC(log)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> log(vecType<T, P> const & x, vecType<T, P> const & base)
{
return glm::log(x) / glm::log(base);
}
}//namespace glm
common/glm/glm/gtx/matrix_cross_product.hpp
+9 -8
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -36,8 +40,7 @@
/// <glm/gtx/matrix_cross_product.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_matrix_cross_product
#define GLM_GTX_matrix_cross_product
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -54,18 +57,16 @@ namespace glm
//! Build a cross product matrix.
//! From GLM_GTX_matrix_cross_product extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> matrixCross3(
detail::tvec3<T, P> const & x);
GLM_FUNC_DECL tmat3x3<T, P> matrixCross3(
tvec3<T, P> const & x);
//! Build a cross product matrix.
//! From GLM_GTX_matrix_cross_product extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> matrixCross4(
detail::tvec3<T, P> const & x);
GLM_FUNC_DECL tmat4x4<T, P> matrixCross4(
tvec3<T, P> const & x);
/// @}
}//namespace glm
#include "matrix_cross_product.inl"
#endif//GLM_GTX_matrix_cross_product
common/glm/glm/gtx/matrix_cross_product.inl
+37 -14
View File
@@ -1,21 +1,44 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2005-12-21
// Updated : 2005-12-21
// Licence : This source is under MIT License
// File : glm/gtx/matrix_cross_product.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_matrix_cross_product
/// @file glm/gtx/matrix_cross_product.inl
/// @date 2005-12-21 / 2005-12-21
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> matrixCross3
GLM_FUNC_QUALIFIER tmat3x3<T, P> matrixCross3
(
detail::tvec3<T, P> const & x
tvec3<T, P> const & x
)
{
detail::tmat3x3<T, P> Result(T(0));
tmat3x3<T, P> Result(T(0));
Result[0][1] = x.z;
Result[1][0] = -x.z;
Result[0][2] = -x.y;
@@ -26,12 +49,12 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> matrixCross4
GLM_FUNC_QUALIFIER tmat4x4<T, P> matrixCross4
(
detail::tvec3<T, P> const & x
tvec3<T, P> const & x
)
{
detail::tmat4x4<T, P> Result(T(0));
tmat4x4<T, P> Result(T(0));
Result[0][1] = x.z;
Result[1][0] = -x.z;
Result[0][2] = -x.y;
common/glm/glm/gtx/int_10_10_10_2.hpp → common/glm/glm/gtx/matrix_decompose.hpp
+38 -12
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -19,26 +23,48 @@
/// 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_matrix_decompose
/// @file glm/gtx/matrix_decompose.hpp
/// @date 2014-08-29 / 2014-08-29
/// @author Christophe Riccio
///
/// @see core (dependence)
///
/// @defgroup gtx_matrix_decompose GLM_GTX_matrix_decompose
/// @ingroup gtx
///
/// @brief Decomposes a model matrix to translations, rotation and scale components
///
/// <glm/gtx/decomposition.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_int_10_10_10_2
#define GLM_GTX_int_10_10_10_2
#pragma once
// Dependency:
#include "../glm.hpp"
#include "../gtx/raw_data.hpp"
// Dependencies
#include "../mat4x4.hpp"
#include "../vec3.hpp"
#include "../vec4.hpp"
#include "../gtc/quaternion.hpp"
#include "../gtc/matrix_transform.hpp"
#if(defined(GLM_MESSAGES))
# pragma message("GLM: GLM_GTX_int_10_10_10_2 extension is deprecated, include GLM_GTC_packing (glm/gtc/packing.hpp) instead")
#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
# pragma message("GLM: GLM_GTX_matrix_decompose extension included")
#endif
namespace glm
{
//! Deprecated, use packUnorm3x10_1x2 instead.
GLM_DEPRECATED GLM_FUNC_DECL dword uint10_10_10_2_cast(glm::vec4 const & v);
/// @addtogroup gtx_matrix_decompose
/// @{
/// Decomposes a model matrix to translations, rotation and scale components
/// @see gtx_matrix_decompose
template <typename T, precision P>
GLM_FUNC_DECL bool decompose(
tmat4x4<T, P> const & modelMatrix,
tvec3<T, P> & scale, tquat<T, P> & orientation, tvec3<T, P> & translation, tvec3<T, P> & skew, tvec4<T, P> & perspective);
/// @}
}//namespace glm
#include "int_10_10_10_2.inl"
#endif//GLM_GTX_int_10_10_10_2
#include "matrix_decompose.inl"
common/glm/glm/gtx/matrix_decompose.inl
+230
View File
@@ -0,0 +1,230 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_matrix_decompose
/// @file glm/gtx/matrix_decompose.inl
/// @date 2014-08-29 / 2014-08-29
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
/// Make a linear combination of two vectors and return the result.
// result = (a * ascl) + (b * bscl)
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec3<T, P> combine(
tvec3<T, P> const & a,
tvec3<T, P> const & b,
T ascl, T bscl)
{
return (a * ascl) + (b * bscl);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER void v3Scale(tvec3<T, P> & v, T desiredLength)
{
T len = glm::length(v);
if(len != 0)
{
T l = desiredLength / len;
v[0] *= l;
v[1] *= l;
v[2] *= l;
}
}
/**
* Matrix decompose
* http://www.opensource.apple.com/source/WebCore/WebCore-514/platform/graphics/transforms/TransformationMatrix.cpp
* Decomposes the mode matrix to translations,rotation scale components
*
*/
template <typename T, precision P>
GLM_FUNC_QUALIFIER bool decompose(tmat4x4<T, P> const & ModelMatrix, tvec3<T, P> & Scale, tquat<T, P> & Orientation, tvec3<T, P> & Translation, tvec3<T, P> & Skew, tvec4<T, P> & Perspective)
{
tmat4x4<T, P> LocalMatrix(ModelMatrix);
// Normalize the matrix.
if(LocalMatrix[3][3] == static_cast<T>(0))
return false;
for(length_t i = 0; i < 4; ++i)
for(length_t j = 0; j < 4; ++j)
LocalMatrix[i][j] /= LocalMatrix[3][3];
// perspectiveMatrix is used to solve for perspective, but it also provides
// an easy way to test for singularity of the upper 3x3 component.
tmat4x4<T, P> PerspectiveMatrix(LocalMatrix);
for(length_t i = 0; i < 3; i++)
PerspectiveMatrix[i][3] = 0;
PerspectiveMatrix[3][3] = 1;
/// TODO: Fixme!
if(determinant(PerspectiveMatrix) == static_cast<T>(0))
return false;
// First, isolate perspective. This is the messiest.
if(LocalMatrix[0][3] != 0 || LocalMatrix[1][3] != 0 || LocalMatrix[2][3] != 0)
{
// rightHandSide is the right hand side of the equation.
tvec4<T, P> RightHandSide;
RightHandSide[0] = LocalMatrix[0][3];
RightHandSide[1] = LocalMatrix[1][3];
RightHandSide[2] = LocalMatrix[2][3];
RightHandSide[3] = LocalMatrix[3][3];
// Solve the equation by inverting PerspectiveMatrix and multiplying
// rightHandSide by the inverse. (This is the easiest way, not
// necessarily the best.)
tmat4x4<T, P> InversePerspectiveMatrix = glm::inverse(PerspectiveMatrix);// inverse(PerspectiveMatrix, inversePerspectiveMatrix);
tmat4x4<T, P> TransposedInversePerspectiveMatrix = glm::transpose(InversePerspectiveMatrix);// transposeMatrix4(inversePerspectiveMatrix, transposedInversePerspectiveMatrix);
Perspective = TransposedInversePerspectiveMatrix * RightHandSide;
// v4MulPointByMatrix(rightHandSide, transposedInversePerspectiveMatrix, perspectivePoint);
// Clear the perspective partition
LocalMatrix[0][3] = LocalMatrix[1][3] = LocalMatrix[2][3] = 0;
LocalMatrix[3][3] = 1;
}
else
{
// No perspective.
Perspective = tvec4<T, P>(0, 0, 0, 1);
}
// Next take care of translation (easy).
Translation = tvec3<T, P>(LocalMatrix[3]);
LocalMatrix[3] = tvec4<T, P>(0, 0, 0, LocalMatrix[3].w);
tvec3<T, P> Row[3], Pdum3;
// Now get scale and shear.
for(length_t i = 0; i < 3; ++i)
Row[i] = LocalMatrix[i];
// Compute X scale factor and normalize first row.
Scale.x = length(Row[0]);// v3Length(Row[0]);
v3Scale(Row[0], 1.0);
// Compute XY shear factor and make 2nd row orthogonal to 1st.
Skew.z = dot(Row[0], Row[1]);
Row[1] = combine(Row[1], Row[0], 1.0, -Skew.z);
// Now, compute Y scale and normalize 2nd row.
Scale.y = length(Row[1]);
v3Scale(Row[1], 1.0);
Skew.z /= Scale.y;
// Compute XZ and YZ shears, orthogonalize 3rd row.
Skew.y = glm::dot(Row[0], Row[2]);
Row[2] = combine(Row[2], Row[0], 1.0, -Skew.y);
Skew.x = glm::dot(Row[1], Row[2]);
Row[2] = combine(Row[2], Row[1], 1.0, -Skew.x);
// Next, get Z scale and normalize 3rd row.
Scale.z = length(Row[2]);
v3Scale(Row[2], 1.0);
Skew.y /= Scale.z;
Skew.x /= Scale.z;
// At this point, the matrix (in rows[]) is orthonormal.
// Check for a coordinate system flip. If the determinant
// is -1, then negate the matrix and the scaling factors.
Pdum3 = cross(Row[1], Row[2]); // v3Cross(row[1], row[2], Pdum3);
if(dot(Row[0], Pdum3) < 0)
{
for(length_t i = 0; i < 3; i++)
{
Scale.x *= static_cast<T>(-1);
Row[i] *= static_cast<T>(-1);
}
}
// Now, get the rotations out, as described in the gem.
// FIXME - Add the ability to return either quaternions (which are
// easier to recompose with) or Euler angles (rx, ry, rz), which
// are easier for authors to deal with. The latter will only be useful
// when we fix https://bugs.webkit.org/show_bug.cgi?id=23799, so I
// will leave the Euler angle code here for now.
// ret.rotateY = asin(-Row[0][2]);
// if (cos(ret.rotateY) != 0) {
// ret.rotateX = atan2(Row[1][2], Row[2][2]);
// ret.rotateZ = atan2(Row[0][1], Row[0][0]);
// } else {
// ret.rotateX = atan2(-Row[2][0], Row[1][1]);
// ret.rotateZ = 0;
// }
T s, t, x, y, z, w;
t = Row[0][0] + Row[1][1] + Row[2][2] + 1.0;
if(t > 1e-4)
{
s = 0.5 / sqrt(t);
w = 0.25 / s;
x = (Row[2][1] - Row[1][2]) * s;
y = (Row[0][2] - Row[2][0]) * s;
z = (Row[1][0] - Row[0][1]) * s;
}
else if(Row[0][0] > Row[1][1] && Row[0][0] > Row[2][2])
{
s = sqrt (1.0 + Row[0][0] - Row[1][1] - Row[2][2]) * 2.0; // S=4*qx
x = 0.25 * s;
y = (Row[0][1] + Row[1][0]) / s;
z = (Row[0][2] + Row[2][0]) / s;
w = (Row[2][1] - Row[1][2]) / s;
}
else if(Row[1][1] > Row[2][2])
{
s = sqrt (1.0 + Row[1][1] - Row[0][0] - Row[2][2]) * 2.0; // S=4*qy
x = (Row[0][1] + Row[1][0]) / s;
y = 0.25 * s;
z = (Row[1][2] + Row[2][1]) / s;
w = (Row[0][2] - Row[2][0]) / s;
}
else
{
s = sqrt(1.0 + Row[2][2] - Row[0][0] - Row[1][1]) * 2.0; // S=4*qz
x = (Row[0][2] + Row[2][0]) / s;
y = (Row[1][2] + Row[2][1]) / s;
z = 0.25 * s;
w = (Row[1][0] - Row[0][1]) / s;
}
Orientation.x = x;
Orientation.y = y;
Orientation.z = z;
Orientation.w = w;
return true;
}
}//namespace glm
common/glm/glm/gtx/matrix_interpolation.hpp
+14 -13
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -35,8 +39,7 @@
/// <glm/gtx/matrix_interpolation.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_matrix_interpolation
#define GLM_GTX_matrix_interpolation
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -54,35 +57,33 @@ namespace glm
/// From GLM_GTX_matrix_interpolation extension.
template <typename T, precision P>
GLM_FUNC_DECL void axisAngle(
detail::tmat4x4<T, P> const & mat,
detail::tvec3<T, P> & axis,
tmat4x4<T, P> const & mat,
tvec3<T, P> & axis,
T & angle);
/// Build a matrix from axis and angle.
/// From GLM_GTX_matrix_interpolation extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> axisAngleMatrix(
detail::tvec3<T, P> const & axis,
GLM_FUNC_DECL tmat4x4<T, P> axisAngleMatrix(
tvec3<T, P> const & axis,
T const angle);
/// Extracts the rotation part of a matrix.
/// From GLM_GTX_matrix_interpolation extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> extractMatrixRotation(
detail::tmat4x4<T, P> const & mat);
GLM_FUNC_DECL tmat4x4<T, P> extractMatrixRotation(
tmat4x4<T, P> const & mat);
/// Build a interpolation of 4 * 4 matrixes.
/// From GLM_GTX_matrix_interpolation extension.
/// Warning! works only with rotation and/or translation matrixes, scale will generate unexpected results.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> interpolate(
detail::tmat4x4<T, P> const & m1,
detail::tmat4x4<T, P> const & m2,
GLM_FUNC_DECL tmat4x4<T, P> interpolate(
tmat4x4<T, P> const & m1,
tmat4x4<T, P> const & m2,
T const delta);
/// @}
}//namespace glm
#include "matrix_interpolation.inl"
#endif//GLM_GTX_matrix_interpolation
common/glm/glm/gtx/matrix_interpolation.inl
+47 -24
View File
@@ -1,19 +1,42 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2011-03-05
// Updated : 2011-03-05
// Licence : This source is under MIT License
// File : glm/gtx/matrix_interpolation.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_matrix_interpolation
/// @file glm/gtx/matrix_interpolation.hpp
/// @date 2011-03-05 / 2011-03-05
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER void axisAngle
(
detail::tmat4x4<T, P> const & mat,
detail::tvec3<T, P> & axis,
tmat4x4<T, P> const & mat,
tvec3<T, P> & axis,
T & angle
)
{
@@ -85,18 +108,18 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> axisAngleMatrix
GLM_FUNC_QUALIFIER tmat4x4<T, P> axisAngleMatrix
(
detail::tvec3<T, P> const & axis,
tvec3<T, P> const & axis,
T const angle
)
{
T c = cos(angle);
T s = sin(angle);
T t = static_cast<T>(1) - c;
detail::tvec3<T, P> n = normalize(axis);
tvec3<T, P> n = normalize(axis);
return detail::tmat4x4<T, P>(
return tmat4x4<T, P>(
t * n.x * n.x + c, t * n.x * n.y + n.z * s, t * n.x * n.z - n.y * s, T(0),
t * n.x * n.y - n.z * s, t * n.y * n.y + c, t * n.y * n.z + n.x * s, T(0),
t * n.x * n.z + n.y * s, t * n.y * n.z - n.x * s, t * n.z * n.z + c, T(0),
@@ -105,12 +128,12 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> extractMatrixRotation
GLM_FUNC_QUALIFIER tmat4x4<T, P> extractMatrixRotation
(
detail::tmat4x4<T, P> const & mat
tmat4x4<T, P> const & mat
)
{
return detail::tmat4x4<T, P>(
return tmat4x4<T, P>(
mat[0][0], mat[0][1], mat[0][2], 0.0,
mat[1][0], mat[1][1], mat[1][2], 0.0,
mat[2][0], mat[2][1], mat[2][2], 0.0,
@@ -119,19 +142,19 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> interpolate
GLM_FUNC_QUALIFIER tmat4x4<T, P> interpolate
(
detail::tmat4x4<T, P> const & m1,
detail::tmat4x4<T, P> const & m2,
tmat4x4<T, P> const & m1,
tmat4x4<T, P> const & m2,
T const delta
)
{
detail::tmat4x4<T, P> m1rot = extractMatrixRotation(m1);
detail::tmat4x4<T, P> dltRotation = m2 * transpose(m1rot);
detail::tvec3<T, P> dltAxis;
tmat4x4<T, P> m1rot = extractMatrixRotation(m1);
tmat4x4<T, P> dltRotation = m2 * transpose(m1rot);
tvec3<T, P> dltAxis;
T dltAngle;
axisAngle(dltRotation, dltAxis, dltAngle);
detail::tmat4x4<T, P> out = axisAngleMatrix(dltAxis, dltAngle * delta) * m1rot;
tmat4x4<T, P> out = axisAngleMatrix(dltAxis, dltAngle * delta) * m1rot;
out[3][0] = m1[3][0] + delta * (m2[3][0] - m1[3][0]);
out[3][1] = m1[3][1] + delta * (m2[3][1] - m1[3][1]);
out[3][2] = m1[3][2] + delta * (m2[3][2] - m1[3][2]);
common/glm/glm/gtx/matrix_major_storage.hpp
+41 -40
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -36,8 +40,7 @@
/// <glm/gtx/matrix_major_storage.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_matrix_major_storage
#define GLM_GTX_matrix_major_storage
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -54,90 +57,88 @@ namespace glm
//! Build a row major matrix from row vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat2x2<T, P> rowMajor2(
detail::tvec2<T, P> const & v1,
detail::tvec2<T, P> const & v2);
GLM_FUNC_DECL tmat2x2<T, P> rowMajor2(
tvec2<T, P> const & v1,
tvec2<T, P> const & v2);
//! Build a row major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat2x2<T, P> rowMajor2(
detail::tmat2x2<T, P> const & m);
GLM_FUNC_DECL tmat2x2<T, P> rowMajor2(
tmat2x2<T, P> const & m);
//! Build a row major matrix from row vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> rowMajor3(
detail::tvec3<T, P> const & v1,
detail::tvec3<T, P> const & v2,
detail::tvec3<T, P> const & v3);
GLM_FUNC_DECL tmat3x3<T, P> rowMajor3(
tvec3<T, P> const & v1,
tvec3<T, P> const & v2,
tvec3<T, P> const & v3);
//! Build a row major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> rowMajor3(
detail::tmat3x3<T, P> const & m);
GLM_FUNC_DECL tmat3x3<T, P> rowMajor3(
tmat3x3<T, P> const & m);
//! Build a row major matrix from row vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> rowMajor4(
detail::tvec4<T, P> const & v1,
detail::tvec4<T, P> const & v2,
detail::tvec4<T, P> const & v3,
detail::tvec4<T, P> const & v4);
GLM_FUNC_DECL tmat4x4<T, P> rowMajor4(
tvec4<T, P> const & v1,
tvec4<T, P> const & v2,
tvec4<T, P> const & v3,
tvec4<T, P> const & v4);
//! Build a row major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> rowMajor4(
detail::tmat4x4<T, P> const & m);
GLM_FUNC_DECL tmat4x4<T, P> rowMajor4(
tmat4x4<T, P> const & m);
//! Build a column major matrix from column vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat2x2<T, P> colMajor2(
detail::tvec2<T, P> const & v1,
detail::tvec2<T, P> const & v2);
GLM_FUNC_DECL tmat2x2<T, P> colMajor2(
tvec2<T, P> const & v1,
tvec2<T, P> const & v2);
//! Build a column major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat2x2<T, P> colMajor2(
detail::tmat2x2<T, P> const & m);
GLM_FUNC_DECL tmat2x2<T, P> colMajor2(
tmat2x2<T, P> const & m);
//! Build a column major matrix from column vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> colMajor3(
detail::tvec3<T, P> const & v1,
detail::tvec3<T, P> const & v2,
detail::tvec3<T, P> const & v3);
GLM_FUNC_DECL tmat3x3<T, P> colMajor3(
tvec3<T, P> const & v1,
tvec3<T, P> const & v2,
tvec3<T, P> const & v3);
//! Build a column major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> colMajor3(
detail::tmat3x3<T, P> const & m);
GLM_FUNC_DECL tmat3x3<T, P> colMajor3(
tmat3x3<T, P> const & m);
//! Build a column major matrix from column vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> colMajor4(
detail::tvec4<T, P> const & v1,
detail::tvec4<T, P> const & v2,
detail::tvec4<T, P> const & v3,
detail::tvec4<T, P> const & v4);
GLM_FUNC_DECL tmat4x4<T, P> colMajor4(
tvec4<T, P> const & v1,
tvec4<T, P> const & v2,
tvec4<T, P> const & v3,
tvec4<T, P> const & v4);
//! Build a column major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> colMajor4(
detail::tmat4x4<T, P> const & m);
GLM_FUNC_DECL tmat4x4<T, P> colMajor4(
tmat4x4<T, P> const & m);
/// @}
}//namespace glm
#include "matrix_major_storage.inl"
#endif//GLM_GTX_matrix_major_storage
common/glm/glm/gtx/matrix_major_storage.inl
+79 -56
View File
@@ -1,22 +1,45 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2006-04-19
// Updated : 2009-02-19
// Licence : This source is under MIT License
// File : glm/gtx/matrix_major_storage.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_matrix_major_storage
/// @file glm/gtx/matrix_major_storage.hpp
/// @date 2006-04-19 / 2014-11-25
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat2x2<T, P> rowMajor2
GLM_FUNC_QUALIFIER tmat2x2<T, P> rowMajor2
(
detail::tvec2<T, P> const & v1,
detail::tvec2<T, P> const & v2
tvec2<T, P> const & v1,
tvec2<T, P> const & v2
)
{
detail::tmat2x2<T, P> Result;
tmat2x2<T, P> Result;
Result[0][0] = v1.x;
Result[1][0] = v1.y;
Result[0][1] = v2.x;
@@ -25,10 +48,10 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat2x2<T, P> rowMajor2(
const detail::tmat2x2<T, P>& m)
GLM_FUNC_QUALIFIER tmat2x2<T, P> rowMajor2(
const tmat2x2<T, P>& m)
{
detail::tmat2x2<T, P> Result;
tmat2x2<T, P> Result;
Result[0][0] = m[0][0];
Result[0][1] = m[1][0];
Result[1][0] = m[0][1];
@@ -37,12 +60,12 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> rowMajor3(
const detail::tvec3<T, P>& v1,
const detail::tvec3<T, P>& v2,
const detail::tvec3<T, P>& v3)
GLM_FUNC_QUALIFIER tmat3x3<T, P> rowMajor3(
const tvec3<T, P>& v1,
const tvec3<T, P>& v2,
const tvec3<T, P>& v3)
{
detail::tmat3x3<T, P> Result;
tmat3x3<T, P> Result;
Result[0][0] = v1.x;
Result[1][0] = v1.y;
Result[2][0] = v1.z;
@@ -56,10 +79,10 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> rowMajor3(
const detail::tmat3x3<T, P>& m)
GLM_FUNC_QUALIFIER tmat3x3<T, P> rowMajor3(
const tmat3x3<T, P>& m)
{
detail::tmat3x3<T, P> Result;
tmat3x3<T, P> Result;
Result[0][0] = m[0][0];
Result[0][1] = m[1][0];
Result[0][2] = m[2][0];
@@ -73,13 +96,13 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> rowMajor4(
const detail::tvec4<T, P>& v1,
const detail::tvec4<T, P>& v2,
const detail::tvec4<T, P>& v3,
const detail::tvec4<T, P>& v4)
GLM_FUNC_QUALIFIER tmat4x4<T, P> rowMajor4(
const tvec4<T, P>& v1,
const tvec4<T, P>& v2,
const tvec4<T, P>& v3,
const tvec4<T, P>& v4)
{
detail::tmat4x4<T, P> Result;
tmat4x4<T, P> Result;
Result[0][0] = v1.x;
Result[1][0] = v1.y;
Result[2][0] = v1.z;
@@ -100,10 +123,10 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> rowMajor4(
const detail::tmat4x4<T, P>& m)
GLM_FUNC_QUALIFIER tmat4x4<T, P> rowMajor4(
const tmat4x4<T, P>& m)
{
detail::tmat4x4<T, P> Result;
tmat4x4<T, P> Result;
Result[0][0] = m[0][0];
Result[0][1] = m[1][0];
Result[0][2] = m[2][0];
@@ -124,50 +147,50 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat2x2<T, P> colMajor2(
const detail::tvec2<T, P>& v1,
const detail::tvec2<T, P>& v2)
GLM_FUNC_QUALIFIER tmat2x2<T, P> colMajor2(
const tvec2<T, P>& v1,
const tvec2<T, P>& v2)
{
return detail::tmat2x2<T, P>(v1, v2);
return tmat2x2<T, P>(v1, v2);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat2x2<T, P> colMajor2(
const detail::tmat2x2<T, P>& m)
GLM_FUNC_QUALIFIER tmat2x2<T, P> colMajor2(
const tmat2x2<T, P>& m)
{
return detail::tmat2x2<T, P>(m);
return tmat2x2<T, P>(m);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> colMajor3(
const detail::tvec3<T, P>& v1,
const detail::tvec3<T, P>& v2,
const detail::tvec3<T, P>& v3)
GLM_FUNC_QUALIFIER tmat3x3<T, P> colMajor3(
const tvec3<T, P>& v1,
const tvec3<T, P>& v2,
const tvec3<T, P>& v3)
{
return detail::tmat3x3<T, P>(v1, v2, v3);
return tmat3x3<T, P>(v1, v2, v3);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> colMajor3(
const detail::tmat3x3<T, P>& m)
GLM_FUNC_QUALIFIER tmat3x3<T, P> colMajor3(
const tmat3x3<T, P>& m)
{
return detail::tmat3x3<T, P>(m);
return tmat3x3<T, P>(m);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> colMajor4(
const detail::tvec4<T, P>& v1,
const detail::tvec4<T, P>& v2,
const detail::tvec4<T, P>& v3,
const detail::tvec4<T, P>& v4)
GLM_FUNC_QUALIFIER tmat4x4<T, P> colMajor4(
const tvec4<T, P>& v1,
const tvec4<T, P>& v2,
const tvec4<T, P>& v3,
const tvec4<T, P>& v4)
{
return detail::tmat4x4<T, P>(v1, v2, v3, v4);
return tmat4x4<T, P>(v1, v2, v3, v4);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> colMajor4(
const detail::tmat4x4<T, P>& m)
GLM_FUNC_QUALIFIER tmat4x4<T, P> colMajor4(
const tmat4x4<T, P>& m)
{
return detail::tmat4x4<T, P>(m);
return tmat4x4<T, P>(m);
}
}//namespace glm
common/glm/glm/gtx/matrix_operation.hpp
+23 -22
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -35,8 +39,7 @@
/// <glm/gtx/matrix_operation.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_matrix_operation
#define GLM_GTX_matrix_operation
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -53,60 +56,58 @@ namespace glm
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat2x2<T, P> diagonal2x2(
detail::tvec2<T, P> const & v);
GLM_FUNC_DECL tmat2x2<T, P> diagonal2x2(
tvec2<T, P> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat2x3<T, P> diagonal2x3(
detail::tvec2<T, P> const & v);
GLM_FUNC_DECL tmat2x3<T, P> diagonal2x3(
tvec2<T, P> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat2x4<T, P> diagonal2x4(
detail::tvec2<T, P> const & v);
GLM_FUNC_DECL tmat2x4<T, P> diagonal2x4(
tvec2<T, P> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x2<T, P> diagonal3x2(
detail::tvec2<T, P> const & v);
GLM_FUNC_DECL tmat3x2<T, P> diagonal3x2(
tvec2<T, P> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> diagonal3x3(
detail::tvec3<T, P> const & v);
GLM_FUNC_DECL tmat3x3<T, P> diagonal3x3(
tvec3<T, P> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x4<T, P> diagonal3x4(
detail::tvec3<T, P> const & v);
GLM_FUNC_DECL tmat3x4<T, P> diagonal3x4(
tvec3<T, P> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x2<T, P> diagonal4x2(
detail::tvec2<T, P> const & v);
GLM_FUNC_DECL tmat4x2<T, P> diagonal4x2(
tvec2<T, P> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x3<T, P> diagonal4x3(
detail::tvec3<T, P> const & v);
GLM_FUNC_DECL tmat4x3<T, P> diagonal4x3(
tvec3<T, P> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> diagonal4x4(
detail::tvec4<T, P> const & v);
GLM_FUNC_DECL tmat4x4<T, P> diagonal4x4(
tvec4<T, P> const & v);
/// @}
}//namespace glm
#include "matrix_operation.inl"
#endif//GLM_GTX_matrix_operation
common/glm/glm/gtx/matrix_operation.inl
+58 -35
View File
@@ -1,69 +1,92 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2009-08-29
// Updated : 2009-08-29
// Licence : This source is under MIT License
// File : glm/gtx/matrix_operation.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_matrix_operation
/// @file glm/gtx/matrix_operation.inl
/// @date 2009-08-29 / 2009-08-29
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat2x2<T, P> diagonal2x2
GLM_FUNC_QUALIFIER tmat2x2<T, P> diagonal2x2
(
detail::tvec2<T, P> const & v
tvec2<T, P> const & v
)
{
detail::tmat2x2<T, P> Result(static_cast<T>(1));
tmat2x2<T, P> Result(static_cast<T>(1));
Result[0][0] = v[0];
Result[1][1] = v[1];
return Result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat2x3<T, P> diagonal2x3
GLM_FUNC_QUALIFIER tmat2x3<T, P> diagonal2x3
(
detail::tvec2<T, P> const & v
tvec2<T, P> const & v
)
{
detail::tmat2x3<T, P> Result(static_cast<T>(1));
tmat2x3<T, P> Result(static_cast<T>(1));
Result[0][0] = v[0];
Result[1][1] = v[1];
return Result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat2x4<T, P> diagonal2x4
GLM_FUNC_QUALIFIER tmat2x4<T, P> diagonal2x4
(
detail::tvec2<T, P> const & v
tvec2<T, P> const & v
)
{
detail::tmat2x4<T, P> Result(static_cast<T>(1));
tmat2x4<T, P> Result(static_cast<T>(1));
Result[0][0] = v[0];
Result[1][1] = v[1];
return Result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x2<T, P> diagonal3x2
GLM_FUNC_QUALIFIER tmat3x2<T, P> diagonal3x2
(
detail::tvec2<T, P> const & v
tvec2<T, P> const & v
)
{
detail::tmat3x2<T, P> Result(static_cast<T>(1));
tmat3x2<T, P> Result(static_cast<T>(1));
Result[0][0] = v[0];
Result[1][1] = v[1];
return Result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> diagonal3x3
GLM_FUNC_QUALIFIER tmat3x3<T, P> diagonal3x3
(
detail::tvec3<T, P> const & v
tvec3<T, P> const & v
)
{
detail::tmat3x3<T, P> Result(static_cast<T>(1));
tmat3x3<T, P> Result(static_cast<T>(1));
Result[0][0] = v[0];
Result[1][1] = v[1];
Result[2][2] = v[2];
@@ -71,12 +94,12 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x4<T, P> diagonal3x4
GLM_FUNC_QUALIFIER tmat3x4<T, P> diagonal3x4
(
detail::tvec3<T, P> const & v
tvec3<T, P> const & v
)
{
detail::tmat3x4<T, P> Result(static_cast<T>(1));
tmat3x4<T, P> Result(static_cast<T>(1));
Result[0][0] = v[0];
Result[1][1] = v[1];
Result[2][2] = v[2];
@@ -84,12 +107,12 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> diagonal4x4
GLM_FUNC_QUALIFIER tmat4x4<T, P> diagonal4x4
(
detail::tvec4<T, P> const & v
tvec4<T, P> const & v
)
{
detail::tmat4x4<T, P> Result(static_cast<T>(1));
tmat4x4<T, P> Result(static_cast<T>(1));
Result[0][0] = v[0];
Result[1][1] = v[1];
Result[2][2] = v[2];
@@ -98,12 +121,12 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x3<T, P> diagonal4x3
GLM_FUNC_QUALIFIER tmat4x3<T, P> diagonal4x3
(
detail::tvec3<T, P> const & v
tvec3<T, P> const & v
)
{
detail::tmat4x3<T, P> Result(static_cast<T>(1));
tmat4x3<T, P> Result(static_cast<T>(1));
Result[0][0] = v[0];
Result[1][1] = v[1];
Result[2][2] = v[2];
@@ -111,12 +134,12 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x2<T, P> diagonal4x2
GLM_FUNC_QUALIFIER tmat4x2<T, P> diagonal4x2
(
detail::tvec2<T, P> const & v
tvec2<T, P> const & v
)
{
detail::tmat4x2<T, P> Result(static_cast<T>(1));
tmat4x2<T, P> Result(static_cast<T>(1));
Result[0][0] = v[0];
Result[1][1] = v[1];
return Result;
common/glm/glm/gtx/matrix_query.hpp
+11 -10
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -36,8 +40,7 @@
/// <glm/gtx/matrix_query.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_matrix_query
#define GLM_GTX_matrix_query
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -56,17 +59,17 @@ namespace glm
/// Return whether a matrix a null matrix.
/// From GLM_GTX_matrix_query extension.
template<typename T, precision P>
GLM_FUNC_DECL bool isNull(detail::tmat2x2<T, P> const & m, T const & epsilon);
GLM_FUNC_DECL bool isNull(tmat2x2<T, P> const & m, T const & epsilon);
/// Return whether a matrix a null matrix.
/// From GLM_GTX_matrix_query extension.
template<typename T, precision P>
GLM_FUNC_DECL bool isNull(detail::tmat3x3<T, P> const & m, T const & epsilon);
GLM_FUNC_DECL bool isNull(tmat3x3<T, P> const & m, T const & epsilon);
/// Return whether a matrix is a null matrix.
/// From GLM_GTX_matrix_query extension.
template<typename T, precision P>
GLM_FUNC_DECL bool isNull(detail::tmat4x4<T, P> const & m, T const & epsilon);
GLM_FUNC_DECL bool isNull(tmat4x4<T, P> const & m, T const & epsilon);
/// Return whether a matrix is an identity matrix.
/// From GLM_GTX_matrix_query extension.
@@ -76,17 +79,17 @@ namespace glm
/// Return whether a matrix is a normalized matrix.
/// From GLM_GTX_matrix_query extension.
template<typename T, precision P>
GLM_FUNC_DECL bool isNormalized(detail::tmat2x2<T, P> const & m, T const & epsilon);
GLM_FUNC_DECL bool isNormalized(tmat2x2<T, P> const & m, T const & epsilon);
/// Return whether a matrix is a normalized matrix.
/// From GLM_GTX_matrix_query extension.
template<typename T, precision P>
GLM_FUNC_DECL bool isNormalized(detail::tmat3x3<T, P> const & m, T const & epsilon);
GLM_FUNC_DECL bool isNormalized(tmat3x3<T, P> const & m, T const & epsilon);
/// Return whether a matrix is a normalized matrix.
/// From GLM_GTX_matrix_query extension.
template<typename T, precision P>
GLM_FUNC_DECL bool isNormalized(detail::tmat4x4<T, P> const & m, T const & epsilon);
GLM_FUNC_DECL bool isNormalized(tmat4x4<T, P> const & m, T const & epsilon);
/// Return whether a matrix is an orthonormalized matrix.
/// From GLM_GTX_matrix_query extension.
@@ -97,5 +100,3 @@ namespace glm
}//namespace glm
#include "matrix_query.inl"
#endif//GLM_GTX_matrix_query
common/glm/glm/gtx/matrix_query.inl
+59 -39
View File
@@ -1,40 +1,60 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2007-03-05
// Updated : 2007-03-05
// Licence : This source is under MIT License
// File : glm/gtx/matrix_query.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
// Dependency:
// - GLM core
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_matrix_query
/// @file glm/gtx/matrix_query.inl
/// @date 2007-03-05 / 2007-03-05
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
template<typename T, precision P>
GLM_FUNC_QUALIFIER bool isNull(detail::tmat2x2<T, P> const & m, T const & epsilon)
GLM_FUNC_QUALIFIER bool isNull(tmat2x2<T, P> const & m, T const & epsilon)
{
bool result = true;
for(length_t i = 0; result && i < 2 ; ++i)
for(detail::component_count_t i = 0; result && i < 2 ; ++i)
result = isNull(m[i], epsilon);
return result;
}
template<typename T, precision P>
GLM_FUNC_QUALIFIER bool isNull(detail::tmat3x3<T, P> const & m, T const & epsilon)
GLM_FUNC_QUALIFIER bool isNull(tmat3x3<T, P> const & m, T const & epsilon)
{
bool result = true;
for(length_t i = 0; result && i < 3 ; ++i)
for(detail::component_count_t i = 0; result && i < 3 ; ++i)
result = isNull(m[i], epsilon);
return result;
}
template<typename T, precision P>
GLM_FUNC_QUALIFIER bool isNull(detail::tmat4x4<T, P> const & m, T const & epsilon)
GLM_FUNC_QUALIFIER bool isNull(tmat4x4<T, P> const & m, T const & epsilon)
{
bool result = true;
for(length_t i = 0; result && i < 4 ; ++i)
for(detail::component_count_t i = 0; result && i < 4 ; ++i)
result = isNull(m[i], epsilon);
return result;
}
@@ -43,28 +63,28 @@ namespace glm
GLM_FUNC_QUALIFIER bool isIdentity(matType<T, P> const & m, T const & epsilon)
{
bool result = true;
for(length_t i(0); result && i < m[0].length(); ++i)
for(detail::component_count_t i(0); result && i < detail::component_count(m[0]); ++i)
{
for(length_t j(0); result && j < i ; ++j)
for(detail::component_count_t j(0); result && j < i ; ++j)
result = abs(m[i][j]) <= epsilon;
if(result)
result = abs(m[i][i] - 1) <= epsilon;
for(length_t j(i + 1); result && j < m.length(); ++j)
for(detail::component_count_t j(i + 1); result && j < detail::component_count(m); ++j)
result = abs(m[i][j]) <= epsilon;
}
return result;
}
template<typename T, precision P>
GLM_FUNC_QUALIFIER bool isNormalized(detail::tmat2x2<T, P> const & m, T const & epsilon)
GLM_FUNC_QUALIFIER bool isNormalized(tmat2x2<T, P> const & m, T const & epsilon)
{
bool result(true);
for(length_t i(0); result && i < m.length(); ++i)
for(detail::component_count_t i(0); result && i < detail::component_count(m); ++i)
result = isNormalized(m[i], epsilon);
for(length_t i(0); result && i < m.length(); ++i)
for(detail::component_count_t i(0); result && i < detail::component_count(m); ++i)
{
typename detail::tmat2x2<T, P>::col_type v;
for(length_t j(0); j < m.length(); ++j)
typename tmat2x2<T, P>::col_type v;
for(detail::component_count_t j(0); j < detail::component_count(m); ++j)
v[j] = m[j][i];
result = isNormalized(v, epsilon);
}
@@ -72,15 +92,15 @@ namespace glm
}
template<typename T, precision P>
GLM_FUNC_QUALIFIER bool isNormalized(detail::tmat3x3<T, P> const & m, T const & epsilon)
GLM_FUNC_QUALIFIER bool isNormalized(tmat3x3<T, P> const & m, T const & epsilon)
{
bool result(true);
for(length_t i(0); result && i < m.length(); ++i)
for(detail::component_count_t i(0); result && i < detail::component_count(m); ++i)
result = isNormalized(m[i], epsilon);
for(length_t i(0); result && i < m.length(); ++i)
for(detail::component_count_t i(0); result && i < detail::component_count(m); ++i)
{
typename detail::tmat3x3<T, P>::col_type v;
for(length_t j(0); j < m.length(); ++j)
typename tmat3x3<T, P>::col_type v;
for(detail::component_count_t j(0); j < detail::component_count(m); ++j)
v[j] = m[j][i];
result = isNormalized(v, epsilon);
}
@@ -88,15 +108,15 @@ namespace glm
}
template<typename T, precision P>
GLM_FUNC_QUALIFIER bool isNormalized(detail::tmat4x4<T, P> const & m, T const & epsilon)
GLM_FUNC_QUALIFIER bool isNormalized(tmat4x4<T, P> const & m, T const & epsilon)
{
bool result(true);
for(length_t i(0); result && i < m.length(); ++i)
for(detail::component_count_t i(0); result && i < detail::component_count(m); ++i)
result = isNormalized(m[i], epsilon);
for(length_t i(0); result && i < m.length(); ++i)
for(detail::component_count_t i(0); result && i < detail::component_count(m); ++i)
{
typename detail::tmat4x4<T, P>::col_type v;
for(length_t j(0); j < m.length(); ++j)
typename tmat4x4<T, P>::col_type v;
for(detail::component_count_t j(0); j < detail::component_count(m); ++j)
v[j] = m[j][i];
result = isNormalized(v, epsilon);
}
@@ -107,15 +127,15 @@ namespace glm
GLM_FUNC_QUALIFIER bool isOrthogonal(matType<T, P> const & m, T const & epsilon)
{
bool result(true);
for(length_t i(0); result && i < m.length() - 1; ++i)
for(length_t j(i + 1); result && j < m.length(); ++j)
for(detail::component_count_t i(0); result && i < detail::component_count(m) - 1; ++i)
for(detail::component_count_t j(i + 1); result && j < detail::component_count(m); ++j)
result = areOrthogonal(m[i], m[j], epsilon);
if(result)
{
matType<T, P> tmp = transpose(m);
for(length_t i(0); result && i < m.length() - 1 ; ++i)
for(length_t j(i + 1); result && j < m.length(); ++j)
for(detail::component_count_t i(0); result && i < detail::component_count(m) - 1 ; ++i)
for(detail::component_count_t j(i + 1); result && j < detail::component_count(m); ++j)
result = areOrthogonal(tmp[i], tmp[j], epsilon);
}
return result;
common/glm/glm/gtx/matrix_transform_2d.hpp
+20 -19
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -35,8 +39,7 @@
/// <glm/gtx/matrix_transform_2d.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_matrix_transform_2d
#define GLM_GTX_matrix_transform_2d
#pragma once
// Dependency:
#include "../mat3x3.hpp"
@@ -57,49 +60,47 @@ namespace glm
/// @param m Input matrix multiplied by this translation matrix.
/// @param v Coordinates of a translation vector.
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> translate(
detail::tmat3x3<T, P> const & m,
detail::tvec2<T, P> const & v);
GLM_FUNC_QUALIFIER tmat3x3<T, P> translate(
tmat3x3<T, P> const & m,
tvec2<T, P> const & v);
/// Builds a rotation 3 * 3 matrix created from an angle.
///
/// @param m Input matrix multiplied by this translation matrix.
/// @param angle Rotation angle expressed in radians if GLM_FORCE_RADIANS is defined or degrees otherwise.
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> rotate(
detail::tmat3x3<T, P> const & m,
T const & angle);
GLM_FUNC_QUALIFIER tmat3x3<T, P> rotate(
tmat3x3<T, P> const & m,
T angle);
/// Builds a scale 3 * 3 matrix created from a vector of 2 components.
///
/// @param m Input matrix multiplied by this translation matrix.
/// @param v Coordinates of a scale vector.
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> scale(
detail::tmat3x3<T, P> const & m,
detail::tvec2<T, P> const & v);
GLM_FUNC_QUALIFIER tmat3x3<T, P> scale(
tmat3x3<T, P> const & m,
tvec2<T, P> const & v);
/// Builds an horizontal (parallel to the x axis) shear 3 * 3 matrix.
///
/// @param m Input matrix multiplied by this translation matrix.
/// @param y Shear factor.
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> shearX(
detail::tmat3x3<T, P> const & m,
T const & y);
GLM_FUNC_QUALIFIER tmat3x3<T, P> shearX(
tmat3x3<T, P> const & m,
T y);
/// Builds a vertical (parallel to the y axis) shear 3 * 3 matrix.
///
/// @param m Input matrix multiplied by this translation matrix.
/// @param x Shear factor.
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> shearY(
detail::tmat3x3<T, P> const & m,
T const & x);
GLM_FUNC_QUALIFIER tmat3x3<T, P> shearY(
tmat3x3<T, P> const & m,
T x);
/// @}
}//namespace glm
#include "matrix_transform_2d.inl"
#endif//GLM_GTX_matrix_transform_2d
common/glm/glm/gtx/matrix_transform_2d.inl
+27 -27
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -32,30 +36,26 @@ namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> translate(
detail::tmat3x3<T, P> const & m,
detail::tvec2<T, P> const & v)
GLM_FUNC_QUALIFIER tmat3x3<T, P> translate(
tmat3x3<T, P> const & m,
tvec2<T, P> const & v)
{
detail::tmat3x3<T, P> Result(m);
tmat3x3<T, P> Result(m);
Result[2] = m[0] * v[0] + m[1] * v[1] + m[2];
return Result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> rotate(
detail::tmat3x3<T, P> const & m,
T const & angle)
GLM_FUNC_QUALIFIER tmat3x3<T, P> rotate(
tmat3x3<T, P> const & m,
T angle)
{
#ifdef GLM_FORCE_RADIANS
T a = angle;
#else
T a = radians(angle);
#endif
T c = cos(a);
T s = sin(a);
T const a = angle;
T const c = cos(a);
T const s = sin(a);
detail::tmat3x3<T, P> Result(detail::tmat3x3<T, P>::_null);
tmat3x3<T, P> Result(uninitialize);
Result[0] = m[0] * c + m[1] * s;
Result[1] = m[0] * -s + m[1] * c;
Result[2] = m[2];
@@ -63,11 +63,11 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> scale(
detail::tmat3x3<T, P> const & m,
detail::tvec2<T, P> const & v)
GLM_FUNC_QUALIFIER tmat3x3<T, P> scale(
tmat3x3<T, P> const & m,
tvec2<T, P> const & v)
{
detail::tmat3x3<T, P> Result(detail::tmat3x3<T, P>::_null);
tmat3x3<T, P> Result(uninitialize);
Result[0] = m[0] * v[0];
Result[1] = m[1] * v[1];
Result[2] = m[2];
@@ -75,21 +75,21 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> shearX(
detail::tmat3x3<T, P> const & m,
T const & y)
GLM_FUNC_QUALIFIER tmat3x3<T, P> shearX(
tmat3x3<T, P> const & m,
T y)
{
detail::tmat3x3<T, P> Result();
tmat3x3<T, P> Result(1);
Result[0][1] = y;
return m * Result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> shearY(
detail::tmat3x3<T, P> const & m,
T const & x)
GLM_FUNC_QUALIFIER tmat3x3<T, P> shearY(
tmat3x3<T, P> const & m,
T x)
{
detail::tmat3x3<T, P> Result();
tmat3x3<T, P> Result(1);
Result[1][0] = x;
return m * Result;
}
common/glm/glm/gtx/mixed_product.hpp
+8 -7
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -35,8 +39,7 @@
/// <glm/gtx/mixed_product.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_mixed_product
#define GLM_GTX_mixed_product
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -53,13 +56,11 @@ namespace glm
/// @brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension)
template <typename T, precision P>
GLM_FUNC_DECL T mixedProduct(
detail::tvec3<T, P> const & v1,
detail::tvec3<T, P> const & v2,
detail::tvec3<T, P> const & v3);
tvec3<T, P> const & v1,
tvec3<T, P> const & v2,
tvec3<T, P> const & v3);
/// @}
}// namespace glm
#include "mixed_product.inl"
#endif//GLM_GTX_mixed_product
common/glm/glm/gtx/mixed_product.inl
+34 -11
View File
@@ -1,20 +1,43 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2007-04-03
// Updated : 2008-09-17
// Licence : This source is under MIT License
// File : glm/gtx/mixed_product.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_mixed_product
/// @file glm/gtx/mixed_product.inl
/// @date 2007-04-03 / 2008-09-17
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER T mixedProduct
(
detail::tvec3<T, P> const & v1,
detail::tvec3<T, P> const & v2,
detail::tvec3<T, P> const & v3
tvec3<T, P> const & v1,
tvec3<T, P> const & v2,
tvec3<T, P> const & v3
)
{
return dot(cross(v1, v2), v3);
common/glm/glm/gtx/multiple.hpp
+37 -14
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -36,15 +40,12 @@
/// <glm/gtx/multiple.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_multiple
#define GLM_GTX_multiple
#pragma once
// Dependency:
#include "../glm.hpp"
#include "../gtc/round.hpp"
#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
# pragma message("GLM: GLM_GTX_multiple extension included")
#endif
#pragma message("GLM: GLM_GTX_multiple extension is deprecated, use GLM_GTC_round instead.")
namespace glm
{
@@ -59,9 +60,21 @@ namespace glm
///
/// @see gtx_multiple
template <typename genType>
GLM_FUNC_DECL genType higherMultiple(
genType const & Source,
genType const & Multiple);
GLM_DEPRECATED GLM_FUNC_DECL genType higherMultiple(
genType Source,
genType Multiple);
/// Higher multiple number of Source.
///
/// @tparam genType Floating-point or integer scalar or vector types.
/// @param Source
/// @param Multiple Must be a null or positive value
///
/// @see gtx_multiple
template <typename T, precision P, template <typename, precision> class vecType>
GLM_DEPRECATED GLM_FUNC_DECL vecType<T, P> higherMultiple(
vecType<T, P> const & Source,
vecType<T, P> const & Multiple);
/// Lower multiple number of Source.
///
@@ -71,13 +84,23 @@ namespace glm
///
/// @see gtx_multiple
template <typename genType>
GLM_FUNC_DECL genType lowerMultiple(
genType const & Source,
genType const & Multiple);
GLM_DEPRECATED GLM_FUNC_DECL genType lowerMultiple(
genType Source,
genType Multiple);
/// Lower multiple number of Source.
///
/// @tparam genType Floating-point or integer scalar or vector types.
/// @param Source
/// @param Multiple Must be a null or positive value
///
/// @see gtx_multiple
template <typename T, precision P, template <typename, precision> class vecType>
GLM_DEPRECATED GLM_FUNC_DECL vecType<T, P> lowerMultiple(
vecType<T, P> const & Source,
vecType<T, P> const & Multiple);
/// @}
}//namespace glm
#include "multiple.inl"
#endif//GLM_GTX_multiple
common/glm/glm/gtx/multiple.inl
+42 -130
View File
@@ -1,152 +1,64 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2009-10-26
// Updated : 2011-06-07
// Licence : This source is under MIT License
// File : glm/gtx/multiple.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
// Dependency:
// - GLM core
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_multiple
/// @file glm/gtx/multiple.inl
/// @date 2009-10-26 / 2011-06-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace detail
namespace glm
{
template <bool Signed>
struct higherMultiple
{
template <typename genType>
GLM_FUNC_QUALIFIER genType operator()
(
genType const & Source,
genType const & Multiple
)
{
if (Source > genType(0))
{
genType Tmp = Source - genType(1);
return Tmp + (Multiple - (Tmp % Multiple));
}
else
return Source + (-Source % Multiple);
}
};
template <>
struct higherMultiple<false>
{
template <typename genType>
GLM_FUNC_QUALIFIER genType operator()
(
genType const & Source,
genType const & Multiple
)
{
genType Tmp = Source - genType(1);
return Tmp + (Multiple - (Tmp % Multiple));
}
};
}//namespace detail
//////////////////////
// higherMultiple
template <typename genType>
GLM_FUNC_QUALIFIER genType higherMultiple
(
genType const & Source,
genType const & Multiple
)
GLM_FUNC_QUALIFIER genType higherMultiple(genType Source, genType Multiple)
{
detail::higherMultiple<std::numeric_limits<genType>::is_signed> Compute;
return Compute(Source, Multiple);
return detail::compute_ceilMultiple<std::numeric_limits<genType>::is_iec559, std::numeric_limits<genType>::is_signed>::call(Source, Multiple);
}
template <>
GLM_FUNC_QUALIFIER float higherMultiple
(
float const & Source,
float const & Multiple
)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> higherMultiple(vecType<T, P> const & Source, vecType<T, P> const & Multiple)
{
if (Source > float(0))
{
float Tmp = Source - float(1);
return Tmp + (Multiple - std::fmod(Tmp, Multiple));
}
else
return Source + std::fmod(-Source, Multiple);
return detail::functor2<T, P, vecType>::call(higherMultiple, Source, Multiple);
}
template <>
GLM_FUNC_QUALIFIER double higherMultiple
(
double const & Source,
double const & Multiple
)
{
if (Source > double(0))
{
double Tmp = Source - double(1);
return Tmp + (Multiple - std::fmod(Tmp, Multiple));
}
else
return Source + std::fmod(-Source, Multiple);
}
VECTORIZE_VEC_VEC(higherMultiple)
//////////////////////
// lowerMultiple
template <typename genType>
GLM_FUNC_QUALIFIER genType lowerMultiple
(
genType const & Source,
genType const & Multiple
)
GLM_FUNC_QUALIFIER genType lowerMultiple(genType Source, genType Multiple)
{
if (Source >= genType(0))
return Source - Source % Multiple;
else
{
genType Tmp = Source + genType(1);
return Tmp - Tmp % Multiple - Multiple;
}
return detail::compute_floorMultiple<std::numeric_limits<genType>::is_iec559, std::numeric_limits<genType>::is_signed>::call(Source, Multiple);
}
template <>
GLM_FUNC_QUALIFIER float lowerMultiple
(
float const & Source,
float const & Multiple
)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<T, P> lowerMultiple(vecType<T, P> const & Source, vecType<T, P> const & Multiple)
{
if (Source >= float(0))
return Source - std::fmod(Source, Multiple);
else
{
float Tmp = Source + float(1);
return Tmp - std::fmod(Tmp, Multiple) - Multiple;
}
return detail::functor2<T, P, vecType>::call(lowerMultiple, Source, Multiple);
}
template <>
GLM_FUNC_QUALIFIER double lowerMultiple
(
double const & Source,
double const & Multiple
)
{
if (Source >= double(0))
return Source - std::fmod(Source, Multiple);
else
{
double Tmp = Source + double(1);
return Tmp - std::fmod(Tmp, Multiple) - Multiple;
}
}
VECTORIZE_VEC_VEC(lowerMultiple)
}//namespace glm
common/glm/glm/gtx/noise.hpp
-29
View File
@@ -1,29 +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.
///////////////////////////////////////////////////////////////////////////////////
#if(defined(GLM_MESSAGES))
# pragma message("GLM: GLM_GTX_random extension is deprecated, include GLM_GTC_random (glm/gtc/noise.hpp) instead")
#endif
// Promoted:
#include "../gtc/noise.hpp"
common/glm/glm/gtx/norm.hpp
+14 -13
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -36,8 +40,7 @@
/// <glm/gtx/norm.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_norm
#define GLM_GTX_norm
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -82,46 +85,44 @@ namespace glm
//! From GLM_GTX_norm extension.
template <typename T, precision P>
GLM_FUNC_DECL T l1Norm(
detail::tvec3<T, P> const & x,
detail::tvec3<T, P> const & y);
tvec3<T, P> const & x,
tvec3<T, P> const & y);
//! Returns the L1 norm of v.
//! From GLM_GTX_norm extension.
template <typename T, precision P>
GLM_FUNC_DECL T l1Norm(
detail::tvec3<T, P> const & v);
tvec3<T, P> const & v);
//! Returns the L2 norm between x and y.
//! From GLM_GTX_norm extension.
template <typename T, precision P>
GLM_FUNC_DECL T l2Norm(
detail::tvec3<T, P> const & x,
detail::tvec3<T, P> const & y);
tvec3<T, P> const & x,
tvec3<T, P> const & y);
//! Returns the L2 norm of v.
//! From GLM_GTX_norm extension.
template <typename T, precision P>
GLM_FUNC_DECL T l2Norm(
detail::tvec3<T, P> const & x);
tvec3<T, P> const & x);
//! Returns the L norm between x and y.
//! From GLM_GTX_norm extension.
template <typename T, precision P>
GLM_FUNC_DECL T lxNorm(
detail::tvec3<T, P> const & x,
detail::tvec3<T, P> const & y,
tvec3<T, P> const & x,
tvec3<T, P> const & y,
unsigned int Depth);
//! Returns the L norm of v.
//! From GLM_GTX_norm extension.
template <typename T, precision P>
GLM_FUNC_DECL T lxNorm(
detail::tvec3<T, P> const & x,
tvec3<T, P> const & x,
unsigned int Depth);
/// @}
}//namespace glm
#include "norm.inl"
#endif//GLM_GTX_norm
common/glm/glm/gtx/norm.inl
+49 -26
View File
@@ -1,11 +1,34 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2005-12-21
// Updated : 2008-07-24
// Licence : This source is under MIT License
// File : glm/gtx/norm.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_norm
/// @file glm/gtx/norm.inl
/// @date 2005-12-21 / 2008-07-24
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
@@ -21,7 +44,7 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER T length2
(
detail::tvec2<T, P> const & x
tvec2<T, P> const & x
)
{
return dot(x, x);
@@ -30,7 +53,7 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER T length2
(
detail::tvec3<T, P> const & x
tvec3<T, P> const & x
)
{
return dot(x, x);
@@ -39,7 +62,7 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER T length2
(
detail::tvec4<T, P> const & x
tvec4<T, P> const & x
)
{
return dot(x, x);
@@ -58,8 +81,8 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER T distance2
(
detail::tvec2<T, P> const & p0,
detail::tvec2<T, P> const & p1
tvec2<T, P> const & p0,
tvec2<T, P> const & p1
)
{
return length2(p1 - p0);
@@ -68,8 +91,8 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER T distance2
(
detail::tvec3<T, P> const & p0,
detail::tvec3<T, P> const & p1
tvec3<T, P> const & p0,
tvec3<T, P> const & p1
)
{
return length2(p1 - p0);
@@ -78,8 +101,8 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER T distance2
(
detail::tvec4<T, P> const & p0,
detail::tvec4<T, P> const & p1
tvec4<T, P> const & p0,
tvec4<T, P> const & p1
)
{
return length2(p1 - p0);
@@ -88,8 +111,8 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER T l1Norm
(
detail::tvec3<T, P> const & a,
detail::tvec3<T, P> const & b
tvec3<T, P> const & a,
tvec3<T, P> const & b
)
{
return abs(b.x - a.x) + abs(b.y - a.y) + abs(b.z - a.z);
@@ -98,7 +121,7 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER T l1Norm
(
detail::tvec3<T, P> const & v
tvec3<T, P> const & v
)
{
return abs(v.x) + abs(v.y) + abs(v.z);
@@ -107,8 +130,8 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER T l2Norm
(
detail::tvec3<T, P> const & a,
detail::tvec3<T, P> const & b
tvec3<T, P> const & a,
tvec3<T, P> const & b
)
{
return length(b - a);
@@ -117,7 +140,7 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER T l2Norm
(
detail::tvec3<T, P> const & v
tvec3<T, P> const & v
)
{
return length(v);
@@ -126,8 +149,8 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER T lxNorm
(
detail::tvec3<T, P> const & x,
detail::tvec3<T, P> const & y,
tvec3<T, P> const & x,
tvec3<T, P> const & y,
unsigned int Depth
)
{
@@ -137,7 +160,7 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER T lxNorm
(
detail::tvec3<T, P> const & v,
tvec3<T, P> const & v,
unsigned int Depth
)
{
common/glm/glm/gtx/normal.hpp
+9 -8
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -36,8 +40,7 @@
/// <glm/gtx/normal.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_normal
#define GLM_GTX_normal
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -54,14 +57,12 @@ namespace glm
//! Computes triangle normal from triangle points.
//! From GLM_GTX_normal extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> triangleNormal(
detail::tvec3<T, P> const & p1,
detail::tvec3<T, P> const & p2,
detail::tvec3<T, P> const & p3);
GLM_FUNC_DECL tvec3<T, P> triangleNormal(
tvec3<T, P> const & p1,
tvec3<T, P> const & p2,
tvec3<T, P> const & p3);
/// @}
}//namespace glm
#include "normal.inl"
#endif//GLM_GTX_normal
common/glm/glm/gtx/normal.inl
+35 -12
View File
@@ -1,20 +1,43 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2005-12-21
// Updated : 2011-06-07
// Licence : This source is under MIT License
// File : glm/gtx/normal.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_normal
/// @file glm/gtx/normal.inl
/// @date 2005-12-21 / 2011-06-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> triangleNormal
GLM_FUNC_QUALIFIER tvec3<T, P> triangleNormal
(
detail::tvec3<T, P> const & p1,
detail::tvec3<T, P> const & p2,
detail::tvec3<T, P> const & p3
tvec3<T, P> const & p1,
tvec3<T, P> const & p2,
tvec3<T, P> const & p3
)
{
return normalize(cross(p1 - p2, p1 - p3));
common/glm/glm/gtx/normalize_dot.hpp
+17 -19
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -36,11 +40,9 @@
/// <glm/gtx/normalized_dot.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_normalize_dot
#define GLM_GTX_normalize_dot
#pragma once
// Dependency:
#include "../glm.hpp"
#include "../gtx/fast_square_root.hpp"
#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
@@ -52,25 +54,21 @@ namespace glm
/// @addtogroup gtx_normalize_dot
/// @{
//! Normalize parameters and returns the dot product of x and y.
//! It's faster that dot(normalize(x), normalize(y)).
//! From GLM_GTX_normalize_dot extension.
template <typename genType>
GLM_FUNC_DECL typename genType::value_type normalizeDot(
genType const & x,
genType const & y);
/// Normalize parameters and returns the dot product of x and y.
/// It's faster that dot(normalize(x), normalize(y)).
///
/// @see gtx_normalize_dot extension.
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL T normalizeDot(vecType<T, P> const & x, vecType<T, P> const & y);
//! Normalize parameters and returns the dot product of x and y.
//! Faster that dot(fastNormalize(x), fastNormalize(y)).
//! From GLM_GTX_normalize_dot extension.
template <typename genType>
GLM_FUNC_DECL typename genType::value_type fastNormalizeDot(
genType const & x,
genType const & y);
/// Normalize parameters and returns the dot product of x and y.
/// Faster that dot(fastNormalize(x), fastNormalize(y)).
///
/// @see gtx_normalize_dot extension.
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL T fastNormalizeDot(vecType<T, P> const & x, vecType<T, P> const & y);
/// @}
}//namespace glm
#include "normalize_dot.inl"
#endif//GLM_GTX_normalize_dot
common/glm/glm/gtx/normalize_dot.inl
+36 -105
View File
@@ -1,115 +1,46 @@
//////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
//////////////////////////////////////////////////////////////////////////////////
// Created : 2007-09-28
// Updated : 2008-10-07
// Licence : This source is under MIT License
// File : glm/gtx/normalize_dot.inl
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_normalize_dot
/// @file glm/gtx/normalize_dot.inl
/// @date 2007-09-28 / 2008-10-07
/// @author Christophe Riccio
//////////////////////////////////////////////////////////////////////////////////
namespace glm
{
template <typename genType>
GLM_FUNC_QUALIFIER genType normalizeDot
(
genType const & x,
genType const & y
)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER T normalizeDot(vecType<T, P> const & x, vecType<T, P> const & y)
{
return
glm::dot(x, y) *
glm::inversesqrt(glm::dot(x, x) *
glm::dot(y, y));
return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER T normalizeDot
(
detail::tvec2<T, P> const & x,
detail::tvec2<T, P> const & y
)
template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_QUALIFIER T fastNormalizeDot(vecType<T, P> const & x, vecType<T, P> const & y)
{
return
glm::dot(x, y) *
glm::inversesqrt(glm::dot(x, x) *
glm::dot(y, y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER T normalizeDot
(
detail::tvec3<T, P> const & x,
detail::tvec3<T, P> const & y
)
{
return
glm::dot(x, y) *
glm::inversesqrt(glm::dot(x, x) *
glm::dot(y, y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER T normalizeDot
(
detail::tvec4<T, P> const & x,
detail::tvec4<T, P> const & y
)
{
return
glm::dot(x, y) *
glm::inversesqrt(glm::dot(x, x) *
glm::dot(y, y));
}
template <typename genType>
GLM_FUNC_QUALIFIER genType fastNormalizeDot
(
genType const & x,
genType const & y
)
{
return
glm::dot(x, y) *
fastInverseSqrt(glm::dot(x, x) *
glm::dot(y, y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER T fastNormalizeDot
(
detail::tvec2<T, P> const & x,
detail::tvec2<T, P> const & y
)
{
return
glm::dot(x, y) *
fastInverseSqrt(glm::dot(x, x) *
glm::dot(y, y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER T fastNormalizeDot
(
detail::tvec3<T, P> const & x,
detail::tvec3<T, P> const & y
)
{
return
glm::dot(x, y) *
fastInverseSqrt(glm::dot(x, x) *
glm::dot(y, y));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER T fastNormalizeDot
(
detail::tvec4<T, P> const & x,
detail::tvec4<T, P> const & y
)
{
return
glm::dot(x, y) *
fastInverseSqrt(glm::dot(x, x) *
glm::dot(y, y));
return glm::dot(x, y) * glm::fastInverseSqrt(glm::dot(x, x) * glm::dot(y, y));
}
}//namespace glm
common/glm/glm/gtx/number_precision.hpp
+5 -4
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -37,8 +41,7 @@
/// <glm/gtx/number_precision.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_number_precision
#define GLM_GTX_number_precision
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -81,5 +84,3 @@ namespace gtx
}//namespace glm
#include "number_precision.inl"
#endif//GLM_GTX_number_precision
common/glm/glm/gtx/number_precision.inl
+31 -8
View File
@@ -1,11 +1,34 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2007-05-10
// Updated : 2007-05-10
// Licence : This source is under MIT License
// File : glm/gtx/number_precision.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_number_precision
/// @file glm/gtx/number_precision.inl
/// @date 2007-05-10 / 2011-06-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
common/glm/glm/gtx/optimum_pow.hpp
+17 -32
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -35,8 +39,7 @@
/// <glm/gtx/optimum_pow.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_optimum_pow
#define GLM_GTX_optimum_pow
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -51,44 +54,26 @@ namespace gtx
/// @addtogroup gtx_optimum_pow
/// @{
//! Returns x raised to the power of 2.
//! From GLM_GTX_optimum_pow extension.
/// Returns x raised to the power of 2.
///
/// @see gtx_optimum_pow
template <typename genType>
GLM_FUNC_DECL genType pow2(const genType& x);
GLM_FUNC_DECL genType pow2(genType const & x);
//! Returns x raised to the power of 3.
//! From GLM_GTX_optimum_pow extension.
/// Returns x raised to the power of 3.
///
/// @see gtx_optimum_pow
template <typename genType>
GLM_FUNC_DECL genType pow3(const genType& x);
GLM_FUNC_DECL genType pow3(genType const & x);
//! Returns x raised to the power of 4.
//! From GLM_GTX_optimum_pow extension.
/// Returns x raised to the power of 4.
///
/// @see gtx_optimum_pow
template <typename genType>
GLM_FUNC_DECL genType pow4(const genType& x);
//! Checks if the parameter is a power of 2 number.
//! From GLM_GTX_optimum_pow extension.
GLM_FUNC_DECL bool powOfTwo(int num);
//! Checks to determine if the parameter component are power of 2 numbers.
//! From GLM_GTX_optimum_pow extension.
template <precision P>
GLM_FUNC_DECL detail::tvec2<bool, P> powOfTwo(detail::tvec2<int, P> const & x);
//! Checks to determine if the parameter component are power of 2 numbers.
//! From GLM_GTX_optimum_pow extension.
template <precision P>
GLM_FUNC_DECL detail::tvec3<bool, P> powOfTwo(detail::tvec3<int, P> const & x);
//! Checks to determine if the parameter component are power of 2 numbers.
//! From GLM_GTX_optimum_pow extension.
template <precision P>
GLM_FUNC_DECL detail::tvec4<bool, P> powOfTwo(detail::tvec4<int, P> const & x);
GLM_FUNC_DECL genType pow4(genType const & x);
/// @}
}//namespace gtx
}//namespace glm
#include "optimum_pow.inl"
#endif//GLM_GTX_optimum_pow
common/glm/glm/gtx/optimum_pow.inl
+31 -40
View File
@@ -1,11 +1,34 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2005-12-21
// Updated : 2005-12-27
// Licence : This source is under MIT License
// File : glm/gtx/optimum_pow.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_optimum_pow
/// @file glm/gtx/optimum_pow.inl
/// @date 2005-12-21 / 2011-06-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
@@ -26,36 +49,4 @@ namespace glm
{
return (x * x) * (x * x);
}
GLM_FUNC_QUALIFIER bool powOfTwo(int x)
{
return !(x & (x - 1));
}
template <precision P>
GLM_FUNC_QUALIFIER detail::tvec2<bool, P> powOfTwo(detail::tvec2<int, P> const & x)
{
return detail::tvec2<bool, P>(
powOfTwo(x.x),
powOfTwo(x.y));
}
template <precision P>
GLM_FUNC_QUALIFIER detail::tvec3<bool, P> powOfTwo(detail::tvec3<int, P> const & x)
{
return detail::tvec3<bool, P>(
powOfTwo(x.x),
powOfTwo(x.y),
powOfTwo(x.z));
}
template <precision P>
GLM_FUNC_QUALIFIER detail::tvec4<bool, P> powOfTwo(detail::tvec4<int, P> const & x)
{
return detail::tvec4<bool, P>(
powOfTwo(x.x),
powOfTwo(x.y),
powOfTwo(x.z),
powOfTwo(x.w));
}
}//namespace glm
common/glm/glm/gtx/orthonormalize.hpp
+16 -14
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -36,11 +40,12 @@
/// <glm/gtx/orthonormalize.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_orthonormalize
#define GLM_GTX_orthonormalize
#pragma once
// Dependency:
#include "../glm.hpp"
#include "../vec3.hpp"
#include "../mat3x3.hpp"
#include "../geometric.hpp"
#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
# pragma message("GLM: GLM_GTX_orthonormalize extension included")
@@ -51,22 +56,19 @@ namespace glm
/// @addtogroup gtx_orthonormalize
/// @{
//! Returns the orthonormalized matrix of m.
//! From GLM_GTX_orthonormalize extension.
/// Returns the orthonormalized matrix of m.
///
/// @see gtx_orthonormalize
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> orthonormalize(
const detail::tmat3x3<T, P>& m);
GLM_FUNC_DECL tmat3x3<T, P> orthonormalize(tmat3x3<T, P> const & m);
//! Orthonormalizes x according y.
//! From GLM_GTX_orthonormalize extension.
/// Orthonormalizes x according y.
///
/// @see gtx_orthonormalize
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> orthonormalize(
const detail::tvec3<T, P>& x,
const detail::tvec3<T, P>& y);
GLM_FUNC_DECL tvec3<T, P> orthonormalize(tvec3<T, P> const & x, tvec3<T, P> const & y);
/// @}
}//namespace glm
#include "orthonormalize.inl"
#endif//GLM_GTX_orthonormalize
common/glm/glm/gtx/orthonormalize.inl
+36 -20
View File
@@ -1,29 +1,49 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2005-12-21
// Updated : 2005-12-21
// Licence : This source is under MIT License
// File : glm/gtx/orthonormalize.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_orthonormalize
/// @file glm/gtx/orthonormalize.inl
/// @date 2005-12-21 / 2011-06-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat3x3<T, P> orthonormalize
(
const detail::tmat3x3<T, P>& m
)
GLM_FUNC_QUALIFIER tmat3x3<T, P> orthonormalize(tmat3x3<T, P> const & m)
{
detail::tmat3x3<T, P> r = m;
tmat3x3<T, P> r = m;
r[0] = normalize(r[0]);
float d0 = dot(r[0], r[1]);
T d0 = dot(r[0], r[1]);
r[1] -= r[0] * d0;
r[1] = normalize(r[1]);
float d1 = dot(r[1], r[2]);
T d1 = dot(r[1], r[2]);
d0 = dot(r[0], r[2]);
r[2] -= r[0] * d0 + r[1] * d1;
r[2] = normalize(r[2]);
@@ -32,11 +52,7 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> orthonormalize
(
const detail::tvec3<T, P>& x,
const detail::tvec3<T, P>& y
)
GLM_FUNC_QUALIFIER tvec3<T, P> orthonormalize(tvec3<T, P> const & x, tvec3<T, P> const & y)
{
return normalize(x - y * dot(y, x));
}
common/glm/glm/gtx/perpendicular.hpp
+5 -4
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -36,8 +40,7 @@
/// <glm/gtx/perpendicular.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_perpendicular
#define GLM_GTX_perpendicular
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -63,5 +66,3 @@ namespace glm
}//namespace glm
#include "perpendicular.inl"
#endif//GLM_GTX_perpendicular
common/glm/glm/gtx/perpendicular.inl
+31 -8
View File
@@ -1,11 +1,34 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2005-12-21
// Updated : 2009-03-06
// Licence : This source is under MIT License
// File : glm/gtx/perpendicular.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_perpendicular
/// @file glm/gtx/perpendicular.inl
/// @date 2005-12-21 / 2011-06-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
common/glm/glm/gtx/polar_coordinates.hpp
+9 -8
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -35,8 +39,7 @@
/// <glm/gtx/polar_coordinates.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_polar_coordinates
#define GLM_GTX_polar_coordinates
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -54,19 +57,17 @@ namespace glm
///
/// @see gtx_polar_coordinates
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> polar(
detail::tvec3<T, P> const & euclidean);
GLM_FUNC_DECL tvec3<T, P> polar(
tvec3<T, P> const & euclidean);
/// Convert Polar to Euclidean coordinates.
///
/// @see gtx_polar_coordinates
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> euclidean(
detail::tvec2<T, P> const & polar);
GLM_FUNC_DECL tvec3<T, P> euclidean(
tvec2<T, P> const & polar);
/// @}
}//namespace glm
#include "polar_coordinates.inl"
#endif//GLM_GTX_polar_coordinates
common/glm/glm/gtx/polar_coordinates.inl
+38 -29
View File
@@ -1,54 +1,63 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2007-03-06
// Updated : 2009-05-01
// Licence : This source is under MIT License
// File : glm/gtx/polar_coordinates.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_polar_coordinates
/// @file glm/gtx/polar_coordinates.inl
/// @date 2007-03-06 / 2011-06-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> polar
GLM_FUNC_QUALIFIER tvec3<T, P> polar
(
detail::tvec3<T, P> const & euclidean
tvec3<T, P> const & euclidean
)
{
T const Length(length(euclidean));
detail::tvec3<T, P> const tmp(euclidean / Length);
tvec3<T, P> const tmp(euclidean / Length);
T const xz_dist(sqrt(tmp.x * tmp.x + tmp.z * tmp.z));
#ifdef GLM_FORCE_RADIANS
return detail::tvec3<T, P>(
return tvec3<T, P>(
atan(xz_dist, tmp.y), // latitude
atan(tmp.x, tmp.z), // longitude
xz_dist); // xz distance
#else
# pragma message("GLM: polar function returning degrees is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
return detail::tvec3<T, P>(
degrees(atan(xz_dist, tmp.y)), // latitude
degrees(atan(tmp.x, tmp.z)), // longitude
xz_dist); // xz distance
#endif
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> euclidean
GLM_FUNC_QUALIFIER tvec3<T, P> euclidean
(
detail::tvec2<T, P> const & polar
tvec2<T, P> const & polar
)
{
#ifdef GLM_FORCE_RADIANS
T const latitude(polar.x);
T const longitude(polar.y);
#else
# pragma message("GLM: euclidean function taking degrees as parameters is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
T const latitude(radians(polar.x));
T const longitude(radians(polar.y));
#endif
return detail::tvec3<T, P>(
return tvec3<T, P>(
cos(latitude) * sin(longitude),
sin(latitude),
cos(latitude) * cos(longitude));
common/glm/glm/gtx/projection.hpp
+11 -11
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -35,11 +39,10 @@
/// <glm/gtx/projection.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_projection
#define GLM_GTX_projection
#pragma once
// Dependency:
#include "../glm.hpp"
#include "../geometric.hpp"
#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
# pragma message("GLM: GLM_GTX_projection extension included")
@@ -50,16 +53,13 @@ namespace glm
/// @addtogroup gtx_projection
/// @{
//! Projects x on Normal.
//! From GLM_GTX_projection extension.
template <typename vecType>
GLM_FUNC_DECL vecType proj(
vecType const & x,
vecType const & Normal);
/// Projects x on Normal.
///
/// @see gtx_projection
template <typename vecType>
GLM_FUNC_DECL vecType proj(vecType const & x, vecType const & Normal);
/// @}
}//namespace glm
#include "projection.inl"
#endif//GLM_GTX_projection
common/glm/glm/gtx/projection.inl
+33 -14
View File
@@ -1,20 +1,39 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2005-12-21
// Updated : 2009-03-06
// Licence : This source is under MIT License
// File : glm/gtx/projection.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_projection
/// @file glm/gtx/projection.inl
/// @date 2005-12-21 / 2011-06-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
template <typename vecType>
GLM_FUNC_QUALIFIER vecType proj
(
vecType const & x,
vecType const & Normal
)
template <typename vecType>
GLM_FUNC_QUALIFIER vecType proj(vecType const & x, vecType const & Normal)
{
return glm::dot(x, Normal) / glm::dot(Normal, Normal) * Normal;
}
common/glm/glm/gtx/quaternion.hpp
+53 -52
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -36,8 +40,7 @@
/// <glm/gtx/quaternion.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_quaternion
#define GLM_GTX_quaternion
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -58,135 +61,135 @@ namespace glm
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> cross(
detail::tquat<T, P> const & q,
detail::tvec3<T, P> const & v);
GLM_FUNC_DECL tvec3<T, P> cross(
tquat<T, P> const & q,
tvec3<T, P> const & v);
//! Compute a cross product between a vector and a quaternion.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> cross(
detail::tvec3<T, P> const & v,
detail::tquat<T, P> const & q);
GLM_FUNC_DECL tvec3<T, P> cross(
tvec3<T, P> const & v,
tquat<T, P> const & q);
//! Compute a point on a path according squad equation.
//! q1 and q2 are control points; s1 and s2 are intermediate control points.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> squad(
detail::tquat<T, P> const & q1,
detail::tquat<T, P> const & q2,
detail::tquat<T, P> const & s1,
detail::tquat<T, P> const & s2,
GLM_FUNC_DECL tquat<T, P> squad(
tquat<T, P> const & q1,
tquat<T, P> const & q2,
tquat<T, P> const & s1,
tquat<T, P> const & s2,
T const & h);
//! Returns an intermediate control point for squad interpolation.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> intermediate(
detail::tquat<T, P> const & prev,
detail::tquat<T, P> const & curr,
detail::tquat<T, P> const & next);
GLM_FUNC_DECL tquat<T, P> intermediate(
tquat<T, P> const & prev,
tquat<T, P> const & curr,
tquat<T, P> const & next);
//! Returns a exp of a quaternion.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> exp(
detail::tquat<T, P> const & q);
GLM_FUNC_DECL tquat<T, P> exp(
tquat<T, P> const & q);
//! Returns a log of a quaternion.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> log(
detail::tquat<T, P> const & q);
GLM_FUNC_DECL tquat<T, P> log(
tquat<T, P> const & q);
/// Returns x raised to the y power.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> pow(
detail::tquat<T, P> const & x,
GLM_FUNC_DECL tquat<T, P> pow(
tquat<T, P> const & x,
T const & y);
//! Returns quarternion square root.
///
/// @see gtx_quaternion
//template<typename T, precision P>
//detail::tquat<T, P> sqrt(
// detail::tquat<T, P> const & q);
//tquat<T, P> sqrt(
// tquat<T, P> const & q);
//! Rotates a 3 components vector by a quaternion.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> rotate(
detail::tquat<T, P> const & q,
detail::tvec3<T, P> const & v);
GLM_FUNC_DECL tvec3<T, P> rotate(
tquat<T, P> const & q,
tvec3<T, P> const & v);
/// Rotates a 4 components vector by a quaternion.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tvec4<T, P> rotate(
detail::tquat<T, P> const & q,
detail::tvec4<T, P> const & v);
GLM_FUNC_DECL tvec4<T, P> rotate(
tquat<T, P> const & q,
tvec4<T, P> const & v);
/// Extract the real component of a quaternion.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL T extractRealComponent(
detail::tquat<T, P> const & q);
tquat<T, P> const & q);
/// Converts a quaternion to a 3 * 3 matrix.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tmat3x3<T, P> toMat3(
detail::tquat<T, P> const & x){return mat3_cast(x);}
GLM_FUNC_DECL tmat3x3<T, P> toMat3(
tquat<T, P> const & x){return mat3_cast(x);}
/// Converts a quaternion to a 4 * 4 matrix.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> toMat4(
detail::tquat<T, P> const & x){return mat4_cast(x);}
GLM_FUNC_DECL tmat4x4<T, P> toMat4(
tquat<T, P> const & x){return mat4_cast(x);}
/// Converts a 3 * 3 matrix to a quaternion.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> toQuat(
detail::tmat3x3<T, P> const & x){return quat_cast(x);}
GLM_FUNC_DECL tquat<T, P> toQuat(
tmat3x3<T, P> const & x){return quat_cast(x);}
/// Converts a 4 * 4 matrix to a quaternion.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> toQuat(
detail::tmat4x4<T, P> const & x){return quat_cast(x);}
GLM_FUNC_DECL tquat<T, P> toQuat(
tmat4x4<T, P> const & x){return quat_cast(x);}
/// Quaternion interpolation using the rotation short path.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> shortMix(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y,
GLM_FUNC_DECL tquat<T, P> shortMix(
tquat<T, P> const & x,
tquat<T, P> const & y,
T const & a);
/// Quaternion normalized linear interpolation.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> fastMix(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y,
GLM_FUNC_DECL tquat<T, P> fastMix(
tquat<T, P> const & x,
tquat<T, P> const & y,
T const & a);
/// Compute the rotation between two vectors.
@@ -195,19 +198,17 @@ namespace glm
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> rotation(
detail::tvec3<T, P> const & orig,
detail::tvec3<T, P> const & dest);
GLM_FUNC_DECL tquat<T, P> rotation(
tvec3<T, P> const & orig,
tvec3<T, P> const & dest);
/// Returns the squared length of x.
///
/// @see gtx_quaternion
template<typename T, precision P>
GLM_FUNC_DECL T length2(detail::tquat<T, P> const & q);
GLM_FUNC_DECL T length2(tquat<T, P> const & q);
/// @}
}//namespace glm
#include "quaternion.inl"
#endif//GLM_GTX_quaternion
common/glm/glm/gtx/quaternion.inl
+114 -85
View File
@@ -1,109 +1,138 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2005-12-21
// Updated : 2008-11-27
// Licence : This source is under MIT License
// File : glm/gtx/quaternion.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_quaternion
/// @file glm/gtx/quaternion.inl
/// @date 2005-12-21 / 2011-06-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#include <limits>
#include "../gtc/constants.hpp"
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> cross
GLM_FUNC_QUALIFIER tvec3<T, P> cross
(
detail::tvec3<T, P> const & v,
detail::tquat<T, P> const & q
tvec3<T, P> const & v,
tquat<T, P> const & q
)
{
return inverse(q) * v;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> cross
GLM_FUNC_QUALIFIER tvec3<T, P> cross
(
detail::tquat<T, P> const & q,
detail::tvec3<T, P> const & v
tquat<T, P> const & q,
tvec3<T, P> const & v
)
{
return q * v;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> squad
GLM_FUNC_QUALIFIER tquat<T, P> squad
(
detail::tquat<T, P> const & q1,
detail::tquat<T, P> const & q2,
detail::tquat<T, P> const & s1,
detail::tquat<T, P> const & s2,
tquat<T, P> const & q1,
tquat<T, P> const & q2,
tquat<T, P> const & s1,
tquat<T, P> const & s2,
T const & h)
{
return mix(mix(q1, q2, h), mix(s1, s2, h), T(2) * (T(1) - h) * h);
return mix(mix(q1, q2, h), mix(s1, s2, h), static_cast<T>(2) * (static_cast<T>(1) - h) * h);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> intermediate
GLM_FUNC_QUALIFIER tquat<T, P> intermediate
(
detail::tquat<T, P> const & prev,
detail::tquat<T, P> const & curr,
detail::tquat<T, P> const & next
tquat<T, P> const & prev,
tquat<T, P> const & curr,
tquat<T, P> const & next
)
{
detail::tquat<T, P> invQuat = inverse(curr);
return exp((log(next + invQuat) + log(prev + invQuat)) / T(-4)) * curr;
tquat<T, P> invQuat = inverse(curr);
return exp((log(next + invQuat) + log(prev + invQuat)) / static_cast<T>(-4)) * curr;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> exp
GLM_FUNC_QUALIFIER tquat<T, P> exp
(
detail::tquat<T, P> const & q
tquat<T, P> const & q
)
{
detail::tvec3<T, P> u(q.x, q.y, q.z);
float Angle = glm::length(u);
detail::tvec3<T, P> v(u / Angle);
return detail::tquat<T, P>(cos(Angle), sin(Angle) * v);
tvec3<T, P> u(q.x, q.y, q.z);
T Angle = glm::length(u);
if (Angle < epsilon<T>())
return tquat<T, P>();
tvec3<T, P> v(u / Angle);
return tquat<T, P>(cos(Angle), sin(Angle) * v);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> log
GLM_FUNC_QUALIFIER tquat<T, P> log
(
detail::tquat<T, P> const & q
tquat<T, P> const & q
)
{
if((q.x == static_cast<T>(0)) && (q.y == static_cast<T>(0)) && (q.z == static_cast<T>(0)))
tvec3<T, P> u(q.x, q.y, q.z);
T Vec3Len = length(u);
if (Vec3Len < epsilon<T>())
{
if(q.w > T(0))
return detail::tquat<T, P>(log(q.w), T(0), T(0), T(0));
else if(q.w < T(0))
return detail::tquat<T, P>(log(-q.w), T(3.1415926535897932384626433832795), T(0),T(0));
if(q.w > static_cast<T>(0))
return tquat<T, P>(log(q.w), static_cast<T>(0), static_cast<T>(0), static_cast<T>(0));
else if(q.w < static_cast<T>(0))
return tquat<T, P>(log(-q.w), pi<T>(), static_cast<T>(0), static_cast<T>(0));
else
return detail::tquat<T, P>(std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity());
return tquat<T, P>(std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity());
}
else
{
T Vec3Len = sqrt(q.x * q.x + q.y * q.y + q.z * q.z);
T QuatLen = sqrt(Vec3Len * Vec3Len + q.w * q.w);
T t = atan(Vec3Len, T(q.w)) / Vec3Len;
return detail::tquat<T, P>(t * q.x, t * q.y, t * q.z, log(QuatLen));
return tquat<T, P>(log(QuatLen), t * q.x, t * q.y, t * q.z);
}
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> pow
GLM_FUNC_QUALIFIER tquat<T, P> pow
(
detail::tquat<T, P> const & x,
tquat<T, P> const & x,
T const & y
)
{
if(abs(x.w) > T(0.9999))
if(abs(x.w) > (static_cast<T>(1) - epsilon<T>()))
return x;
float Angle = acos(y);
float NewAngle = Angle * y;
float Div = sin(NewAngle) / sin(Angle);
return detail::tquat<T, P>(
T Angle = acos(y);
T NewAngle = Angle * y;
T Div = sin(NewAngle) / sin(Angle);
return tquat<T, P>(
cos(NewAngle),
x.x * Div,
x.y * Div,
@@ -111,9 +140,9 @@ namespace glm
}
//template <typename T, precision P>
//GLM_FUNC_QUALIFIER detail::tquat<T, P> sqrt
//GLM_FUNC_QUALIFIER tquat<T, P> sqrt
//(
// detail::tquat<T, P> const & q
// tquat<T, P> const & q
//)
//{
// T q0 = static_cast<T>(1) - dot(q, q);
@@ -121,20 +150,20 @@ namespace glm
//}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> rotate
GLM_FUNC_QUALIFIER tvec3<T, P> rotate
(
detail::tquat<T, P> const & q,
detail::tvec3<T, P> const & v
tquat<T, P> const & q,
tvec3<T, P> const & v
)
{
return q * v;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> rotate
GLM_FUNC_QUALIFIER tvec4<T, P> rotate
(
detail::tquat<T, P> const & q,
detail::tvec4<T, P> const & v
tquat<T, P> const & q,
tvec4<T, P> const & v
)
{
return q * v;
@@ -143,10 +172,10 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER T extractRealComponent
(
detail::tquat<T, P> const & q
tquat<T, P> const & q
)
{
T w = static_cast<T>(1.0) - q.x * q.x - q.y * q.y - q.z * q.z;
T w = static_cast<T>(1) - q.x * q.x - q.y * q.y - q.z * q.z;
if(w < T(0))
return T(0);
else
@@ -156,26 +185,26 @@ namespace glm
template <typename T, precision P>
GLM_FUNC_QUALIFIER T length2
(
detail::tquat<T, P> const & q
tquat<T, P> const & q
)
{
return q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> shortMix
GLM_FUNC_QUALIFIER tquat<T, P> shortMix
(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y,
tquat<T, P> const & x,
tquat<T, P> const & y,
T const & a
)
{
if(a <= T(0)) return x;
if(a >= T(1)) return y;
if(a <= static_cast<T>(0)) return x;
if(a >= static_cast<T>(1)) return y;
T fCos = dot(x, y);
detail::tquat<T, P> y2(y); //BUG!!! tquat<T> y2;
if(fCos < T(0))
tquat<T, P> y2(y); //BUG!!! tquat<T> y2;
if(fCos < static_cast<T>(0))
{
y2 = -y;
fCos = -fCos;
@@ -183,7 +212,7 @@ namespace glm
//if(fCos > 1.0f) // problem
T k0, k1;
if(fCos > T(0.9999))
if(fCos > (static_cast<T>(1) - epsilon<T>()))
{
k0 = static_cast<T>(1) - a;
k1 = static_cast<T>(0) + a; //BUG!!! 1.0f + a;
@@ -193,11 +222,11 @@ namespace glm
T fSin = sqrt(T(1) - fCos * fCos);
T fAngle = atan(fSin, fCos);
T fOneOverSin = static_cast<T>(1) / fSin;
k0 = sin((T(1) - a) * fAngle) * fOneOverSin;
k1 = sin((T(0) + a) * fAngle) * fOneOverSin;
k0 = sin((static_cast<T>(1) - a) * fAngle) * fOneOverSin;
k1 = sin((static_cast<T>(0) + a) * fAngle) * fOneOverSin;
}
return detail::tquat<T, P>(
return tquat<T, P>(
k0 * x.w + k1 * y2.w,
k0 * x.x + k1 * y2.x,
k0 * x.y + k1 * y2.y,
@@ -205,36 +234,36 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> fastMix
GLM_FUNC_QUALIFIER tquat<T, P> fastMix
(
detail::tquat<T, P> const & x,
detail::tquat<T, P> const & y,
tquat<T, P> const & x,
tquat<T, P> const & y,
T const & a
)
{
return glm::normalize(x * (T(1) - a) + (y * a));
return glm::normalize(x * (static_cast<T>(1) - a) + (y * a));
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> rotation
GLM_FUNC_QUALIFIER tquat<T, P> rotation
(
detail::tvec3<T, P> const & orig,
detail::tvec3<T, P> const & dest
tvec3<T, P> const & orig,
tvec3<T, P> const & dest
)
{
T cosTheta = dot(orig, dest);
detail::tvec3<T, P> rotationAxis;
tvec3<T, P> rotationAxis;
if(cosTheta < T(-1) + epsilon<T>())
if(cosTheta < static_cast<T>(-1) + epsilon<T>())
{
// special case when vectors in opposite directions :
// there is no "ideal" rotation axis
// So guess one; any will do as long as it's perpendicular to start
// This implementation favors a rotation around the Up axis (Y),
// since it's often what you want to do.
rotationAxis = cross(detail::tvec3<T, P>(0, 0, 1), orig);
rotationAxis = cross(tvec3<T, P>(0, 0, 1), orig);
if(length2(rotationAxis) < epsilon<T>()) // bad luck, they were parallel, try again!
rotationAxis = cross(detail::tvec3<T, P>(1, 0, 0), orig);
rotationAxis = cross(tvec3<T, P>(1, 0, 0), orig);
rotationAxis = normalize(rotationAxis);
return angleAxis(pi<T>(), rotationAxis);
@@ -243,11 +272,11 @@ namespace glm
// Implementation from Stan Melax's Game Programming Gems 1 article
rotationAxis = cross(orig, dest);
T s = sqrt((T(1) + cosTheta) * T(2));
T s = sqrt((T(1) + cosTheta) * static_cast<T>(2));
T invs = static_cast<T>(1) / s;
return detail::tquat<T, P>(
s * T(0.5f),
return tquat<T, P>(
s * static_cast<T>(0.5f),
rotationAxis.x * invs,
rotationAxis.y * invs,
rotationAxis.z * invs);
common/glm/glm/gtx/random.hpp
-29
View File
@@ -1,29 +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.
///////////////////////////////////////////////////////////////////////////////////
#if(defined(GLM_MESSAGES))
# pragma message("GLM: GLM_GTX_random extension is deprecated, include GLM_GTC_random instead")
#endif
// Promoted:
#include "../gtc/random.hpp"
common/glm/glm/gtx/range.hpp
+102
View File
@@ -0,0 +1,102 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_range
/// @file glm/gtx/range.hpp
/// @date 2014-09-19 / 2014-09-19
/// @author Joshua Moerman
///
/// @defgroup gtx_range GLM_GTX_range
/// @ingroup gtx
///
/// @brief Defines begin and end for vectors and matrices. Useful for range-based for loop.
/// The range is defined over the elements, not over columns or rows (e.g. mat4 has 16 elements).
///
/// <glm/gtx/range.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#pragma once
// Dependencies
#include "../detail/setup.hpp"
#if !GLM_HAS_RANGE_FOR
# error "GLM_GTX_range requires C++11 suppport or 'range for'"
#endif
#include "../gtc/type_ptr.hpp"
namespace glm{
namespace detail
{
/* The glm types provide a .length() member, but for matrices
this only defines the number of columns, so we need to work around this */
template <typename T, precision P>
detail::component_count_t number_of_elements_(tvec2<T, P> const & v){
return detail::component_count(v);
}
template <typename T, precision P>
detail::component_count_t number_of_elements_(tvec3<T, P> const & v){
return detail::component_count(v);
}
template <typename T, precision P>
detail::component_count_t number_of_elements_(tvec4<T, P> const & v){
return detail::component_count(v);
}
template <typename genType>
detail::component_count_t number_of_elements_(genType const & m){
return detail::component_count(m) * detail::component_count(m[0]);
}
}//namespace
/// @addtogroup gtx_range
/// @{
template <typename genType>
const typename genType::value_type * begin(genType const & v){
return value_ptr(v);
}
template <typename genType>
const typename genType::value_type * end(genType const & v){
return begin(v) + detail::number_of_elements_(v);
}
template <typename genType>
typename genType::value_type * begin(genType& v){
return value_ptr(v);
}
template <typename genType>
typename genType::value_type * end(genType& v){
return begin(v) + detail::number_of_elements_(v);
}
/// @}
}//namespace glm
common/glm/glm/gtx/raw_data.hpp
+5 -4
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -35,8 +39,7 @@
/// <glm/gtx/raw_data.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_raw_data
#define GLM_GTX_raw_data
#pragma once
// Dependencies
#include "../detail/setup.hpp"
@@ -71,5 +74,3 @@ namespace glm
}// namespace glm
#include "raw_data.inl"
#endif//GLM_GTX_raw_data
common/glm/glm/gtx/raw_data.inl
+31 -11
View File
@@ -1,11 +1,31 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2008-11-19
// Updated : 2008-11-19
// Licence : This source is under MIT License
// File : glm/gtx/raw_data.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
// Dependency:
// - GLM core
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_raw_data
/// @file glm/gtx/raw_data.inl
/// @date 2008-11-19 / 2011-06-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
common/glm/glm/gtx/reciprocal.hpp
-26
View File
@@ -1,26 +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.
///////////////////////////////////////////////////////////////////////////////////
#if(defined(GLM_MESSAGES))
# pragma message("GLM: GLM_GTX_reciprocal extension is deprecated, include GLM_GTC_reciprocal instead")
#endif
common/glm/glm/gtx/rotate_normalized_axis.hpp
+14 -13
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -30,15 +34,14 @@
/// @see gtc_quaternion
///
/// @defgroup gtx_rotate_normalized_axis GLM_GTX_rotate_normalized_axis
/// @ingroup gtc
/// @ingroup gtx
///
/// @brief Quaternions and matrices rotations around normalized axis.
///
/// <glm/gtx/rotate_normalized_axis.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_rotate_normalized_axis
#define GLM_GTX_rotate_normalized_axis
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -63,13 +66,13 @@ namespace glm
///
/// @see gtx_rotate_normalized_axis
/// @see - rotate(T angle, T x, T y, T z)
/// @see - rotate(detail::tmat4x4<T, P> const & m, T angle, T x, T y, T z)
/// @see - rotate(T angle, detail::tvec3<T, P> const & v)
/// @see - rotate(tmat4x4<T, P> const & m, T angle, T x, T y, T z)
/// @see - rotate(T angle, tvec3<T, P> const & v)
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> rotateNormalizedAxis(
detail::tmat4x4<T, P> const & m,
GLM_FUNC_DECL tmat4x4<T, P> rotateNormalizedAxis(
tmat4x4<T, P> const & m,
T const & angle,
detail::tvec3<T, P> const & axis);
tvec3<T, P> const & axis);
/// Rotates a quaternion from a vector of 3 components normalized axis and an angle.
///
@@ -79,14 +82,12 @@ namespace glm
///
/// @see gtx_rotate_normalized_axis
template <typename T, precision P>
GLM_FUNC_DECL detail::tquat<T, P> rotateNormalizedAxis(
detail::tquat<T, P> const & q,
GLM_FUNC_DECL tquat<T, P> rotateNormalizedAxis(
tquat<T, P> const & q,
T const & angle,
detail::tvec3<T, P> const & axis);
tvec3<T, P> const & axis);
/// @}
}//namespace glm
#include "rotate_normalized_axis.inl"
#endif//GLM_GTX_rotate_normalized_axis
common/glm/glm/gtx/rotate_normalized_axis.inl
+20 -26
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -29,27 +33,22 @@
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> rotateNormalizedAxis
GLM_FUNC_QUALIFIER tmat4x4<T, P> rotateNormalizedAxis
(
detail::tmat4x4<T, P> const & m,
tmat4x4<T, P> const & m,
T const & angle,
detail::tvec3<T, P> const & v
tvec3<T, P> const & v
)
{
#ifdef GLM_FORCE_RADIANS
T a = angle;
#else
# pragma message("GLM: rotateNormalizedAxis function taking degrees as parameters is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
T a = radians(angle);
#endif
T c = cos(a);
T s = sin(a);
T const a = angle;
T const c = cos(a);
T const s = sin(a);
detail::tvec3<T, P> axis = v;
tvec3<T, P> const axis(v);
detail::tvec3<T, P> temp = (T(1) - c) * axis;
tvec3<T, P> const temp((static_cast<T>(1) - c) * axis);
detail::tmat4x4<T, P> Rotate(detail::tmat4x4<T, P>::_null);
tmat4x4<T, P> Rotate(uninitialize);
Rotate[0][0] = c + temp[0] * axis[0];
Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
@@ -62,7 +61,7 @@ namespace glm
Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
Rotate[2][2] = c + temp[2] * axis[2];
detail::tmat4x4<T, P> Result(detail::tmat4x4<T, P>::_null);
tmat4x4<T, P> Result(uninitialize);
Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
@@ -71,24 +70,19 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tquat<T, P> rotateNormalizedAxis
GLM_FUNC_QUALIFIER tquat<T, P> rotateNormalizedAxis
(
detail::tquat<T, P> const & q,
tquat<T, P> const & q,
T const & angle,
detail::tvec3<T, P> const & v
tvec3<T, P> const & v
)
{
detail::tvec3<T, P> Tmp = v;
tvec3<T, P> const Tmp(v);
#ifdef GLM_FORCE_RADIANS
T const AngleRad(angle);
#else
# pragma message("GLM: rotateNormalizedAxis function taking degrees as parameters is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
T const AngleRad = radians(angle);
#endif
T const Sin = sin(AngleRad * T(0.5));
return q * detail::tquat<T, P>(cos(AngleRad * static_cast<T>(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin);
//return gtc::quaternion::cross(q, detail::tquat<T, P>(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin));
return q * tquat<T, P>(cos(AngleRad * static_cast<T>(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin);
//return gtc::quaternion::cross(q, tquat<T, P>(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin));
}
}//namespace glm
common/glm/glm/gtx/rotate_vector.hpp
+41 -27
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -36,8 +40,7 @@
/// <glm/gtx/rotate_vector.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_rotate_vector
#define GLM_GTX_rotate_vector
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -52,81 +55,92 @@ namespace glm
/// @addtogroup gtx_rotate_vector
/// @{
/// Returns Spherical interpolation between two vectors
///
/// @param x A first vector
/// @param y A second vector
/// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1].
///
/// @see gtx_rotate_vector
template <typename T, precision P>
GLM_FUNC_DECL tvec3<T, P> slerp(
tvec3<T, P> const & x,
tvec3<T, P> const & y,
T const & a);
//! Rotate a two dimensional vector.
//! From GLM_GTX_rotate_vector extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec2<T, P> rotate(
detail::tvec2<T, P> const & v,
GLM_FUNC_DECL tvec2<T, P> rotate(
tvec2<T, P> const & v,
T const & angle);
//! Rotate a three dimensional vector around an axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> rotate(
detail::tvec3<T, P> const & v,
GLM_FUNC_DECL tvec3<T, P> rotate(
tvec3<T, P> const & v,
T const & angle,
detail::tvec3<T, P> const & normal);
tvec3<T, P> const & normal);
//! Rotate a four dimensional vector around an axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<T, P> rotate(
detail::tvec4<T, P> const & v,
GLM_FUNC_DECL tvec4<T, P> rotate(
tvec4<T, P> const & v,
T const & angle,
detail::tvec3<T, P> const & normal);
tvec3<T, P> const & normal);
//! Rotate a three dimensional vector around the X axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> rotateX(
detail::tvec3<T, P> const & v,
GLM_FUNC_DECL tvec3<T, P> rotateX(
tvec3<T, P> const & v,
T const & angle);
//! Rotate a three dimensional vector around the Y axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> rotateY(
detail::tvec3<T, P> const & v,
GLM_FUNC_DECL tvec3<T, P> rotateY(
tvec3<T, P> const & v,
T const & angle);
//! Rotate a three dimensional vector around the Z axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec3<T, P> rotateZ(
detail::tvec3<T, P> const & v,
GLM_FUNC_DECL tvec3<T, P> rotateZ(
tvec3<T, P> const & v,
T const & angle);
//! Rotate a four dimentionnals vector around the X axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<T, P> rotateX(
detail::tvec4<T, P> const & v,
GLM_FUNC_DECL tvec4<T, P> rotateX(
tvec4<T, P> const & v,
T const & angle);
//! Rotate a four dimensional vector around the X axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<T, P> rotateY(
detail::tvec4<T, P> const & v,
GLM_FUNC_DECL tvec4<T, P> rotateY(
tvec4<T, P> const & v,
T const & angle);
//! Rotate a four dimensional vector around the X axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tvec4<T, P> rotateZ(
detail::tvec4<T, P> const & v,
GLM_FUNC_DECL tvec4<T, P> rotateZ(
tvec4<T, P> const & v,
T const & angle);
//! Build a rotation matrix from a normal and a up vector.
//! From GLM_GTX_rotate_vector extension.
template <typename T, precision P>
GLM_FUNC_DECL detail::tmat4x4<T, P> orientation(
detail::tvec3<T, P> const & Normal,
detail::tvec3<T, P> const & Up);
GLM_FUNC_DECL tmat4x4<T, P> orientation(
tvec3<T, P> const & Normal,
tvec3<T, P> const & Up);
/// @}
}//namespace glm
#include "rotate_vector.inl"
#endif//GLM_GTX_rotate_vector
common/glm/glm/gtx/rotate_vector.inl
+92 -98
View File
@@ -1,51 +1,91 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2006-11-02
// Updated : 2009-02-19
// Licence : This source is under MIT License
// File : glm/gtx/rotate_vector.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_rotate_vector
/// @file glm/gtx/rotate_vector.inl
/// @date 2006-11-02 / 2011-06-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec2<T, P> rotate
GLM_FUNC_QUALIFIER tvec3<T, P> slerp
(
detail::tvec2<T, P> const & v,
tvec3<T, P> const & x,
tvec3<T, P> const & y,
T const & a
)
{
// get cosine of angle between vectors (-1 -> 1)
T CosAlpha = dot(x, y);
// get angle (0 -> pi)
T Alpha = acos(CosAlpha);
// get sine of angle between vectors (0 -> 1)
T SinAlpha = sin(Alpha);
// this breaks down when SinAlpha = 0, i.e. Alpha = 0 or pi
T t1 = sin((static_cast<T>(1) - a) * Alpha) / SinAlpha;
T t2 = sin(a * Alpha) / SinAlpha;
// interpolate src vectors
return x * t1 + y * t2;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec2<T, P> rotate
(
tvec2<T, P> const & v,
T const & angle
)
{
detail::tvec2<T, P> Result;
#ifdef GLM_FORCE_RADIANS
tvec2<T, P> Result;
T const Cos(cos(angle));
T const Sin(sin(angle));
#else
# pragma message("GLM: rotate function taking degrees as parameters is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
T const Cos = cos(radians(angle));
T const Sin = sin(radians(angle));
#endif
Result.x = v.x * Cos - v.y * Sin;
Result.y = v.x * Sin + v.y * Cos;
return Result;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> rotate
GLM_FUNC_QUALIFIER tvec3<T, P> rotate
(
detail::tvec3<T, P> const & v,
tvec3<T, P> const & v,
T const & angle,
detail::tvec3<T, P> const & normal
tvec3<T, P> const & normal
)
{
return detail::tmat3x3<T, P>(glm::rotate(angle, normal)) * v;
return tmat3x3<T, P>(glm::rotate(angle, normal)) * v;
}
/*
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> rotateGTX(
const detail::tvec3<T, P>& x,
GLM_FUNC_QUALIFIER tvec3<T, P> rotateGTX(
const tvec3<T, P>& x,
T angle,
const detail::tvec3<T, P>& normal)
const tvec3<T, P>& normal)
{
const T Cos = cos(radians(angle));
const T Sin = sin(radians(angle));
@@ -53,33 +93,26 @@ namespace glm
}
*/
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> rotate
GLM_FUNC_QUALIFIER tvec4<T, P> rotate
(
detail::tvec4<T, P> const & v,
tvec4<T, P> const & v,
T const & angle,
detail::tvec3<T, P> const & normal
tvec3<T, P> const & normal
)
{
return rotate(angle, normal) * v;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> rotateX
GLM_FUNC_QUALIFIER tvec3<T, P> rotateX
(
detail::tvec3<T, P> const & v,
tvec3<T, P> const & v,
T const & angle
)
{
detail::tvec3<T, P> Result(v);
#ifdef GLM_FORCE_RADIANS
tvec3<T, P> Result(v);
T const Cos(cos(angle));
T const Sin(sin(angle));
#else
# pragma message("GLM: rotateX function taking degrees as parameters is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
T const Cos = cos(radians(angle));
T const Sin = sin(radians(angle));
#endif
Result.y = v.y * Cos - v.z * Sin;
Result.z = v.y * Sin + v.z * Cos;
@@ -87,22 +120,15 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> rotateY
GLM_FUNC_QUALIFIER tvec3<T, P> rotateY
(
detail::tvec3<T, P> const & v,
tvec3<T, P> const & v,
T const & angle
)
{
detail::tvec3<T, P> Result = v;
#ifdef GLM_FORCE_RADIANS
tvec3<T, P> Result = v;
T const Cos(cos(angle));
T const Sin(sin(angle));
#else
# pragma message("GLM: rotateY function taking degrees as parameters is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
T const Cos(cos(radians(angle)));
T const Sin(sin(radians(angle)));
#endif
Result.x = v.x * Cos + v.z * Sin;
Result.z = -v.x * Sin + v.z * Cos;
@@ -110,22 +136,15 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec3<T, P> rotateZ
GLM_FUNC_QUALIFIER tvec3<T, P> rotateZ
(
detail::tvec3<T, P> const & v,
tvec3<T, P> const & v,
T const & angle
)
{
detail::tvec3<T, P> Result = v;
#ifdef GLM_FORCE_RADIANS
tvec3<T, P> Result = v;
T const Cos(cos(angle));
T const Sin(sin(angle));
#else
# pragma message("GLM: rotateZ function taking degrees as parameters is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
T const Cos(cos(radians(angle)));
T const Sin(sin(radians(angle)));
#endif
Result.x = v.x * Cos - v.y * Sin;
Result.y = v.x * Sin + v.y * Cos;
@@ -133,22 +152,15 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> rotateX
GLM_FUNC_QUALIFIER tvec4<T, P> rotateX
(
detail::tvec4<T, P> const & v,
tvec4<T, P> const & v,
T const & angle
)
{
detail::tvec4<T, P> Result = v;
#ifdef GLM_FORCE_RADIANS
tvec4<T, P> Result = v;
T const Cos(cos(angle));
T const Sin(sin(angle));
#else
# pragma message("GLM: rotateX function taking degrees as parameters is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
T const Cos(cos(radians(angle)));
T const Sin(sin(radians(angle)));
#endif
Result.y = v.y * Cos - v.z * Sin;
Result.z = v.y * Sin + v.z * Cos;
@@ -156,22 +168,15 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> rotateY
GLM_FUNC_QUALIFIER tvec4<T, P> rotateY
(
detail::tvec4<T, P> const & v,
tvec4<T, P> const & v,
T const & angle
)
{
detail::tvec4<T, P> Result = v;
#ifdef GLM_FORCE_RADIANS
tvec4<T, P> Result = v;
T const Cos(cos(angle));
T const Sin(sin(angle));
#else
# pragma message("GLM: rotateX function taking degrees as parameters is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
T const Cos(cos(radians(angle)));
T const Sin(sin(radians(angle)));
#endif
Result.x = v.x * Cos + v.z * Sin;
Result.z = -v.x * Sin + v.z * Cos;
@@ -179,22 +184,15 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tvec4<T, P> rotateZ
GLM_FUNC_QUALIFIER tvec4<T, P> rotateZ
(
detail::tvec4<T, P> const & v,
tvec4<T, P> const & v,
T const & angle
)
{
detail::tvec4<T, P> Result = v;
#ifdef GLM_FORCE_RADIANS
tvec4<T, P> Result = v;
T const Cos(cos(angle));
T const Sin(sin(angle));
#else
# pragma message("GLM: rotateZ function taking degrees as parameters is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
T const Cos(cos(radians(angle)));
T const Sin(sin(radians(angle)));
#endif
Result.x = v.x * Cos - v.y * Sin;
Result.y = v.x * Sin + v.y * Cos;
@@ -202,22 +200,18 @@ namespace glm
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> orientation
GLM_FUNC_QUALIFIER tmat4x4<T, P> orientation
(
detail::tvec3<T, P> const & Normal,
detail::tvec3<T, P> const & Up
tvec3<T, P> const & Normal,
tvec3<T, P> const & Up
)
{
if(all(equal(Normal, Up)))
return detail::tmat4x4<T, P>(T(1));
return tmat4x4<T, P>(T(1));
tvec3<T, P> RotationAxis = cross(Up, Normal);
T Angle = acos(dot(Normal, Up));
detail::tvec3<T, P> RotationAxis = cross(Up, Normal);
# ifdef GLM_FORCE_RADIANS
T Angle = acos(dot(Normal, Up));
# else
# pragma message("GLM: rotateZ function taking degrees as parameters is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
T Angle = degrees(acos(dot(Normal, Up)));
# endif
return rotate(Angle, RotationAxis);
}
}//namespace glm
common/glm/glm/gtx/scalar_multiplication.hpp
+98
View File
@@ -0,0 +1,98 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
/// @file glm/gtx/scalar_multiplication.hpp
/// @date 2014-09-22 / 2014-09-22
/// @author Joshua Moerman
///
/// @brief Enables scalar multiplication for all types
///
/// Since GLSL is very strict about types, the following (often used) combinations do not work:
/// double * vec4
/// int * vec4
/// vec4 / int
/// So we'll fix that! Of course "float * vec4" should remain the same (hence the enable_if magic)
///
///////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "../detail/setup.hpp"
#if !GLM_HAS_TEMPLATE_ALIASES
# error "GLM_GTX_scalar_multiplication requires C++11 suppport or alias templates"
#endif
#include "../vec2.hpp"
#include "../vec3.hpp"
#include "../vec4.hpp"
#include "../mat2x2.hpp"
#include <type_traits>
namespace glm
{
template <typename T, typename Vec>
using return_type_scalar_multiplication = typename std::enable_if<
!std::is_same<T, float>::value // T may not be a float
&& std::is_arithmetic<T>::value, Vec // But it may be an int or double (no vec3 or mat3, ...)
>::type;
#define GLM_IMPLEMENT_SCAL_MULT(Vec) \
template <typename T> \
return_type_scalar_multiplication<T, Vec> \
operator*(T const & s, Vec rh){ \
return rh *= static_cast<float>(s); \
} \
\
template <typename T> \
return_type_scalar_multiplication<T, Vec> \
operator*(Vec lh, T const & s){ \
return lh *= static_cast<float>(s); \
} \
\
template <typename T> \
return_type_scalar_multiplication<T, Vec> \
operator/(Vec lh, T const & s){ \
return lh *= 1.0f / s; \
}
GLM_IMPLEMENT_SCAL_MULT(vec2)
GLM_IMPLEMENT_SCAL_MULT(vec3)
GLM_IMPLEMENT_SCAL_MULT(vec4)
GLM_IMPLEMENT_SCAL_MULT(mat2)
GLM_IMPLEMENT_SCAL_MULT(mat2x3)
GLM_IMPLEMENT_SCAL_MULT(mat2x4)
GLM_IMPLEMENT_SCAL_MULT(mat3x2)
GLM_IMPLEMENT_SCAL_MULT(mat3)
GLM_IMPLEMENT_SCAL_MULT(mat3x4)
GLM_IMPLEMENT_SCAL_MULT(mat4x2)
GLM_IMPLEMENT_SCAL_MULT(mat4x3)
GLM_IMPLEMENT_SCAL_MULT(mat4)
#undef GLM_IMPLEMENT_SCAL_MULT
} // namespace glm
common/glm/glm/gtx/scalar_relational.hpp
+6 -5
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -27,7 +31,7 @@
///
/// @see core (dependence)
///
/// @defgroup gtx_extend GLM_GTX_scalar_relational
/// @defgroup gtx_scalar_relational GLM_GTX_scalar_relational
/// @ingroup gtx
///
/// @brief Extend a position from a source to a position at a defined length.
@@ -35,8 +39,7 @@
/// <glm/gtx/scalar_relational.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_scalar_relational
#define GLM_GTX_scalar_relational
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -56,5 +59,3 @@ namespace glm
}//namespace glm
#include "scalar_relational.inl"
#endif//GLM_GTX_scalar_relational
common/glm/glm/gtx/scalar_relational.inl
+31 -8
View File
@@ -1,11 +1,34 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2013-02-04
// Updated : 2013-02-04
// Licence : This source is under MIT License
// File : glm/gtx/scalar_relational.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2012 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_scalar_relational
/// @file glm/gtx/scalar_relational.inl
/// @date 2013-02-04 / 2013-02-04
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
common/glm/glm/gtx/simd_mat4.hpp
+7 -7
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -20,8 +24,8 @@
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref gtx_simd_vec4
/// @file glm/gtx/simd_vec4.hpp
/// @ref gtx_simd_mat4
/// @file glm/gtx/simd_mat4.hpp
/// @date 2009-05-07 / 2011-06-07
/// @author Christophe Riccio
///
@@ -35,8 +39,7 @@
/// <glm/gtx/simd_mat4.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_simd_mat4
#define GLM_GTX_simd_mat4
#pragma once
// Dependencies
#include "../detail/setup.hpp"
@@ -61,7 +64,6 @@ namespace detail
/// \ingroup gtx_simd_mat4
GLM_ALIGNED_STRUCT(16) fmat4x4SIMD
{
enum ctor{_null};
typedef float value_type;
typedef fvec4SIMD col_type;
typedef fvec4SIMD row_type;
@@ -201,5 +203,3 @@ namespace detail
#include "simd_mat4.inl"
#endif//(GLM_ARCH != GLM_ARCH_PURE)
#endif//GLM_GTX_simd_mat4
common/glm/glm/gtx/simd_mat4.inl
+37 -14
View File
@@ -1,10 +1,33 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2009-05-19
// Updated : 2009-05-19
// Licence : This source is under MIT License
// File : glm/gtx/simd_mat4.hpp
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2014 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.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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_simd_mat4
/// @file glm/gtx/simd_mat4.inl
/// @date 2009-05-07 / 2011-06-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
@@ -43,12 +66,12 @@ GLM_FUNC_QUALIFIER fvec4SIMD const & fmat4x4SIMD::operator[]
GLM_FUNC_QUALIFIER fmat4x4SIMD::fmat4x4SIMD()
{
#ifndef GLM_SIMD_ENABLE_DEFAULT_INIT
this->Data[0] = fvec4SIMD(1.0f, 0, 0, 0);
this->Data[1] = fvec4SIMD(0, 1.0f, 0, 0);
this->Data[2] = fvec4SIMD(0, 0, 1.0f, 0);
this->Data[3] = fvec4SIMD(0, 0, 0, 1.0f);
#endif
# ifndef GLM_FORCE_NO_CTOR_INIT
this->Data[0] = fvec4SIMD(1, 0, 0, 0);
this->Data[1] = fvec4SIMD(0, 1, 0, 0);
this->Data[2] = fvec4SIMD(0, 0, 1, 0);
this->Data[3] = fvec4SIMD(0, 0, 0, 1);
# endif
}
GLM_FUNC_QUALIFIER fmat4x4SIMD::fmat4x4SIMD(float const & s)
@@ -554,7 +577,7 @@ GLM_FUNC_QUALIFIER detail::fmat4x4SIMD outerProduct
__m128 Shu2 = _mm_shuffle_ps(r.Data, r.Data, _MM_SHUFFLE(2, 2, 2, 2));
__m128 Shu3 = _mm_shuffle_ps(r.Data, r.Data, _MM_SHUFFLE(3, 3, 3, 3));
detail::fmat4x4SIMD result(detail::fmat4x4SIMD::_null);
detail::fmat4x4SIMD result(uninitialize);
result[0].Data = _mm_mul_ps(c.Data, Shu0);
result[1].Data = _mm_mul_ps(c.Data, Shu1);
result[2].Data = _mm_mul_ps(c.Data, Shu2);
common/glm/glm/gtx/simd_quat.hpp
+79 -85
View File
@@ -12,6 +12,10 @@
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// Restrictions:
/// By making use of the Software for military purposes, you choose to make
/// a Bunny unhappy.
///
/// 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
@@ -22,12 +26,12 @@
///
/// @ref gtx_simd_quat
/// @file glm/gtx/simd_quat.hpp
/// @date 2009-05-07 / 2011-06-07
/// @date 2013-04-22 / 2014-11-25
/// @author Christophe Riccio
///
/// @see core (dependence)
///
/// @defgroup gtx_simd_vec4 GLM_GTX_simd_quat
/// @defgroup gtx_simd_quat GLM_GTX_simd_quat
/// @ingroup gtx
///
/// @brief SIMD implementation of quat type.
@@ -35,8 +39,7 @@
/// <glm/gtx/simd_quat.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTX_simd_quat
#define GLM_GTX_simd_quat
#pragma once
// Dependency:
#include "../glm.hpp"
@@ -55,22 +58,17 @@
# pragma message("GLM: GLM_GTX_simd_quat extension included")
#endif
// Warning silencer for nameless struct/union.
#if (GLM_COMPILER & GLM_COMPILER_VC)
# pragma warning(push)
# pragma warning(disable:4201) // warning C4201: nonstandard extension used : nameless struct/union
#endif
namespace glm{
namespace detail
{
/// Quaternion implemented using SIMD SEE intrinsics.
/// \ingroup gtx_simd_vec4
GLM_ALIGNED_STRUCT(16) fquatSIMD
{
enum ctor{null};
typedef __m128 value_type;
typedef std::size_t size_type;
static size_type value_size();
@@ -79,13 +77,13 @@ namespace detail
typedef tquat<bool, defaultp> bool_type;
#ifdef GLM_SIMD_ENABLE_XYZW_UNION
union
{
__m128 Data;
struct {float x, y, z, w;};
};
union
{
__m128 Data;
struct {float x, y, z, w;};
};
#else
__m128 Data;
__m128 Data;
#endif
//////////////////////////////////////
@@ -107,21 +105,21 @@ namespace detail
float const & z);
explicit fquatSIMD(
quat const & v);
explicit fquatSIMD(
explicit fquatSIMD(
vec3 const & eulerAngles);
//////////////////////////////////////
// Unary arithmetic operators
fquatSIMD& operator =(fquatSIMD const & q);
fquatSIMD& operator*=(float const & s);
fquatSIMD& operator =(fquatSIMD const & q);
fquatSIMD& operator*=(float const & s);
fquatSIMD& operator/=(float const & s);
};
//////////////////////////////////////
// Arithmetic operators
//////////////////////////////////////
// Arithmetic operators
detail::fquatSIMD operator- (
detail::fquatSIMD const & q);
@@ -156,64 +154,64 @@ namespace detail
}//namespace detail
typedef glm::detail::fquatSIMD simdQuat;
/// @addtogroup gtx_simd_quat
/// @{
//! Convert a simdQuat to a quat.
//! (From GLM_GTX_simd_quat extension)
typedef glm::detail::fquatSIMD simdQuat;
//! Convert a simdQuat to a quat.
/// @see gtx_simd_quat
quat quat_cast(
detail::fquatSIMD const & x);
//! Convert a simdMat4 to a simdQuat.
//! (From GLM_GTX_simd_quat extension)
detail::fquatSIMD quatSIMD_cast(
detail::fmat4x4SIMD const & m);
//! Convert a simdMat4 to a simdQuat.
/// @see gtx_simd_quat
detail::fquatSIMD quatSIMD_cast(
detail::fmat4x4SIMD const & m);
//! Converts a mat4 to a simdQuat.
//! (From GLM_GTX_simd_quat extension)
template <typename T, precision P>
detail::fquatSIMD quatSIMD_cast(
detail::tmat4x4<T, P> const & m);
//! Converts a mat4 to a simdQuat.
/// @see gtx_simd_quat
template <typename T, precision P>
detail::fquatSIMD quatSIMD_cast(
tmat4x4<T, P> const & m);
//! Converts a mat3 to a simdQuat.
//! (From GLM_GTX_simd_quat extension)
template <typename T, precision P>
detail::fquatSIMD quatSIMD_cast(
detail::tmat3x3<T, P> const & m);
//! Converts a mat3 to a simdQuat.
/// @see gtx_simd_quat
template <typename T, precision P>
detail::fquatSIMD quatSIMD_cast(
tmat3x3<T, P> const & m);
//! Convert a simdQuat to a simdMat4
//! (From GLM_GTX_simd_quat extension)
detail::fmat4x4SIMD mat4SIMD_cast(
detail::fquatSIMD const & q);
//! Convert a simdQuat to a simdMat4
/// @see gtx_simd_quat
detail::fmat4x4SIMD mat4SIMD_cast(
detail::fquatSIMD const & q);
//! Converts a simdQuat to a standard mat4.
//! (From GLM_GTX_simd_quat extension)
mat4 mat4_cast(
detail::fquatSIMD const & q);
//! Converts a simdQuat to a standard mat4.
/// @see gtx_simd_quat
mat4 mat4_cast(
detail::fquatSIMD const & q);
/// Returns the length of the quaternion.
///
/// @see gtc_quaternion
/// @see gtx_simd_quat
float length(
detail::fquatSIMD const & x);
/// Returns the normalized quaternion.
///
/// @see gtc_quaternion
/// @see gtx_simd_quat
detail::fquatSIMD normalize(
detail::fquatSIMD const & x);
/// Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ...
/// Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ...
///
/// @see gtc_quaternion
/// @see gtx_simd_quat
float dot(
detail::fquatSIMD const & q1,
detail::fquatSIMD const & q2);
/// Spherical linear interpolation of two quaternions.
/// Spherical linear interpolation of two quaternions.
/// The interpolation is oriented and the rotation is performed at constant speed.
/// For short path spherical linear interpolation, use the slerp function.
///
@@ -221,21 +219,21 @@ namespace detail
/// @param y A quaternion
/// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1].
/// @tparam T Value type used to build the quaternion. Supported: half, float or double.
/// @see gtc_quaternion
/// @see gtx_simd_quat
/// @see - slerp(detail::fquatSIMD const & x, detail::fquatSIMD const & y, T const & a)
detail::fquatSIMD mix(
detail::fquatSIMD const & x,
detail::fquatSIMD const & y,
float const & a);
/// Linear interpolation of two quaternions.
/// Linear interpolation of two quaternions.
/// The interpolation is oriented.
///
/// @param x A quaternion
/// @param y A quaternion
/// @param a Interpolation factor. The interpolation is defined in the range [0, 1].
/// @tparam T Value type used to build the quaternion. Supported: half, float or double.
/// @see gtc_quaternion
/// @see gtx_simd_quat
detail::fquatSIMD lerp(
detail::fquatSIMD const & x,
detail::fquatSIMD const & y,
@@ -248,36 +246,36 @@ namespace detail
/// @param y A quaternion
/// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1].
/// @tparam T Value type used to build the quaternion. Supported: half, float or double.
/// @see gtc_quaternion
/// @see gtx_simd_quat
detail::fquatSIMD slerp(
detail::fquatSIMD const & x,
detail::fquatSIMD const & y,
float const & a);
/// Faster spherical linear interpolation of two unit length quaternions.
///
/// This is the same as mix(), except for two rules:
/// 1) The two quaternions must be unit length.
/// 2) The interpolation factor (a) must be in the range [0, 1].
///
/// This will use the equivalent to fastAcos() and fastSin().
///
/// @see gtc_quaternion
/// Faster spherical linear interpolation of two unit length quaternions.
///
/// This is the same as mix(), except for two rules:
/// 1) The two quaternions must be unit length.
/// 2) The interpolation factor (a) must be in the range [0, 1].
///
/// This will use the equivalent to fastAcos() and fastSin().
///
/// @see gtx_simd_quat
/// @see - mix(detail::fquatSIMD const & x, detail::fquatSIMD const & y, T const & a)
detail::fquatSIMD fastMix(
detail::fquatSIMD const & x,
detail::fquatSIMD const & y,
float const & a);
/// Identical to fastMix() except takes the shortest path.
///
/// The same rules apply here as those in fastMix(). Both quaternions must be unit length and 'a' must be
/// in the range [0, 1].
///
/// Identical to fastMix() except takes the shortest path.
///
/// The same rules apply here as those in fastMix(). Both quaternions must be unit length and 'a' must be
/// in the range [0, 1].
///
/// @see - fastMix(detail::fquatSIMD const & x, detail::fquatSIMD const & y, T const & a)
/// @see - slerp(detail::fquatSIMD const & x, detail::fquatSIMD const & y, T const & a)
detail::fquatSIMD fastSlerp(
detail::fquatSIMD fastSlerp(
detail::fquatSIMD const & x,
detail::fquatSIMD const & y,
float const & a);
@@ -285,45 +283,43 @@ namespace detail
/// Returns the q conjugate.
///
/// @see gtc_quaternion
/// @see gtx_simd_quat
detail::fquatSIMD conjugate(
detail::fquatSIMD const & q);
/// Returns the q inverse.
///
/// @see gtc_quaternion
/// @see gtx_simd_quat
detail::fquatSIMD inverse(
detail::fquatSIMD const & q);
/// Build a quaternion from an angle and a normalized axis.
/// Build a quaternion from an angle and a normalized axis.
///
/// @param angle Angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
/// @param angle Angle expressed in radians.
/// @param axis Axis of the quaternion, must be normalized.
///
/// @see gtc_quaternion
/// @see gtx_simd_quat
detail::fquatSIMD angleAxisSIMD(
float const & angle,
vec3 const & axis);
/// Build a quaternion from an angle and a normalized axis.
/// Build a quaternion from an angle and a normalized axis.
///
/// @param angle Angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
/// @param angle Angle expressed in radians.
/// @param x x component of the x-axis, x, y, z must be a normalized axis
/// @param y y component of the y-axis, x, y, z must be a normalized axis
/// @param z z component of the z-axis, x, y, z must be a normalized axis
///
/// @see gtc_quaternion
/// @see gtx_simd_quat
detail::fquatSIMD angleAxisSIMD(
float const & angle,
float const & x,
float const & y,
float const & z);
// TODO: Move this to somewhere more appropriate. Used with fastMix() and fastSlerp().
/// Performs the equivalent of glm::fastSin() on each component of the given __m128.
__m128 fastSin(__m128 x);
// TODO: Move this to somewhere more appropriate. Used with fastMix() and fastSlerp().
/// Performs the equivalent of glm::fastSin() on each component of the given __m128.
__m128 fastSin(__m128 x);
/// @}
}//namespace glm
@@ -337,5 +333,3 @@ namespace detail
#endif//(GLM_ARCH != GLM_ARCH_PURE)
#endif//GLM_GTX_simd_quat

Some files were not shown because too many files have changed in this diff Show More