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

Merge branch '0.9.1' into precision

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

48
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.
\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:
1. GCC 3.4 and higher
2. LLVM 2.3 through GCC 4.2 front-end 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>.
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
(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.
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
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.
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.
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,
you can define GLM_FORCE_INLINE before any inclusion of <glm/glm.hpp>.
To force the compiler to inline the function, using whatever capabilities that the compiler provides to do so,
GLM_FORCE_INLINE can be defined before any inclusion of <glm/glm.hpp>.
\code
#define GLM_FORCE_INLINE
@ -281,7 +281,7 @@ void foo()
\section advanced_compatibility Compatibility
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
#define GLM_FORCE_CXX98
@ -394,9 +394,10 @@ void foo()
\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:
/code
@ -409,9 +410,11 @@ void foo()
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.
**/
@ -603,27 +606,30 @@ glm::vec3 lighting(
\page pg_reference References
OpenGL 4.1 core specification:
http://www.opengl.org/registry/doc/glspec41.core.20100725.pdf
http://www.opengl.org/registry/doc/glspec41.core.20100725.pdf
GLSL 4.10 specification:
http://www.opengl.org/registry/doc/GLSLangSpec.4.10.6.clean.pdf
http://www.opengl.org/registry/doc/GLSLangSpec.4.10.6.clean.pdf
GLU 1.3 specification:
http://www.opengl.org/documentation/specs/glu/glu1_3.pdf
http://www.opengl.org/documentation/specs/glu/glu1_3.pdf
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
GLM website:
http://glm.g-truc.net
GLM OpenGL SDK page:
http://www.opengl.org/sdk/libs/GLM/
G-Truc Creation page:
http://www.g-truc.net/project-0016.html
http://www.g-truc.net/project-0016.html
The OpenGL Toolkits forum to ask questions about GLM:
http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=postlist&Board=10&page=1
http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=postlist&Board=10&page=1
**/

1
glm/core/type_vec4.hpp
View File

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

3
glm/glm.hpp
View File

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

30
glm/gtx/spline.hpp
View File

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

72
glm/gtx/spline.inl
View File

@ -12,53 +12,59 @@ namespace gtx{
namespace spline
{
template <typename genType>
inline genType catmullRom(
const genType& v1,
const genType& v2,
const genType& v3,
const genType& v4,
const GLMvalType& s)
inline genType catmullRom
(
genType const & v1,
genType const & v2,
genType const & v3,
genType const & v4,
typename genType::value_type const & s
)
{
GLMvalType s1 = s;
GLMvalType s2 = optimum_pow::pow2(s);
GLMvalType s3 = optimum_pow::pow3(s);
typename genType::value_type s1 = s;
typename genType::value_type s2 = optimum_pow::pow2(s);
typename genType::value_type s3 = optimum_pow::pow3(s);
GLMvalType f1 = -s3 + GLMvalType(2) * s2 - s;
GLMvalType f2 = GLMvalType(3) * s3 - GLMvalType(5) * s2 + GLMvalType(2);
GLMvalType f3 = GLMvalType(-3) * s3 + GLMvalType(4) * s2 + s;
GLMvalType f4 = s3 - s2;
typename genType::value_type f1 = -s3 + typename genType::value_type(2) * s2 - s;
typename genType::value_type f2 = typename genType::value_type(3) * s3 - typename genType::value_type(5) * s2 + typename genType::value_type(2);
typename genType::value_type f3 = typename genType::value_type(-3) * s3 + typename genType::value_type(4) * s2 + s;
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>
inline genType hermite(
const genType& v1,
const genType& t1,
const genType& v2,
const genType& t2,
const GLMvalType& s)
inline genType hermite
(
genType const & v1,
genType const & t1,
genType const & v2,
genType const & t2,
typename genType::value_type const & s
)
{
GLMvalType s1 = s;
GLMvalType s2 = optimum_pow::pow2(s);
GLMvalType s3 = optimum_pow::pow3(s);
typename genType::value_type s1 = s;
typename genType::value_type s2 = optimum_pow::pow2(s);
typename genType::value_type s3 = optimum_pow::pow3(s);
GLMvalType f1 = GLMvalType(2) * s3 - GLMvalType(3) * s2 + GLMvalType(1);
GLMvalType f2 = GLMvalType(-2) * s3 + GLMvalType(3) * s2;
GLMvalType f3 = s3 - GLMvalType(2) * s2 + s;
GLMvalType f4 = s3 - s2;
typename genType::value_type f1 = typename genType::value_type(2) * s3 - typename genType::value_type(3) * s2 + typename genType::value_type(1);
typename genType::value_type f2 = typename genType::value_type(-2) * s3 + typename genType::value_type(3) * s2;
typename genType::value_type f3 = s3 - typename genType::value_type(2) * s2 + s;
typename genType::value_type f4 = s3 - s2;
return f1 * v1 + f2 * v2 + f3 * t1 + f4 * t2;
}
template <typename genType>
inline genType cubic(
const genType& v1,
const genType& v2,
const genType& v3,
const genType& v4,
const GLMvalType& s)
inline genType cubic
(
genType const & v1,
genType const & v2,
genType const & v3,
genType const & v4,
typename genType::value_type const & s
)
{
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.
template <typename genType>
bool areCollinear(
const genType & v0,
const genType & v1,
const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon());
genType const & v0,
genType const & v1,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if two vectors are opposites.
//! From GLM_GTX_vector_query extensions.
template <typename genType>
bool areOpposite(
const genType & v0,
const genType & v1,
const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon());
genType const & v0,
genType const & v1,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if two vectors are orthogonals.
//! From GLM_GTX_vector_query extensions.
template <typename genType>
bool areOrthogonal(
const genType & v0,
const genType & v1,
const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon());
genType const & v0,
genType const & v1,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if a vector is normalized.
//! From GLM_GTX_vector_query extensions.
template <typename genType>
bool isNormalized(
const genType & v,
const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon());
genType const & v,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if a vector is null.
//! From GLM_GTX_vector_query extensions.
template <typename genType>
bool isNull(
const genType& v,
const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon());
genType const & v,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if two vectors are orthonormal.
//! From GLM_GTX_vector_query extensions.
template <typename genType>
bool areOrthonormal(
const genType & v0,
const genType & v1,
const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon());
genType const & v0,
genType const & v1,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if two vectors are similar.
//! From GLM_GTX_vector_query extensions.
template <typename genType>
bool areSimilar(
const genType& v0,
const genType& v1,
const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon());
genType const & v0,
genType const & v1,
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
{
template <typename T>
inline bool areCollinear(
const detail::tvec2<T>& v0,
const detail::tvec2<T>& v1,
const T epsilon)
inline bool areCollinear
(
detail::tvec2<T> const & v0,
detail::tvec2<T> const & v1,
T const & epsilon
)
{
return length(cross(detail::tvec3<T>(v0, T(0)), detail::tvec3<T>(v1, T(0)))) < epsilon;
}
template <typename T>
inline bool areCollinear(
const detail::tvec3<T>& v0,
const detail::tvec3<T>& v1,
const T epsilon)
inline bool areCollinear
(
detail::tvec3<T> const & v0,
detail::tvec3<T> const & v1,
T const & epsilon
)
{
return length(cross(v0, v1)) < epsilon;
}
template <typename T>
inline bool areCollinear(
const detail::tvec4<T>& v0,
const detail::tvec4<T>& v1,
const T epsilon)
inline bool areCollinear
(
detail::tvec4<T> const & v0,
detail::tvec4<T> const & v1,
T const & epsilon
)
{
return length(cross(detail::tvec3<T>(v0), detail::tvec3<T>(v1))) < epsilon;
}
template <typename genType>
inline bool areOpposite(
const genType& v0,
const genType& v1,
const GLMvalType epsilon)
inline bool areOpposite
(
genType const & v0,
genType const & v1,
typename genType::value_type const & epsilon
)
{
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>
inline bool areOrthogonal(
const genType& v0,
const genType& v1,
const GLMvalType epsilon)
inline bool areOrthogonal
(
genType const & v0,
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>
inline bool isNormalized(
const genType& v,
const GLMvalType epsilon)
inline bool isNormalized
(
genType const & v,
typename genType::value_type const & epsilon
)
{
return abs(length(v) - GLMvalType(1)) <= GLMvalType(2) * epsilon;
}
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;
}
template <typename T>
inline bool isCompNull(
const T s,
const T epsilon)
inline bool isCompNull
(
T const & s,
T const & epsilon
)
{
return abs(s) < epsilon;
}
template <typename T>
inline detail::tvec2<bool> isCompNull(
const detail::tvec2<T>& v,
const T epsilon)
inline detail::tvec2<bool> isCompNull
(
detail::tvec2<T> const & v,
T const & epsilon)
{
return detail::tvec2<bool>(
(abs(v.x) < epsilon),
@ -95,9 +118,11 @@ namespace vector_query
}
template <typename T>
inline detail::tvec3<bool> isCompNull(
const detail::tvec3<T>& v,
const T epsilon)
inline detail::tvec3<bool> isCompNull
(
detail::tvec3<T> const & v,
T const & epsilon
)
{
return detail::tvec3<bool>(
abs(v.x) < epsilon,
@ -106,9 +131,11 @@ namespace vector_query
}
template <typename T>
inline detail::tvec4<bool> isCompNull(
const detail::tvec4<T>& v,
const T epsilon)
inline detail::tvec4<bool> isCompNull
(
detail::tvec4<T> const & v,
T const & epsilon
)
{
return detail::tvec4<bool>(
abs(v.x) < epsilon,
@ -118,19 +145,23 @@ namespace vector_query
}
template <typename genType>
inline bool areOrthonormal(
const genType& v0,
const genType& v1,
const GLMvalType epsilon)
inline bool areOrthonormal
(
genType const & v0,
genType const & v1,
typename genType::value_type const & epsilon
)
{
return isNormalized(v0, epsilon) && isNormalized(v1, epsilon) && (abs(dot(v0, v1)) <= epsilon);
}
template <typename genType>
inline bool areSimilar(
const genType& v0,
const genType& v1,
const GLMvalType epsilon)
inline bool areSimilar
(
genType const & v0,
genType const & v1,
typename genType::value_type const & epsilon
)
{
bool similar = true;
for(typename genType::size_type i = 0; similar && i < genType::value_size(); i++)