mirror/glm
1
0
Fork 0
mirror of https://github.com/g-truc/glm.git synced 2024-11-30 03:44:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch '0.9.1' of ssh://ogl-math.git.sourceforge.net/gitroot/ogl-math/ogl-math into 0.9.1

Browse Source
This commit is contained in:
Christophe Riccio 2011-03-11 00:25:00 +00:00
commit d08c508f01
7 changed files with 177 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
doc/pages.doxy
View File

@ -9,16 +9,16 @@
This library works perfectly with OpenGL but it also ensures interoperability with other third party libraries and SDK. It is a good candidate for software rendering (Raytracing / Rasterisation), image processing, physic simulations and any context that requires a simple and convenient mathematics library. This library works perfectly with OpenGL but it also ensures interoperability with other third party libraries and SDK. It is a good candidate for software rendering (Raytracing / Rasterisation), image processing, physic simulations and any context that requires a simple and convenient mathematics library.
\note The Doxygen-generated documentation will often state that a type or function
is defined in a namespace that is a child of the \link glm glm \endlink namespace.
Please ignore this; you can access all publicly available types as direct children
of the glm namespace.
GLM is written as a platform independent library with no dependence and officially supports the following compilers: GLM is written as a platform independent library with no dependence and officially supports the following compilers:
1. GCC 3.4 and higher 1. GCC 3.4 and higher
2. LLVM 2.3 through GCC 4.2 front-end and higher 2. LLVM 2.3 through GCC 4.2 front-end and higher
3. Visual Studio 2005 and higher 3. Visual Studio 2005 and higher
\note The Doxygen-generated documentation will often state that a type or function
is defined in a namespace that is a child of the \link glm glm \endlink namespace.
Please ignore this; All publicly available types and functions can be accessed as a direct children
of the glm namespace.
The source code is licenced under the <a href="http://www.opensource.org/licenses/mit-license.php">MIT licence</a>. The source code is licenced under the <a href="http://www.opensource.org/licenses/mit-license.php">MIT licence</a>.
Thanks for contributing to the project by <a href="https://sourceforge.net/apps/trac/ogl-math/newticket">submitting tickets for bug reports and feature requests</a>. Thanks for contributing to the project by <a href="https://sourceforge.net/apps/trac/ogl-math/newticket">submitting tickets for bug reports and feature requests</a>.
@ -67,7 +67,7 @@ int foo()
The \ref core "GLM" represents only what GLSL's core provides in terms of types and functions The \ref core "GLM" represents only what GLSL's core provides in terms of types and functions
(to the best of GLM's ability to replicate them). All that is needed to use the core (to the best of GLM's ability to replicate them). All that is needed to use the core
is to <tt>#include <glm/glm.hpp></tt>. is to include <tt><glm/glm.hpp></tt>.
\ref gtc "GTC extensions" are functions and types that add onto the core. \ref gtc "GTC extensions" are functions and types that add onto the core.
These are considered reasonably stable, with their APIs not changing much between These are considered reasonably stable, with their APIs not changing much between
@ -79,7 +79,7 @@ int foo()
is why they are marked "experimental". Like GTC extensions, each experimental extension is included is why they are marked "experimental". Like GTC extensions, each experimental extension is included
with a separate header file. with a separate header file.
All the extensions can be included at once by default with <tt>#include <glm/ext.hpp></tt> All the extensions can be included at once by default by including <tt><glm/ext.hpp></tt>
but this is not recommanded as it will reduce compilation speed for many unused features. but this is not recommanded as it will reduce compilation speed for many unused features.
All of GLM is defined as direct children of the glm namespace, including extensions. All of GLM is defined as direct children of the glm namespace, including extensions.
@ -255,8 +255,8 @@ void foo()
GLM's functions are defined in headers, so they are defined with C++'s "inline" delcaration. GLM's functions are defined in headers, so they are defined with C++'s "inline" delcaration.
This does not require the compiler to inline them, however. This does not require the compiler to inline them, however.
If you want to force the compiler to inline the function, using whatever capabilities that the compiler provides to do so, To force the compiler to inline the function, using whatever capabilities that the compiler provides to do so,
you can define GLM_FORCE_INLINE before any inclusion of <glm/glm.hpp>. GLM_FORCE_INLINE can be defined before any inclusion of <glm/glm.hpp>.
\code \code
#define GLM_FORCE_INLINE #define GLM_FORCE_INLINE
@ -281,7 +281,7 @@ void foo()
\section advanced_compatibility Compatibility \section advanced_compatibility Compatibility
Compilers have some language extensions that GLM will automatically take advantage of them when they are enabled. Compilers have some language extensions that GLM will automatically take advantage of them when they are enabled.
The #define GLM_FORCE_CXX98 can switch off these extensions, forcing GLM to operate on pure C++98. GLM_FORCE_CXX98 can switch off these extensions, forcing GLM to operate on pure C++98.
\code \code
#define GLM_FORCE_CXX98 #define GLM_FORCE_CXX98
@ -394,9 +394,10 @@ void foo()
\section faq7 Should I use 'using namespace glm;'? \section faq7 Should I use 'using namespace glm;'?
This is unwise. There is every chance that are that if 'using namespace glm;' is called, name collisions will happen. GLSL names for functions are fairly generic, so it is entirely likely that there is another function called, for example, \link glm::sqrt sqrt \endlink. This is unwise. Chances are that if 'using namespace glm;' is called, name collisions will happen.
GLSL names for functions are fairly generic, so it is entirely likely that there is another function called, for example, \link glm::sqrt sqrt \endlink.
If you need frequent use of particular types, you can bring them into the global For frequent use of particular types, they can be brough into the global
namespace with a 'using' declaration like this: namespace with a 'using' declaration like this:
/code /code
@ -409,9 +410,11 @@ void foo()
GLM is mainly designed to be convenient; that's why it is written against GLSL specification. GLM is mainly designed to be convenient; that's why it is written against GLSL specification.
The <a href="http://en.wikipedia.org/wiki/Pareto_principle">80-20</a> rule suggests that 80% of a program's performance comes from 20% of its code. Therefore, one must first identify which 20% of the code is impacting the performance. The <a href="http://en.wikipedia.org/wiki/Pareto_principle">80-20 rule</a> suggests that 80% of a program's performance comes from 20% of its code.
Therefore, one should first identify which 20% of the code is impacting the performance.
In general, if one identifies certain math code to be a performance bottleneck, the only way to solve this is to write specialized code for those particular math needs. So no canned library solution would be suitable. In general, if one identifies certain math code to be a performance bottleneck, the only way to solve this is to write specialized code for those particular math needs.
So no canned library solution would be suitable.
That being said, GLM can provides some descent performances alternatives based on approximations or SIMD instructions. That being said, GLM can provides some descent performances alternatives based on approximations or SIMD instructions.
**/ **/
@ -614,12 +617,15 @@ glm::vec3 lighting(
GLM HEAD snapshot: GLM HEAD snapshot:
http://ogl-math.git.sourceforge.net/git/gitweb.cgi?p=ogl-math/ogl-math;a=snapshot;h=HEAD;sf=tgz http://ogl-math.git.sourceforge.net/git/gitweb.cgi?p=ogl-math/ogl-math;a=snapshot;h=HEAD;sf=tgz
GLM Trac, for bug report and feature request: GLM bug tracker:
https://sourceforge.net/apps/trac/ogl-math https://sourceforge.net/apps/trac/ogl-math
GLM website: GLM website:
http://glm.g-truc.net http://glm.g-truc.net
GLM OpenGL SDK page:
http://www.opengl.org/sdk/libs/GLM/
G-Truc Creation page: G-Truc Creation page:
http://www.g-truc.net/project-0016.html http://www.g-truc.net/project-0016.html

1
glm/core/type_vec4.hpp
View File

@ -15,7 +15,6 @@
#include "type_int.hpp" #include "type_int.hpp"
#include "type_size.hpp" #include "type_size.hpp"
#include "_swizzle.hpp" #include "_swizzle.hpp"
#include "_detail.hpp"
namespace glm namespace glm
{ {

3
glm/glm.hpp
View File

@ -12,9 +12,6 @@
#ifndef glm_glm #ifndef glm_glm
#define glm_glm #define glm_glm
//! TODO: to delete
#define GLMvalType typename genType::value_type
#include <cmath> #include <cmath>
#include <climits> #include <climits>
#include <cfloat> #include <cfloat>

30
glm/gtx/spline.hpp
View File

@ -36,31 +36,31 @@ namespace glm
//! From GLM_GTX_spline extension. //! From GLM_GTX_spline extension.
template <typename genType> template <typename genType>
genType catmullRom( genType catmullRom(
const genType& v1, genType const & v1,
const genType& v2, genType const & v2,
const genType& v3, genType const & v3,
const genType& v4, genType const & v4,
const GLMvalType& s); typename genType::value_type const & s);
//! Return a point from a hermite curve. //! Return a point from a hermite curve.
//! From GLM_GTX_spline extension. //! From GLM_GTX_spline extension.
template <typename genType> template <typename genType>
genType hermite( genType hermite(
const genType& v1, genType const & v1,
const genType& t1, genType const & t1,
const genType& v2, genType const & v2,
const genType& t2, genType const & t2,
const GLMvalType& s); typename genType::value_type const & s);
//! Return a point from a cubic curve. //! Return a point from a cubic curve.
//! From GLM_GTX_spline extension. //! From GLM_GTX_spline extension.
template <typename genType> template <typename genType>
genType cubic( genType cubic(
const genType& v1, genType const & v1,
const genType& v2, genType const & v2,
const genType& v3, genType const & v3,
const genType& v4, genType const & v4,
const GLMvalType& s); typename genType::value_type const & s);
///@} ///@}

72
glm/gtx/spline.inl
View File

@ -12,53 +12,59 @@ namespace gtx{
namespace spline namespace spline
{ {
template <typename genType> template <typename genType>
inline genType catmullRom( inline genType catmullRom
const genType& v1, (
const genType& v2, genType const & v1,
const genType& v3, genType const & v2,
const genType& v4, genType const & v3,
const GLMvalType& s) genType const & v4,
typename genType::value_type const & s
)
{ {
GLMvalType s1 = s; typename genType::value_type s1 = s;
GLMvalType s2 = optimum_pow::pow2(s); typename genType::value_type s2 = optimum_pow::pow2(s);
GLMvalType s3 = optimum_pow::pow3(s); typename genType::value_type s3 = optimum_pow::pow3(s);
GLMvalType f1 = -s3 + GLMvalType(2) * s2 - s; typename genType::value_type f1 = -s3 + typename genType::value_type(2) * s2 - s;
GLMvalType f2 = GLMvalType(3) * s3 - GLMvalType(5) * s2 + GLMvalType(2); typename genType::value_type f2 = typename genType::value_type(3) * s3 - typename genType::value_type(5) * s2 + typename genType::value_type(2);
GLMvalType f3 = GLMvalType(-3) * s3 + GLMvalType(4) * s2 + s; typename genType::value_type f3 = typename genType::value_type(-3) * s3 + typename genType::value_type(4) * s2 + s;
GLMvalType f4 = s3 - s2; typename genType::value_type f4 = s3 - s2;
return (f1 * v1 + f2 * v2 + f3 * v3 + f4 * v4) / GLMvalType(2); return (f1 * v1 + f2 * v2 + f3 * v3 + f4 * v4) / typename genType::value_type(2);
} }
template <typename genType> template <typename genType>
inline genType hermite( inline genType hermite
const genType& v1, (
const genType& t1, genType const & v1,
const genType& v2, genType const & t1,
const genType& t2, genType const & v2,
const GLMvalType& s) genType const & t2,
typename genType::value_type const & s
)
{ {
GLMvalType s1 = s; typename genType::value_type s1 = s;
GLMvalType s2 = optimum_pow::pow2(s); typename genType::value_type s2 = optimum_pow::pow2(s);
GLMvalType s3 = optimum_pow::pow3(s); typename genType::value_type s3 = optimum_pow::pow3(s);
GLMvalType f1 = GLMvalType(2) * s3 - GLMvalType(3) * s2 + GLMvalType(1); typename genType::value_type f1 = typename genType::value_type(2) * s3 - typename genType::value_type(3) * s2 + typename genType::value_type(1);
GLMvalType f2 = GLMvalType(-2) * s3 + GLMvalType(3) * s2; typename genType::value_type f2 = typename genType::value_type(-2) * s3 + typename genType::value_type(3) * s2;
GLMvalType f3 = s3 - GLMvalType(2) * s2 + s; typename genType::value_type f3 = s3 - typename genType::value_type(2) * s2 + s;
GLMvalType f4 = s3 - s2; typename genType::value_type f4 = s3 - s2;
return f1 * v1 + f2 * v2 + f3 * t1 + f4 * t2; return f1 * v1 + f2 * v2 + f3 * t1 + f4 * t2;
} }
template <typename genType> template <typename genType>
inline genType cubic( inline genType cubic
const genType& v1, (
const genType& v2, genType const & v1,
const genType& v3, genType const & v2,
const genType& v4, genType const & v3,
const GLMvalType& s) genType const & v4,
typename genType::value_type const & s
)
{ {
return ((v1 * s + v2) * s + v3) * s + v4; return ((v1 * s + v2) * s + v3) * s + v4;
} }

38
glm/gtx/vector_query.hpp
View File

@ -39,55 +39,55 @@ namespace glm
//! From GLM_GTX_vector_query extensions. //! From GLM_GTX_vector_query extensions.
template <typename genType> template <typename genType>
bool areCollinear( bool areCollinear(
const genType & v0, genType const & v0,
const genType & v1, genType const & v1,
const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon()); typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if two vectors are opposites. //! Check if two vectors are opposites.
//! From GLM_GTX_vector_query extensions. //! From GLM_GTX_vector_query extensions.
template <typename genType> template <typename genType>
bool areOpposite( bool areOpposite(
const genType & v0, genType const & v0,
const genType & v1, genType const & v1,
const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon()); typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if two vectors are orthogonals. //! Check if two vectors are orthogonals.
//! From GLM_GTX_vector_query extensions. //! From GLM_GTX_vector_query extensions.
template <typename genType> template <typename genType>
bool areOrthogonal( bool areOrthogonal(
const genType & v0, genType const & v0,
const genType & v1, genType const & v1,
const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon()); typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if a vector is normalized. //! Check if a vector is normalized.
//! From GLM_GTX_vector_query extensions. //! From GLM_GTX_vector_query extensions.
template <typename genType> template <typename genType>
bool isNormalized( bool isNormalized(
const genType & v, genType const & v,
const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon()); typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if a vector is null. //! Check if a vector is null.
//! From GLM_GTX_vector_query extensions. //! From GLM_GTX_vector_query extensions.
template <typename genType> template <typename genType>
bool isNull( bool isNull(
const genType& v, genType const & v,
const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon()); typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if two vectors are orthonormal. //! Check if two vectors are orthonormal.
//! From GLM_GTX_vector_query extensions. //! From GLM_GTX_vector_query extensions.
template <typename genType> template <typename genType>
bool areOrthonormal( bool areOrthonormal(
const genType & v0, genType const & v0,
const genType & v1, genType const & v1,
const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon()); typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if two vectors are similar. //! Check if two vectors are similar.
//! From GLM_GTX_vector_query extensions. //! From GLM_GTX_vector_query extensions.
template <typename genType> template <typename genType>
bool areSimilar( bool areSimilar(
const genType& v0, genType const & v0,
const genType& v1, genType const & v1,
const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon()); typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
///@} ///@}

123
glm/gtx/vector_query.inl
View File

@ -17,77 +17,100 @@ namespace gtx{
namespace vector_query namespace vector_query
{ {
template <typename T> template <typename T>
inline bool areCollinear( inline bool areCollinear
const detail::tvec2<T>& v0, (
const detail::tvec2<T>& v1, detail::tvec2<T> const & v0,
const T epsilon) detail::tvec2<T> const & v1,
T const & epsilon
)
{ {
return length(cross(detail::tvec3<T>(v0, T(0)), detail::tvec3<T>(v1, T(0)))) < epsilon; return length(cross(detail::tvec3<T>(v0, T(0)), detail::tvec3<T>(v1, T(0)))) < epsilon;
} }
template <typename T> template <typename T>
inline bool areCollinear( inline bool areCollinear
const detail::tvec3<T>& v0, (
const detail::tvec3<T>& v1, detail::tvec3<T> const & v0,
const T epsilon) detail::tvec3<T> const & v1,
T const & epsilon
)
{ {
return length(cross(v0, v1)) < epsilon; return length(cross(v0, v1)) < epsilon;
} }
template <typename T> template <typename T>
inline bool areCollinear( inline bool areCollinear
const detail::tvec4<T>& v0, (
const detail::tvec4<T>& v1, detail::tvec4<T> const & v0,
const T epsilon) detail::tvec4<T> const & v1,
T const & epsilon
)
{ {
return length(cross(detail::tvec3<T>(v0), detail::tvec3<T>(v1))) < epsilon; return length(cross(detail::tvec3<T>(v0), detail::tvec3<T>(v1))) < epsilon;
} }
template <typename genType> template <typename genType>
inline bool areOpposite( inline bool areOpposite
const genType& v0, (
const genType& v1, genType const & v0,
const GLMvalType epsilon) genType const & v1,
typename genType::value_type const & epsilon
)
{ {
assert(isNormalized(v0) && isNormalized(v1)); assert(isNormalized(v0) && isNormalized(v1));
return((genType::value_type(1) + dot(v0, v1)) <= epsilon); return((typename genType::value_type(1) + dot(v0, v1)) <= epsilon);
} }
template <typename genType> template <typename genType>
inline bool areOrthogonal( inline bool areOrthogonal
const genType& v0, (
const genType& v1, genType const & v0,
const GLMvalType epsilon) genType const & v1,
typename genType::value_type const & epsilon
)
{ {
return abs(dot(v0, v1)) <= max(GLMvalType(1), length(v0)) * max(GLMvalType(1), length(v1)) * epsilon; return abs(dot(v0, v1)) <= max(
typename genType::value_type(1),
length(v0)) * max(
typename genType::value_type(1),
length(v1)) * epsilon;
} }
template <typename genType> template <typename genType>
inline bool isNormalized( inline bool isNormalized
const genType& v, (
const GLMvalType epsilon) genType const & v,
typename genType::value_type const & epsilon
)
{ {
return abs(length(v) - GLMvalType(1)) <= GLMvalType(2) * epsilon; return abs(length(v) - GLMvalType(1)) <= GLMvalType(2) * epsilon;
} }
template <typename genType> template <typename genType>
inline bool isNull(const genType& v, const GLMvalType epsilon) inline bool isNull
(
genType const & v,
typename genType::value_type const & epsilon
)
{ {
return length(v) <= epsilon; return length(v) <= epsilon;
} }
template <typename T> template <typename T>
inline bool isCompNull( inline bool isCompNull
const T s, (
const T epsilon) T const & s,
T const & epsilon
)
{ {
return abs(s) < epsilon; return abs(s) < epsilon;
} }
template <typename T> template <typename T>
inline detail::tvec2<bool> isCompNull( inline detail::tvec2<bool> isCompNull
const detail::tvec2<T>& v, (
const T epsilon) detail::tvec2<T> const & v,
T const & epsilon)
{ {
return detail::tvec2<bool>( return detail::tvec2<bool>(
(abs(v.x) < epsilon), (abs(v.x) < epsilon),
@ -95,9 +118,11 @@ namespace vector_query
} }
template <typename T> template <typename T>
inline detail::tvec3<bool> isCompNull( inline detail::tvec3<bool> isCompNull
const detail::tvec3<T>& v, (
const T epsilon) detail::tvec3<T> const & v,
T const & epsilon
)
{ {
return detail::tvec3<bool>( return detail::tvec3<bool>(
abs(v.x) < epsilon, abs(v.x) < epsilon,
@ -106,9 +131,11 @@ namespace vector_query
} }
template <typename T> template <typename T>
inline detail::tvec4<bool> isCompNull( inline detail::tvec4<bool> isCompNull
const detail::tvec4<T>& v, (
const T epsilon) detail::tvec4<T> const & v,
T const & epsilon
)
{ {
return detail::tvec4<bool>( return detail::tvec4<bool>(
abs(v.x) < epsilon, abs(v.x) < epsilon,
@ -118,19 +145,23 @@ namespace vector_query
} }
template <typename genType> template <typename genType>
inline bool areOrthonormal( inline bool areOrthonormal
const genType& v0, (
const genType& v1, genType const & v0,
const GLMvalType epsilon) genType const & v1,
typename genType::value_type const & epsilon
)
{ {
return isNormalized(v0, epsilon) && isNormalized(v1, epsilon) && (abs(dot(v0, v1)) <= epsilon); return isNormalized(v0, epsilon) && isNormalized(v1, epsilon) && (abs(dot(v0, v1)) <= epsilon);
} }
template <typename genType> template <typename genType>
inline bool areSimilar( inline bool areSimilar
const genType& v0, (
const genType& v1, genType const & v0,
const GLMvalType epsilon) genType const & v1,
typename genType::value_type const & epsilon
)
{ {
bool similar = true; bool similar = true;
for(typename genType::size_type i = 0; similar && i < genType::value_size(); i++) for(typename genType::size_type i = 0; similar && i < genType::value_size(); i++)