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

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

Browse Source
This commit is contained in:
Christophe Riccio 2011-02-07 12:29:04 +00:00
commit 71eaa832ec
94 changed files with 1510 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
doc/coreModules.doxy Normal file
View File

@ -0,0 +1,58 @@
/**
\defgroup core GLM Core
\brief The core of GLM, which implements exactly and only the GLSL specification to the degree possible.
The GLM core consists of \ref core_types "C++ types that mirror GLSL types",
\ref core_funcs "C++ functions that mirror the GLSL functions". It also includes
\ref core_precision "a set of precision-based types" that can be used in the appropriate
functions. The C++ types are all based on a basic set of \ref core_template "template types".
**/
/**
\defgroup core_types Core GLSL Types
\brief The standard types defined by the GLSL specification.
These types are all typedefs of more generalized, template types. To see the definiton
of the equivalent template types, go to \ref core_template.
\ingroup core
**/
/**
\defgroup core_precision Core Precision Types
\brief Non-GLSL types that are used to define precision-based types.
The GLSL language allows the user to define the precision of a particular variable.
In OpenGL's GLSL, these precision qualifiers have no effect; they are there for compatibility
with OpenGL ES's precision qualifiers, where they \em do have an effect.
C++ has no language equivalent to precision qualifiers. So GLM provides the next-best thing:
a number of typedefs of the \ref core_template that use a particular precision.
None of these types make any guarantees about the actual precision used.
\ingroup core
**/
/**
\defgroup core_template Core Template Types
\brief The generic template types used as the basis for the core types.
These types are all templates used to define the actual \ref core_types.
\ingroup core
**/
/**
\defgroup core_funcs Core GLSL Functions
\brief The functions defined by the GLSL specification.
\ingroup core
**/

6
doc/doxyfile
View File

@ -590,7 +590,7 @@ WARN_LOGFILE =
# directories like "/usr/src/myproject". Separate the files or directories
# with spaces.
INPUT = ../glm
INPUT = ../glm .
# This tag can be used to specify the character encoding of the source files
# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
@ -607,7 +607,7 @@ INPUT_ENCODING = UTF-8
# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx
# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90
FILE_PATTERNS = *.hpp
FILE_PATTERNS = *.hpp *.doxy
# The RECURSIVE tag can be used to turn specify whether or not subdirectories
# should be searched for input files as well. Possible values are YES and NO.
@ -641,7 +641,7 @@ EXCLUDE_PATTERNS =
# wildcard * is used, a substring. Examples: ANamespace, AClass,
# AClass::ANamespace, ANamespace::*Test
EXCLUDE_SYMBOLS = detail
EXCLUDE_SYMBOLS =
# The EXAMPLE_PATH tag can be used to specify one or more files or
# directories that contain example code fragments that are included (see

114
doc/experimentalModules.doxy Normal file
View File

@ -0,0 +1,114 @@
/**
\defgroup gtc GLM Core Extensions
\brief Functions and types that GLSL does not provide, but are useful to have.
Core extensions differ from \ref gtx "experimental extensions" in that core extensions
are fairly stable. The API for experimental extensions is expected to change
significantly between versions.
You can bring all of the extensions, core or experimental, in by
including <glm/ext.hpp> Otherwise, you will have to include each extension
by including a specific file.
**/
/**
\defgroup gtc_half_float Half Float Core Extension
\ingroup gtc
\brief Defines the half-float type, along with various typedefs for vectors and matrices.
You must include <glm/glc/half_float.hpp> to get this functionality.
**/
/**
\defgroup gtc_matrix_access Matrix Access Core Extension
\ingroup gtc
\brief Defines functions that allow you to access rows or columns of a matrix easily.
You must include <glm/glc/matrix_access.hpp> to get this functionality.
**/
/**
\defgroup gtc_matrix_integer Integer Matrix Core Extension
\ingroup gtc
\brief Defines a number of matrices with integer types.
You must include <glm/glc/matrix_integer.hpp> to get this functionality.
**/
/**
\defgroup gtc_matrix_inverse Matrix Inverse Core Extension
\ingroup gtc
\brief Defines additional matrix inverting functions.
You must include <glm/glc/matrix_inverse.hpp> to get this functionality.
**/
/**
\defgroup gtc_matrix_transform Matrix Transform Core Extension
\ingroup gtc
\brief Defines functions that generate common transformation matrices.
The matrices generated by this extension use standard OpenGL fixed-function
conventions. For example, the lookAt function generates a transform from world
space into the specific eye space that the projective matrix functions (
perspective, ortho, etc) are designed to expect. The OpenGL compatibility
specifications defines the particular layout of this eye space.
You must include <glm/glc/matrix_transform.hpp> to get this functionality.
**/
/**
\defgroup gtc_quaternion Quaternion Core Extension
\ingroup gtc
\brief Defines a templated quaternion type and several quaternion operations.
You must include <glm/glc/quaternion.hpp> to get this functionality.
**/
/**
\defgroup gtc_type_precision Type Precision Core Extension
\ingroup gtc
\brief Defines specific C++-based precision types.
\ref core_precision defines types based on GLSL's precision qualifiers. This
extension defines types based on explicitly-sized C++ data types.
You must include the file <glm/glc/type_precision.hpp> to get this functionality.
**/
/**
\defgroup gtc_type_ptr Pointer Access Core Extension
\ingroup gtc
\brief Used to get a pointer to the memory layout of a basic type.
This extension defines an overloaded function, glm::value_ptr, which
takes any of the \ref core_template "core template types". It returns
a pointer to the memory layout of the object. Matrix types store their values
in row-major order.
This is useful for uploading data to matrices or copying data to buffer objects.
Example:
\code
#include <glm/glm.hpp>
#include <glm/glc/type_ptr.hpp>
glm::vec3 aVector(3);
glm::mat4 someMatrix(1.0);
glUniform3fv(uniformLoc, 1, glm::value_ptr(aVector));
glUniformMatrix4fv(uniformMatrixLoc, 1, GL_FALSE, glm::value_ptr(someMatrix));
\endcode
You must include the file <glm/glc/type_ptr.hpp> to get this functionality.
**/

500
doc/gtcModules.doxy Normal file
View File

@ -0,0 +1,500 @@
/**
\defgroup gtx GLM Experimental Extensions
\brief Functions and types that GLSL does not provide, but are useful to have.
Experimental extensions are useful functions and types, but the development of
their API and functionality is not necessarily stable. They can change substantially
between versions. Backwards compatibility is not much of an issue for them.
You can bring all of the extensions, core or experimental, in by
including <glm/ext.hpp> Otherwise, you will have to include each extension
by including a specific file.
**/
/**
\defgroup gtx_associated_min_max Associated Min/Max Experimental Extension
\ingroup gtx
\brief Min and max functions that return associated values not the compared onces.
You must include the file <glm/glx/associated_min_max.hpp> to get this functionality.
**/
/**
\defgroup gtx_bit Bitwise Operations Experimental Extension
\ingroup gtx
\brief Allow to perform bit operations on integer values
You must include the file <glm/glx/bit.hpp> to get this functionality.
**/
/**
\defgroup gtx_closest_point Find Closest Point Experimental Extension
\ingroup gtx
\brief Find the point on a straight line which is the closet of a point.
You must include the file <glm/glx/closest_point.hpp> to get this functionality.
**/
/**
\defgroup gtx_color_cast Color Conversion Experimental Extension
\ingroup gtx
\brief Conversion between two color types.
You must include the file <glm/glx/color_cast.hpp> to get this functionality.
**/
/**
\defgroup gtx_color_space RGB to HSV Conversion Experimental Extension
\ingroup gtx
\brief Related to RGB to HSV conversions and operations.
You must include the file <glm/glx/color_space.hpp> to get this functionality.
**/
/**
\defgroup gtx_color_space_YCoCg RGB to YCoCg Conversion Experimental Extension
\ingroup gtx
\brief RGB to YCoCg conversions and operations
You must include the file <glm/glx/color_space_YCoCg.hpp> to get this functionality.
**/
/**
\defgroup gtx_compatibility Cg and HLSL Compatibility Experimental Extension
\ingroup gtx
\brief Provide functions to increase the compatibility with Cg and HLSL languages
You must include the file <glm/glx/compatibility.hpp> to get this functionality.
**/
/**
\defgroup gtx_component_wise Component Wise Experimental Extension
\ingroup gtx
\brief Operations between components of a type
You must include the file <glm/glx/component_wise.hpp> to get this functionality.
**/
/**
\defgroup gtx_epsilon Epsilon Comparison Experimental Extension
\ingroup gtx
\brief Comparison functions for a user defined epsilon values.
You must include the file <glm/glx/epsilon.hpp> to get this functionality.
**/
/**
\defgroup gtx_euler_angles Matrix From Euler Angles Experimental Extension
\ingroup gtx
\brief Build matrices from Euler angles.
You must include the file <glm/glx/euler_angles.hpp> to get this functionality.
**/
/**
\defgroup gtx_extend Position Extending Experimental Extension
\ingroup gtx
\brief Extend a position from a source to a position at a defined length.
You must include the file <glm/glx/extend.hpp> to get this functionality.
**/
/**
\defgroup gtx_extented_min_max Extended Min Max Experimental Extension
\ingroup gtx
\brief Min and max functions for 3 to 4 parameters.
You must include the file <glm/glx/extented_min_max.hpp> to get this functionality.
**/
/**
\defgroup gtx_fast_exponential Fast Exponentiation Experimental Extension
\ingroup gtx
\brief Fast but less accurate implementations of exponential based functions.
You must include the file <glm/glx/fast_exponential.hpp> to get this functionality.
**/
/**
\defgroup gtx_fast_square_root Fast Square Root Experimental Extension
\ingroup gtx
\brief Fast but less accurate implementations of square root based functions.
You must include the file <glm/glx/fast_square_root.hpp> to get this functionality.
**/
/**
\defgroup gtx_fast_trigonometry Fast Trig Experimental Extension
\ingroup gtx
\brief Fast but less accurate implementations of trigonometric functions.
You must include the file <glm/glx/fast_trigonometry.hpp> to get this functionality.
**/
/**
\defgroup gtx_handed_coordinate_space Space Handedness Experimental Extension
\ingroup gtx
\brief To know if a set of three basis vectors defines a right or left-handed coordinate system.
You must include the file <glm/glx/handed_coordinate_system.hpp> to get this functionality.
**/
/**
\defgroup gtx_inertia Intertial Matrix Experimental Extension
\ingroup gtx
\brief Create inertia matrices
You must include the file <glm/glx/inertia.hpp> to get this functionality.
**/
/**
\defgroup gtx_int_10_10_10_2 Packed Integer Experimental Extension
\ingroup gtx
\brief Add support for integer for core functions
You must include the file <glm/glx/int_10_10_10_2.hpp> to get this functionality.
**/
/**
\defgroup gtx_integer Integer Function Experimental Extension
\ingroup gtx
\brief Add support for integer for core functions
You must include the file <glm/glx/integer.hpp> to get this functionality.
**/
/**
\defgroup gtx_intersect Intersection Test Experimental Extension
\ingroup gtx
\brief Add intersection functions
You must include the file <glm/glx/intersect.hpp> to get this functionality.
**/
/**
\defgroup gtx_log_base Log With Base Experimental Extension
\ingroup gtx
\brief Logarithm for any base. base can be a vector or a scalar.
You must include the file <glm/glx/log_base.hpp> to get this functionality.
**/
/**
\defgroup gtx_matrix_cross_product Cross Product Matrices Experimental Extension
\ingroup gtx
\brief Build cross product matrices
You must include the file <glm/glx/matrix_cross_product.hpp> to get this functionality.
**/
/**
\defgroup gtx_matrix_major_storage Build Matrix Experimental Extension
\ingroup gtx
\brief Build matrices with specific matrix order, row or column
You must include the file <glm/glx/matrix_major_storage.hpp> to get this functionality.
**/
/**
\defgroup gtx_matrix_operation Diagonal Matrix Experimental Extension
\ingroup gtx
\brief Build diagonal matrices from vectors.
You must include the file <glm/glx/matrix_operation.hpp> to get this functionality.
**/
/**
\defgroup gtx_matrix_query Query Matrix Properties Experimental Extension
\ingroup gtx
\brief Query to evaluate matrix properties
You must include the file <glm/glx/matrix_query.hpp> to get this functionality.
**/
/**
\defgroup gtx_mixed_product Mixed Product Experimental Extension
\ingroup gtx
\brief Mixed product of 3 vectors.
You must include the file <glm/glx/mixed_product.hpp> to get this functionality.
**/
/**
\defgroup gtx_multiple Multiples Experimental Extension
\ingroup gtx
\brief Find the closest number of a number multiple of other number.
You must include the file <glm/glx/multiple.hpp> to get this functionality.
**/
/**
\defgroup gtx_norm Vector Norm Experimental Extension
\ingroup gtx
\brief Various way to compute vector norms.
You must include the file <glm/glx/norm.hpp> to get this functionality.
**/
/**
\defgroup gtx_normal Compute Normal Experimental Extension
\ingroup gtx
\brief Compute the normal of a triangle.
You must include the file <glm/glx/normal.hpp> to get this functionality.
**/
/**
\defgroup gtx_normalize_dot Normalize Dot Product Experimental Extension
\ingroup gtx
\brief Dot product of vectors that need to be normalize with a single square root.
You must include the file <glm/glx/normalized_dot.hpp> to get this functionality.
**/
/**
\defgroup gtx_number_precision Number Precision Experimental Extension
\ingroup gtx
\brief Defined size types.
You must include the file <glm/glx/number_precision.hpp> to get this functionality.
**/
/**
\defgroup gtx_ocl_type OpenCL Types Experimental Extension
\ingroup gtx
\brief OpenCL types.
You must include the file <glm/glx/ocl_type.hpp> to get this functionality.
**/
/**
\defgroup gtx_optimum_pow Optimum Pow Experimental Extension
\ingroup gtx
\brief Integer exponentiation of power functions.
You must include the file <glm/glx/optimum_pow.hpp> to get this functionality.
**/
/**
\defgroup gtx_orthonormalize Orthonormalize Experimental Extension
\ingroup gtx
\brief Orthonormalize matrices.
You must include the file <glm/glx/orthonormalize.hpp> to get this functionality.
**/
/**
\defgroup gtx_perpendicular Perpendicular Experimental Extension
\ingroup gtx
\brief Perpendicular of a vector from other one
You must include the file <glm/glx/perpendicular.hpp> to get this functionality.
**/
/**
\defgroup gtx_polar_coordinates Polar Coordinates Experimental Extension
\ingroup gtx
\brief Conversion from Euclidean space to polar space and revert.
You must include the file <glm/glx/polar_coordinates.hpp> to get this functionality.
**/
/**
\defgroup gtx_projection Projection Experimental Extension
\ingroup gtx
\brief Projection of a vector to other one
You must include the file <glm/glx/projection.hpp> to get this functionality.
**/
/**
\defgroup gtx_quaternion Quaternion Experimental Extension
\ingroup gtx
\brief Quaternion types and functions
You must include the file <glm/glx/quaternion.hpp> to get this functionality.
**/
/**
\defgroup gtx_random Random Experimental Extension
\ingroup gtx
\brief Generate random number from various distribution methods
You must include the file <glm/glx/random.hpp> to get this functionality.
**/
/**
\defgroup gtx_raw_data Raw Data Experimental Extension
\ingroup gtx
\brief Projection of a vector to other one
You must include the file <glm/glx/raw_data.hpp> to get this functionality.
**/
/**
\defgroup gtx_reciprocal Reciprocal Experimental Extension
\ingroup gtx
\brief Define secant, cosecant and cotangent functions.
You must include the file <glm/glx/reciprocal.hpp> to get this functionality.
**/
/**
\defgroup gtx_rotate_vector Rotate Vector Experimental Extension
\ingroup gtx
\brief Function to directly rotate a vector
You must include the file <glm/glx/rotate_vector.hpp> to get this functionality.
**/
/**
\defgroup gtx_simd_mat4 SIMD Mat4 Experimental Extension
\ingroup gtx
\brief SIMD implementation of mat4 type.
You must include the file <glm/glx/simd_mat4.hpp> to get this functionality.
**/
/**
\defgroup gtx_simd_vec4 SIMD Vec4 Experimental Extension
\ingroup gtx
\brief SIMD implementation of vec4 type.
You must include the file <glm/glx/simd_vec4.hpp> to get this functionality.
**/
/**
\defgroup gtx_spline Spline Experimental Extension
\ingroup gtx
\brief Spline functions
You must include the file <glm/glx/spline.hpp> to get this functionality.
**/
/**
\defgroup gtx_string_cast String Cast Experimental Extension
\ingroup gtx
\brief Setup strings for GLM type values
You must include the file <glm/glx/transform.hpp> to get this functionality.
**/
/**
\defgroup gtx_transform Transformation Matrices Experimental Extension
\ingroup gtx
\brief Add transformation matrices
You must include the file <glm/glx/transform2.hpp> to get this functionality.
**/
/**
\defgroup gtx_transform2 Extra Transform Matrices Experimental Extension
\ingroup gtx
\brief Add extra transformation matrices
You must include the file <glm/glx/unsigned_int.hpp> to get this functionality.
**/
/**
\defgroup gtx_unsigned_int Unsigned Int Experimental Extension
\ingroup gtx
\brief Add support for unsigned integer for core functions
You must include the file <glm/glx/unsigned_int.hpp> to get this functionality.
**/
/**
\defgroup gtx_vector_access Vector Access Experimental Extension
\ingroup gtx
\brief Function to set values to vectors
You must include the file <glm/glx/vector_access.hpp> to get this functionality.
**/
/**
\defgroup gtx_vector_angle Vector Angle Experimental Extension
\ingroup gtx
\brief Compute angle between vectors
You must include the file <glm/glx/vector_angle.hpp> to get this functionality.
**/
/**
\defgroup gtx_vector_query Vector Query Experimental Extension
\ingroup gtx
\brief Query informations of vector types
You must include the file <glm/glx/vector_query.hpp> to get this functionality.
**/
/**
\defgroup gtx_verbose_operator Verbose Operator Experimental Extension
\ingroup gtx
\brief Use words to replace operators
You must include the file <glm/glx/verbose_operator.hpp> to get this functionality.
**/
/**
\defgroup gtx_wrap Wrap Experimental Extension
\ingroup gtx
\brief Wrapping mode using my texture samping.
You must include the file <glm/glx/wrap.hpp> to get this functionality.
**/

268
doc/pages.doxy Normal file
View File

@ -0,0 +1,268 @@
/**
\mainpage OpenGL Mathematics
OpenGL Mathematics (GLM) is a C++ mathematics library for 3D applications based
on the OpenGL Shading Language (GLSL) specification.
GLM provides 3D programmers with math classes and functions that are similar to
GLSL or any high level GPU programming language. The idea is to have a library
that has identical naming conventions and functionalities than GLSL so that when
developers know GLSL, they know how to use GLM.
GLM is not limited strictly to GLSL features.
However, this project isn't limited by GLSL features. An extension system, based
on the GLSL extension conventions, allows extended capabilities.
This library can be used with OpenGL but also for software rendering (Raytracing
/ Rasterisation), image processing and as much contexts as a simple math library
could be used for.
GLM is written as a platform independent library. The following compilers are
officially supported:
\li GNU GCC 3.4 and higher
\li Microsoft Visual Studio 8.0 and higher
The source code is under the
<a href="http://www.opensource.org/licenses/mit-license.php">MIT licence</a>.
Any feedback is welcome and can be sent to glm@g-truc.net.
\li \subpage started
\li \subpage faq
\li \subpage issues
\li \subpage reference
**/
/**
\page started Getting Started
\section started_compiler Compiler Setup
GLM is a header library. Therefore, it doesn't require to be built separately. All that
is necessary to use GLM is to add the GLM install path to your compiler's include
search paths. (-I option with GCC) Alternatively, you can copy the GLM files directly into your
project's source directory.
GLM makes heavy use of C++ templates. This may significantly increase the compile
time for files that use GLM. If this is a problem for your needs, precompiled headers
are a good solution for avoiding this issue.
\section started_core Core Features
After initial compiler setup, all core features of GLM (core GLSL features) can be accessed
by including the glm.hpp header. The line: #include <glm/glm.hpp> is used for a typical
compiler setup.
Note that by default there are no dependencies on external headers like gl.h, gl3.h, glu.h or
windows.h.
\section started_swizzle Setup of Swizzle Operators
A common feature of shader languages like GLSL is components swizzling. This involves
being able to select which components of a vector are used and in what order. For
example, "variable.x", "variable.xxy", "variable.zxyy" are examples of swizzling.
However in GLM, swizzling operators are disabled by default. To enable swizzling the
define GLM_SWIZZLE must be defined to one of GLM_SWIZZLE_XYZW, GLM_SWIZZLE_RGBA,
GLM_SWIZZLE_STQP or GLM_SWIZZLE_FULL depending on what swizzle syntax is required.
To enable swizzling, it is suggested that setup.hpp be included first, then custom
settings and finally glm.hpp. For
example:
\code
#include <glm/setup.hpp>
#define GLM_SWIZZLE GLM_SWIZZLE_FULL
#include <glm/glm.hpp>
\endcode
These custom setup lines can then be placed in a common project header or precompiled
header.
\section started_sample Basic Use of GLM Core
\code
#include <glm/glm.hpp>
int foo()
{
glm::vec4 Position = glm::vec4(glm::vec3(0.0), 1.0);
glm::mat4 Model = glm::mat4(1.0);
Model[4] = glm::vec4(1.0, 1.0, 0.0, 1.0);
glm::vec4 Transformed = Model * Position;
return 0;
}
\endcode
\section started_extensions GLM Extensions
GLM extends the core GLSL feature set with extensions. These extensions include:
quaternion, transformation, spline, matrix inverse, color spaces, etc.
Note that some extensions are incompatible with other extension as and may result in C++
name collisions when used together.
To use a particular extension, simply include the extension header file. All
extension features are added to the glm namespace.
\code
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
int foo()
{
glm::vec4 Position = glm::vec4(glm::vec3(0.0f), 1.0f);
glm::mat4 Model = glm::translate(1.0f, 1.0f, 1.0f);
glm::vec4 Transformed = Model * Position;
return 0;
}
\endcode
\section started_depend Dependencies
When <glm/glm.hpp> is included, GLM provides all the GLSL features it implements in C++.
By including <glm/ext.hpp> all the features of all extensions of GLM are included.
When you include a specific extension, all the dependent extensions will be included as well.
All the extensions depend on GLM core. (<glm/glm.hpp>)
GLM has no dependencies on external libraries. However, if <boost/static_assert.hpp> is
included before the GLM headers, boost::static_assert will be used all over GLM code.
**/
/**
\page faq FAQ
\section faq1 Why GLM follows GLSL specification and conventions?
Following GLSL conventions is a really strict policy of GLM. GLM has been designed following
the idea that everyone does its own math library with his own conventions. The idea is that
brilliant developers (the OpenGL ARB) worked together and agreed to make GLSL. Following
GLSL conventions is a way to find consensus. Moreover, basically when a developer knows
GLSL, he knows GLM.
\section faq2 Would it be possible to add my feature?
YES. Every feature request could be added by submitting it here:
https://sourceforge.net/apps/trac/ogl-math/newticket
These requests would mainly take the form of extensions and if you provide an
implementation, the feature will be added automatically in the next GLM release.
A SourceForge.net account is required to create a ticket.
\section faq3 Does GLM run GLSL program?
No, GLM is a C++ implementation of a subset of GLSL.
\section faq4 Does a GLSL compiler build GLM codes?
Not directly but it can be easy to port. However, the difference between a shader and C++
program at software design level will probably make this idea unlikely or impossible.
\section faq5 Should I use GTX extensions?
GTX extensions are qualified to be experimental extensions. In GLM this means that these
extensions might change from version to version without restriction. In practice, it doesn't
really change except time to time. GTC extensions are stabled, tested and perfectly reliable
in time. Many GTX extensions extend GTC extensions and provide a way to explore features
and implementations before becoming stable by a promotion as GTC extensions. This is
fairly the way OpenGL features are developed through extensions.
\section faq6 Would it be possible to change GLM to do glVertex3fv(glm::vec3(0))?
It's possible to implement such thing in C++ with the implementation of the appropriate cast
operator. In this example it's likely because it would result as a transparent cast, however,
most of the time it's really unlikely resulting of build with no error and programs running
with unexpected behaviors.
GLM_GTC_type_ptr extension provide a safe solution:
\code
glm::vec4 v(0);
glm::mat4 m(0);
glVertex3fv(glm::value_ptr(v))
glLoadMatrixfv(glm::value_ptr(m));
\endcode
Another solution inspired by STL:
\code
glVertex3fv(&v[0]);
glLoadMatrixfv(&m[0][0]);
\endcode
\section faq7 Where can I ask my questions?
A good place is the OpenGL Toolkits forum on OpenGL.org:
http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=postlist&Board=10&page=1
\section faq8 Where can I report a bug?
Just like feature requests:
https://sourceforge.net/apps/trac/ogl-math/newticket
A SourceForge account is required to create a ticket.
\section faq8 Where can I find the documentation of extensions?
The Doxygen generated documentation includes a complete list of all extensions available.
Explore this documentation to get a complete view of all GLM capabilities!
http://glm.g-truc.net/html/index.html
\section faq9 Should I use 'using namespace glm;'?
NO! Chances are that if 'using namespace glm;' is called, name collisions will happen
because GLM is based on GLSL and GLSL is also a consensus on tokens so these tokens are
probably used quite often.
**/
/**
\page issues Known Issues
\section issue1 Swizzle Operators
Enabling the swizzle operator can result in name collisions with the Win32 API.
Consequently swizzle operators are disable by default. A safer way to do swizzling is to use
the member function 'swizzle'. Future version of GLM should remove this limitation.
\section issue2 not Function
The GLSL keyword not is also a keyword in C++. To prevent name collisions, the GLSL not
function has been implemented with the name not_.
\section issue3 Half Based Types
GLM supports half float number types through the extension GLM_GTC_half_float. This
extension provides the types half, hvec*, hmat*x* and hquat*.
Unfortunately, C++ norm doesn't support anonymous unions which limit hvec* vector
components access to x, y, z and w.
However, Visual C++ does support anonymous unions. When
GLM_USE_ANONYMOUS_UNION is define, it enables the support of all component names
(x,y,z,w ; r,g,b,a ; s,t,p,q). With GCC it will result in a build error.
**/
/**
\page reference References
OpenGL 4.1 core specification:
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
GLM HEAD snapshot:
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:
https://sourceforge.net/apps/trac/ogl-math
GLM website:
http://glm.g-truc.net
G-Truc Creation page:
http://www.g-truc.net/project-0016.html
**/

5
glm/core/func_common.hpp
View File

@ -21,6 +21,9 @@ namespace glm
//! Define common functions from Section 8.3 of GLSL 1.30.8 specification. Included in glm namespace.
namespace common{
/// \addtogroup core_funcs
///@{
//! Returns x if x >= 0; otherwise, it returns -x.
//! (From GLSL 1.30.08 specification, section 8.3)
template <typename genFIType>
@ -262,6 +265,8 @@ namespace glm
template <typename genType, typename genIType>
genType ldexp(genType const & x, genIType const & exp);
///@}
}//namespace common
}//namespace function
}//namespace core

5
glm/core/func_exponential.hpp
View File

@ -21,6 +21,9 @@ namespace glm
//! Define all exponential functions from Section 8.2 of GLSL 1.30.8 specification. Included in glm namespace.
namespace exponential{
/// \addtogroup core_funcs
///@{
//! Returns x raised to the y power.
//! (From GLSL 1.30.08 specification, section 8.2)
template <typename genType>
@ -59,6 +62,8 @@ namespace glm
template <typename genType>
genType inversesqrt(genType const & x);
///@}
}//namespace exponential
}//namespace function
}//namespace core

5
glm/core/func_geometric.hpp
View File

@ -21,6 +21,9 @@ namespace glm
//! Define all geometric functions from Section 8.4 of GLSL 1.30.8 specification. Included in glm namespace.
namespace geometric{
/// \addtogroup core_funcs
///@{
//! Returns the length of x, i.e., sqrt(x * x).
//! (From GLSL 1.30.08 specification, section 8.4)
template <typename genType>
@ -80,6 +83,8 @@ namespace glm
genType const & N,
typename genType::value_type const & eta);
///@}
}//namespace geometric
}//namespace function
}//namespace core

5
glm/core/func_integer.hpp
View File

@ -21,6 +21,9 @@ namespace glm
//! Define integer functions from Section 8.8 of GLSL 4.00.8 specification.
namespace integer{
/// \addtogroup core_funcs
///@{
//! Adds 32-bit unsigned integer x and y, returning the sum
//! modulo pow(2, 32). The value carry is set to 0 if the sum was
//! less than pow(2, 32), or to 1 otherwise.
@ -128,6 +131,8 @@ namespace glm
template <typename T, template <typename> class C>
typename C<T>::signed_type findMSB(C<T> const & Value);
///@}
}//namespace integer
}//namespace function
}//namespace core

5
glm/core/func_matrix.hpp
View File

@ -21,6 +21,9 @@ namespace glm
//! Define all matrix functions from Section 8.5 of GLSL 1.30.8 specification. Included in glm namespace.
namespace matrix{
/// \addtogroup core_funcs
///@{
//! Multiply matrix x by matrix y component-wise, i.e.,
//! result[i][j] is the scalar product of x[i][j] and y[i][j].
//! (From GLSL 1.30.08 specification, section 8.5)
@ -80,6 +83,8 @@ namespace glm
detail::tmat4x4<T> inverse(
detail::tmat4x4<T> const & m);
///@}
}//namespace matrix
}//namespace function
}//namespace core

5
glm/core/func_noise.hpp
View File

@ -21,6 +21,9 @@ namespace glm
// Define all noise functions from Section 8.9 of GLSL 1.30.8 specification. Included in glm namespace.
namespace noise{
/// \addtogroup core_funcs
///@{
// Returns a 1D noise value based on the input value x.
// From GLSL 1.30.08 specification, section 8.9.
template <typename genType>
@ -41,6 +44,8 @@ namespace glm
template <typename genType>
detail::tvec4<typename genType::value_type> noise4(genType const & x);
///@}
}//namespace noise
}//namespace function
}//namespace core

5
glm/core/func_packing.hpp
View File

@ -21,6 +21,9 @@ namespace glm
//! Define packing functions from section 8.4 floating-point pack and unpack functions of GLSL 4.00.8 specification
namespace packing
{
/// \addtogroup core_funcs
///@{
detail::uint32 packUnorm2x16(detail::tvec2<detail::float32> const & v);
detail::uint32 packUnorm4x8(detail::tvec4<detail::float32> const & v);
detail::uint32 packSnorm4x8(detail::tvec4<detail::float32> const & v);
@ -32,6 +35,8 @@ namespace glm
double packDouble2x32(detail::tvec2<detail::uint32> const & v);
detail::tvec2<detail::uint32> unpackDouble2x32(double const & v);
///@}
}//namespace packing
}//namespace function
}//namespace core

5
glm/core/func_trigonometric.hpp
View File

@ -23,6 +23,9 @@ namespace glm
//! Included in glm namespace.
namespace trigonometric{
/// \addtogroup core_funcs
///@{
//! Converts degrees to radians and returns the result.
//! (From GLSL 1.30.08 specification, section 8.1)
template <typename genType>
@ -111,6 +114,8 @@ namespace glm
template <typename genType>
genType atanh(genType const & x);
///@}
}//namespace trigonometric
}//namespace function
}//namespace core

5
glm/core/func_vector_relational.hpp
View File

@ -24,6 +24,9 @@ namespace glm
//! Included in glm namespace.
namespace vector_relational
{
/// \addtogroup core_funcs
///@{
//! Returns the component-wise comparison result of x < y.
//! (From GLSL 1.30.08 specification, section 8.6)
template <typename T, template <typename> class vecType>
@ -183,6 +186,8 @@ namespace glm
return Result;
}
///@}
}//namespace vector_relational
}//namespace function
}//namespace core

39
glm/core/type.hpp
View File

@ -80,64 +80,79 @@ namespace type
#else
//! 2 components vector of floating-point numbers.
//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
//! \ingroup core_types
typedef precision::mediump_vec2 vec2;
//! 3 components vector of floating-point numbers.
//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
//! \ingroup core_types
typedef precision::mediump_vec3 vec3;
//! 4 components vector of floating-point numbers.
//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
//! \ingroup core_types
typedef precision::mediump_vec4 vec4;
//! 2 columns of 2 components matrix of floating-point numbers.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
//! \ingroup core_types
typedef precision::mediump_mat2x2 mat2x2;
//! 2 columns of 3 components matrix of floating-point numbers.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
//! \ingroup core_types
typedef precision::mediump_mat2x3 mat2x3;
//! 2 columns of 4 components matrix of floating-point numbers.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
//! \ingroup core_types
typedef precision::mediump_mat2x4 mat2x4;
//! 3 columns of 2 components matrix of floating-point numbers.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
//! \ingroup core_types
typedef precision::mediump_mat3x2 mat3x2;
//! 3 columns of 3 components matrix of floating-point numbers.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
//! \ingroup core_types
typedef precision::mediump_mat3x3 mat3x3;
//! 3 columns of 4 components matrix of floating-point numbers.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
//! \ingroup core_types
typedef precision::mediump_mat3x4 mat3x4;
//! 4 columns of 2 components matrix of floating-point numbers.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
//! \ingroup core_types
typedef precision::mediump_mat4x2 mat4x2;
//! 4 columns of 3 components matrix of floating-point numbers.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
//! \ingroup core_types
typedef precision::mediump_mat4x3 mat4x3;
//! 4 columns of 4 components matrix of floating-point numbers.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
//! \ingroup core_types
typedef precision::mediump_mat4x4 mat4x4;
#endif//GLM_PRECISION
//! 2 columns of 2 components matrix of floating-point numbers.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
//! \ingroup core_types
typedef mat2x2 mat2;
//! 3 columns of 3 components matrix of floating-point numbers.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
//! \ingroup core_types
typedef mat3x3 mat3;
//! 4 columns of 4 components matrix of floating-point numbers.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
//! \ingroup core_types
typedef mat4x4 mat4;
//////////////////////////
@ -158,14 +173,17 @@ namespace type
#else
//! 2 components vector of signed integer numbers.
//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
//! \ingroup core_types
typedef precision::mediump_ivec2 ivec2;
//! 3 components vector of signed integer numbers.
//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
//! \ingroup core_types
typedef precision::mediump_ivec3 ivec3;
//! 4 components vector of signed integer numbers.
//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
//! \ingroup core_types
typedef precision::mediump_ivec4 ivec4;
#endif//GLM_PRECISION
@ -187,14 +205,17 @@ namespace type
#else
//! 2 components vector of unsigned integer numbers.
//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
//! \ingroup core_types
typedef precision::mediump_uvec2 uvec2;
//! 3 components vector of unsigned integer numbers.
//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
//! \ingroup core_types
typedef precision::mediump_uvec3 uvec3;
//! 4 components vector of unsigned integer numbers.
//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
//! \ingroup core_types
typedef precision::mediump_uvec4 uvec4;
#endif//GLM_PRECISION
@ -203,14 +224,17 @@ namespace type
//! 2 components vector of boolean.
//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
//! \ingroup core_types
typedef detail::tvec2<bool> bvec2;
//! 3 components vector of boolean.
//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
//! \ingroup core_types
typedef detail::tvec3<bool> bvec3;
//! 4 components vector of boolean.
//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
//! \ingroup core_types
typedef detail::tvec4<bool> bvec4;
//////////////////////////
@ -218,62 +242,77 @@ namespace type
//! Vector of 2 double-precision floating-point numbers.
//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
//! \ingroup core_types
typedef detail::tvec2<double> dvec2;
//! Vector of 3 double-precision floating-point numbers.
//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
//! \ingroup core_types
typedef detail::tvec3<double> dvec3;
//! Vector of 4 double-precision floating-point numbers.
//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
//! \ingroup core_types
typedef detail::tvec4<double> dvec4;
//! 2 * 2 matrix of double-precision floating-point numbers.
//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
//! \ingroup core_types
typedef detail::tmat2x2<double> dmat2;
//! 3 * 3 matrix of double-precision floating-point numbers.
//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
//! \ingroup core_types
typedef detail::tmat3x3<double> dmat3;
//! 4 * 4 matrix of double-precision floating-point numbers.
//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
//! \ingroup core_types
typedef detail::tmat4x4<double> dmat4;
//! 2 * 2 matrix of double-precision floating-point numbers.
//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
//! \ingroup core_types
typedef detail::tmat2x2<double> dmat2x2;
//! 2 * 3 matrix of double-precision floating-point numbers.
//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
//! \ingroup core_types
typedef detail::tmat2x3<double> dmat2x3;
//! 2 * 4 matrix of double-precision floating-point numbers.
//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
//! \ingroup core_types
typedef detail::tmat2x4<double> dmat2x4;
//! 3 * 2 matrix of double-precision floating-point numbers.
//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
//! \ingroup core_types
typedef detail::tmat3x2<double> dmat3x2;
//! 3 * 3 matrix of double-precision floating-point numbers.
//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
//! \ingroup core_types
typedef detail::tmat3x3<double> dmat3x3;
//! 3 * 4 matrix of double-precision floating-point numbers.
//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
//! \ingroup core_types
typedef detail::tmat3x4<double> dmat3x4;
//! 4 * 2 matrix of double-precision floating-point numbers.
//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
//! \ingroup core_types
typedef detail::tmat4x2<double> dmat4x2;
//! 4 * 3 matrix of double-precision floating-point numbers.
//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
//! \ingroup core_types
typedef detail::tmat4x3<double> dmat4x3;
//! 4 * 4 matrix of double-precision floating-point numbers.
//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
//! \ingroup core_types
typedef detail::tmat4x4<double> dmat4x4;
}//namespace type

9
glm/core/type_float.hpp
View File

@ -38,16 +38,19 @@ namespace glm
typedef double highp_float_t;
//! Low precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification
//! \ingroup core_precision
typedef lowp_float_t lowp_float;
//! Medium precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification
//! \ingroup core_precision
typedef mediump_float_t mediump_float;
//! High precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification
//! \ingroup core_precision
typedef highp_float_t highp_float;
}
//namespace precision

2
glm/core/type_half.hpp
View File

@ -27,6 +27,8 @@ namespace glm
float toFloat32(hdata value);
hdata toFloat16(float const & value);
///16-bit floating point type.
/// \ingroup gtc_half_float
class thalf
{
public:

19
glm/core/type_int.hpp
View File

@ -63,32 +63,39 @@ namespace glm
namespace core{
namespace type{
///namespace for precision stuff.
namespace precision
{
//! Low precision signed integer.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification.
//! \ingroup core_precision
typedef detail::lowp_int_t lowp_int;
//! Medium precision signed integer.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification.
//! \ingroup core_precision
typedef detail::mediump_int_t mediump_int;
//! High precision signed integer.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification.
//! \ingroup core_precision
typedef detail::highp_int_t highp_int;
//! Low precision unsigned integer.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification.
//! \ingroup core_precision
typedef detail::lowp_uint_t lowp_uint;
//! Medium precision unsigned integer.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification.
//! \ingroup core_precision
typedef detail::mediump_uint_t mediump_uint;
//! High precision unsigned integer.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification.
//! \ingroup core_precision
typedef detail::highp_uint_t highp_uint;
}
//namespace precision

12
glm/core/type_mat2x2.hpp
View File

@ -35,7 +35,8 @@ namespace glm
template <typename T> struct tmat4x3;
template <typename T> struct tmat4x4;
//!< \brief Template for 2 * 2 matrix of floating-point numbers.
//! \brief Template for 2 * 2 matrix of floating-point numbers.
//! \ingroup core_template
template <typename T>
struct tmat2x2
{
@ -222,16 +223,19 @@ namespace glm
namespace precision
{
//! 2 columns of 2 components matrix of low precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
//! \ingroup core_precision
typedef detail::tmat2x2<lowp_float> lowp_mat2x2;
//! 2 columns of 2 components matrix of medium precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
//! \ingroup core_precision
typedef detail::tmat2x2<mediump_float> mediump_mat2x2;
//! 2 columns of 2 components matrix of high precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
//! \ingroup core_precision
typedef detail::tmat2x2<highp_float> highp_mat2x2;
}
//namespace precision

12
glm/core/type_mat2x3.hpp
View File

@ -35,7 +35,8 @@ namespace glm
template <typename T> struct tmat4x3;
template <typename T> struct tmat4x4;
//!< \brief Template for 2 columns and 3 rows matrix of floating-point numbers.
//! \brief Template for 2 columns and 3 rows matrix of floating-point numbers.
//! \ingroup core_template
template <typename T>
struct tmat2x3
{
@ -189,16 +190,19 @@ namespace glm
namespace precision
{
//! 2 columns of 3 components matrix of low precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
//! \ingroup core_precision
typedef detail::tmat2x3<lowp_float> lowp_mat2x3;
//! 2 columns of 3 components matrix of medium precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
//! \ingroup core_precision
typedef detail::tmat2x3<mediump_float> mediump_mat2x3;
//! 2 columns of 3 components matrix of high precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
//! \ingroup core_precision
typedef detail::tmat2x3<highp_float> highp_mat2x3;
}
//namespace precision

9
glm/core/type_mat2x4.hpp
View File

@ -35,7 +35,8 @@ namespace glm
template <typename T> struct tmat4x3;
template <typename T> struct tmat4x4;
//!< \brief Template for 2 columns and 4 rows matrix of floating-point numbers.
//! Template for 2 columns and 4 rows matrix of floating-point numbers.
//! \ingroup core_template
template <typename T>
struct tmat2x4
{
@ -189,15 +190,15 @@ namespace glm
namespace precision
{
//! 2 columns of 4 components matrix of low precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
typedef detail::tmat2x4<lowp_float> lowp_mat2x4;
//! 2 columns of 4 components matrix of medium precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
typedef detail::tmat2x4<mediump_float> mediump_mat2x4;
//! 2 columns of 4 components matrix of high precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
typedef detail::tmat2x4<highp_float> highp_mat2x4;
}

9
glm/core/type_mat3x2.hpp
View File

@ -35,7 +35,8 @@ namespace glm
template <typename T> struct tmat4x3;
template <typename T> struct tmat4x4;
//!< \brief Template for 3 columns and 2 rows matrix of floating-point numbers.
//! \brief Template for 3 columns and 2 rows matrix of floating-point numbers.
//! \ingroup core_template
template <typename T>
struct tmat3x2
{
@ -191,15 +192,15 @@ namespace glm
namespace precision
{
//! 3 columns of 2 components matrix of low precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
typedef detail::tmat3x2<lowp_float> lowp_mat3x2;
//! 3 columns of 2 components matrix of medium precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
typedef detail::tmat3x2<mediump_float> mediump_mat3x2;
//! 3 columns of 2 components matrix of high precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
typedef detail::tmat3x2<highp_float> highp_mat3x2;
}

12
glm/core/type_mat3x3.hpp
View File

@ -35,7 +35,8 @@ namespace glm
template <typename T> struct tmat4x3;
template <typename T> struct tmat4x4;
//!< \brief Template for 3 * 3 matrix of floating-point numbers.
//! \brief Template for 3 * 3 matrix of floating-point numbers.
//! \ingroup core_template
template <typename T>
struct tmat3x3
{
@ -221,16 +222,19 @@ namespace glm
namespace precision
{
//! 3 columns of 3 components matrix of low precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
//! \ingroup core_precision
typedef detail::tmat3x3<lowp_float> lowp_mat3x3;
//! 3 columns of 3 components matrix of medium precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
//! \ingroup core_precision
typedef detail::tmat3x3<mediump_float> mediump_mat3x3;
//! 3 columns of 3 components matrix of high precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
//! \ingroup core_precision
typedef detail::tmat3x3<highp_float> highp_mat3x3;
}
//namespace precision

9
glm/core/type_mat3x4.hpp
View File

@ -35,7 +35,8 @@ namespace glm
template <typename T> struct tmat4x3;
template <typename T> struct tmat4x4;
//!< \brief Template for 3 columns and 4 rows matrix of floating-point numbers.
//! \brief Template for 3 columns and 4 rows matrix of floating-point numbers.
//! \ingroup core_template
template <typename T>
struct tmat3x4
{
@ -191,15 +192,15 @@ namespace glm
namespace precision
{
//! 3 columns of 4 components matrix of low precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
typedef detail::tmat3x4<lowp_float> lowp_mat3x4;
//! 3 columns of 4 components matrix of medium precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
typedef detail::tmat3x4<mediump_float> mediump_mat3x4;
//! 3 columns of 4 components matrix of high precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
typedef detail::tmat3x4<highp_float> highp_mat3x4;
}

12
glm/core/type_mat4x2.hpp
View File

@ -35,7 +35,8 @@ namespace glm
template <typename T> struct tmat4x3;
template <typename T> struct tmat4x4;
//!< \brief Template for 4 columns and 2 rows matrix of floating-point numbers.
//! \brief Template for 4 columns and 2 rows matrix of floating-point numbers.
//! \ingroup core_template
template <typename T>
struct tmat4x2
{
@ -193,16 +194,19 @@ namespace glm
namespace precision
{
//! 4 columns of 2 components matrix of low precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
//! \ingroup core_precision
typedef detail::tmat4x2<lowp_float> lowp_mat4x2;
//! 4 columns of 2 components matrix of medium precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
//! \ingroup core_precision
typedef detail::tmat4x2<mediump_float> mediump_mat4x2;
//! 4 columns of 2 components matrix of high precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
//! \ingroup core_precision
typedef detail::tmat4x2<highp_float> highp_mat4x2;
}
//namespace precision

12
glm/core/type_mat4x3.hpp
View File

@ -35,7 +35,8 @@ namespace glm
template <typename T> struct tmat4x3;
template <typename T> struct tmat4x4;
//!< \brief Template for 4 columns and 3 rows matrix of floating-point numbers.
//! \brief Template for 4 columns and 3 rows matrix of floating-point numbers.
//! \ingroup core_template
template <typename T>
struct tmat4x3
{
@ -193,16 +194,19 @@ namespace glm
namespace precision
{
//! 4 columns of 3 components matrix of low precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
//! \ingroup core_precision
typedef detail::tmat4x3<lowp_float> lowp_mat4x3;
//! 4 columns of 3 components matrix of medium precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
//! \ingroup core_precision
typedef detail::tmat4x3<mediump_float> mediump_mat4x3;
//! 4 columns of 3 components matrix of high precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
//! \ingroup core_precision
typedef detail::tmat4x3<highp_float> highp_mat4x3;
}
//namespace precision

12
glm/core/type_mat4x4.hpp
View File

@ -35,7 +35,8 @@ namespace glm
template <typename T> struct tmat4x3;
template <typename T> struct tmat4x4;
//!< \brief Template for 4 * 4 matrix of floating-point numbers.
//! \brief Template for 4 * 4 matrix of floating-point numbers.
//! \ingroup core_template
template <typename T>
struct tmat4x4
{
@ -221,16 +222,19 @@ namespace glm
namespace precision
{
//! 4 columns of 4 components matrix of low precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
//! \ingroup core_precision
typedef detail::tmat4x4<lowp_float> lowp_mat4x4;
//! 4 columns of 4 components matrix of medium precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
//! \ingroup core_precision
typedef detail::tmat4x4<mediump_float> mediump_mat4x4;
//! 4 columns of 4 components matrix of high precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
//! \ingroup core_precision
typedef detail::tmat4x4<highp_float> highp_mat4x4;
}
//namespace precision

29
glm/core/type_vec2.hpp
View File

@ -32,6 +32,8 @@ namespace glm
template <typename T> struct tvec3;
template <typename T> struct tvec4;
//! The basic 2D vector type.
//! \ingroup core_template
template <typename T>
struct tvec2
{
@ -203,42 +205,51 @@ namespace glm
namespace precision
{
//! 2 components vector of high precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec2<highp_float> highp_vec2;
//! 2 components vector of medium precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec2<mediump_float> mediump_vec2;
//! 2 components vector of low precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec2<lowp_float> lowp_vec2;
//! 2 components vector of high precision signed integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec2<highp_int> highp_ivec2;
//! 2 components vector of medium precision signed integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec2<mediump_int> mediump_ivec2;
//! 2 components vector of low precision signed integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec2<lowp_int> lowp_ivec2;
//! 2 components vector of high precision unsigned integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec2<highp_uint> highp_uvec2;
//! 2 components vector of medium precision unsigned integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec2<mediump_uint> mediump_uvec2;
//! 2 components vector of low precision unsigned integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec2<lowp_uint> lowp_uvec2;
}
//namespace precision

29
glm/core/type_vec3.hpp
View File

@ -31,6 +31,8 @@ namespace glm
template <typename T> struct tvec2;
template <typename T> struct tvec4;
//! Basic 3D vector type.
//! \ingroup core_template
template <typename T>
struct tvec3
{
@ -208,42 +210,51 @@ namespace glm
namespace precision
{
//! 3 components vector of high precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec3<highp_float> highp_vec3;
//! 3 components vector of medium precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec3<mediump_float> mediump_vec3;
//! 3 components vector of low precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec3<lowp_float> lowp_vec3;
//! 3 components vector of high precision signed integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec3<highp_int> highp_ivec3;
//! 3 components vector of medium precision signed integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec3<mediump_int> mediump_ivec3;
//! 3 components vector of low precision signed integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec3<lowp_int> lowp_ivec3;
//! 3 components vector of high precision unsigned integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec3<highp_uint> highp_uvec3;
//! 3 components vector of medium precision unsigned integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec3<mediump_uint> mediump_uvec3;
//! 3 components vector of low precision unsigned integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec3<lowp_uint> lowp_uvec3;
}
//namespace precision

29
glm/core/type_vec4.hpp
View File

@ -32,6 +32,8 @@ namespace glm
template <typename T> struct tvec2;
template <typename T> struct tvec3;
///Basic 4D vector type.
//! \ingroup core_template
template <typename T>
struct tvec4
{
@ -225,42 +227,51 @@ namespace glm
namespace precision
{
//! 4 components vector of high precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec4<highp_float> highp_vec4;
//! 4 components vector of medium precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec4<mediump_float> mediump_vec4;
//! 4 components vector of low precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec4<lowp_float> lowp_vec4;
//! 4 components vector of high precision signed integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec4<highp_int> highp_ivec4;
//! 4 components vector of medium precision signed integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec4<mediump_int> mediump_ivec4;
//! 4 components vector of low precision signed integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec4<lowp_int> lowp_ivec4;
//! 4 components vector of high precision unsigned integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec4<highp_uint> highp_uvec4;
//! 4 components vector of medium precision unsigned integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec4<mediump_uint> mediump_uvec4;
//! 4 components vector of low precision unsigned integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
//! \ingroup core_precision
typedef detail::tvec4<lowp_uint> lowp_uvec4;
}
//namespace precision

20
glm/glm.hpp
View File

@ -7,26 +7,6 @@
// File : glm/glm.hpp
///////////////////////////////////////////////////////////////////////////////////////////////////
/*! \mainpage OpenGL Mathematics
*
* OpenGL Mathematics (GLM) is a C++ mathematics library for 3D applications based on the OpenGL Shading Language (GLSL) specification.
*
* GLM provides 3D programmers with math classes and functions that are similar to GLSL or any high level GPU programming language. The idea is to have a library that has identical naming conventions and functionalities than GLSL so that when developers know GLSL, they know how to use GLM.
*
* However, this project isn't limited by GLSL features. An extension system, based on the GLSL extension conventions, allows extended capabilities.
*
* This library can be used with OpenGL but also for software rendering (Raytracing / Rasterisation), image processing and as much contexts as a simple math library could be used for.
*
* GLM is written as a platform independent library and supports the following compilers:
* - GNU GCC 3.4 and higher
* - Microsoft Visual Studio 8.0 and higher
*
* The source code is under the MIT licence.
*
* Any feedback is welcome and can be sent to glm@g-truc.net.
*
*/
#ifndef glm_glm
#define glm_glm

5
glm/gtc/half_float.hpp
View File

@ -326,6 +326,9 @@ namespace glm
//! GLM_GTC_half_float extension: Add support for half precision floating-point types
namespace half_float
{
/// \addtogroup gtc_half_float
///@{
//! Type for half-precision floating-point numbers.
//! From GLM_GTC_half_float extension.
typedef detail::thalf half;
@ -354,6 +357,8 @@ namespace glm
//! From GLM_GTC_half_float extension.
typedef detail::tmat4x4<detail::thalf> hmat4;
///@}
}//namespace half_float
}//namespace gtc
}//namespace glm

5
glm/gtc/matrix_access.hpp
View File

@ -25,6 +25,9 @@ namespace gtc{
//! GLM_GTC_matrix_access extension: Set a column or a row of a matrix
namespace matrix_access
{
/// \addtogroup gtc_matrix_access
///@{
//! Get a specific row of a matrix.
//! From GLM_GTC_matrix_access extension.
template <typename genType>
@ -55,6 +58,8 @@ namespace matrix_access
int index,
typename genType::col_type const & x);
///@}
}//namespace matrix_access
}//namespace gtc
}//namespace glm

5
glm/gtc/matrix_integer.hpp
View File

@ -30,6 +30,9 @@ namespace glm
//! GLM_GTC_matrix_integer extension: Add integer matrices
namespace matrix_integer
{
/// \addtogroup gtc_matrix_integer
///@{
typedef detail::tmat2x2<highp_int> highp_imat2; //!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x3<highp_int> highp_imat3; //!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x4<highp_int> highp_imat4; //!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
@ -201,6 +204,8 @@ namespace glm
typedef mediump_umat4x4 umat4x4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
#endif//GLM_PRECISION
///@}
}//namespace matrix_integer
}//namespace gtc
}//namespace glm

5
glm/gtc/matrix_inverse.hpp
View File

@ -25,6 +25,9 @@ namespace gtc{
//! GLM_GTC_matrix_inverse extension: Inverse matrix functions
namespace matrix_inverse
{
/// \addtogroup gtc_matrix_inverse
///@{
//! Fast matrix inverse for affine matrix.
//! From GLM_GTC_matrix_inverse extension.
template <typename genType>
@ -36,6 +39,8 @@ namespace matrix_inverse
inline typename genType::value_type inverseTranspose(
genType const & m);
///@}
}//namespace matrix_inverse
}//namespace gtc
}//namespace glm

4
glm/gtc/matrix_transform.hpp
View File

@ -31,6 +31,9 @@ namespace glm
//! GLM_GTC_matrix_transform extension: Add transformation matrices
namespace matrix_transform
{
/// \addtogroup gtc_matrix_transform
///@{
//! Builds a translation 4 * 4 matrix created from a vector of 3 components.
//! From GLM_GTC_matrix_transform extension.
template <typename T>
@ -141,6 +144,7 @@ namespace glm
detail::tvec3<T> const & center,
detail::tvec3<T> const & up);
///@}
}//namespace matrix_transform
}//namespace gtc
}//namespace glm

6
glm/gtc/quaternion.hpp
View File

@ -36,6 +36,7 @@ namespace glm
{
//! \brief Template for quaternion.
//! From GLM_GTC_quaternion extension.
/// \ingroup gtc_quaternion
template <typename T>
struct tquat// : public genType<T, tquat>
{
@ -124,6 +125,9 @@ namespace glm
//! GLM_GTC_quaternion extension: Quaternion types and functions
namespace quaternion
{
/// \addtogroup gtc_quaternion
///@{
//! Returns the length of the quaternion x.
//! From GLM_GTC_quaternion extension.
template <typename T>
@ -218,6 +222,8 @@ namespace glm
//! From GLM_GTC_quaternion extension.
typedef detail::tquat<double> dquat;
///@}
}//namespace quaternion
}//namespace gtc
} //namespace glm

5
glm/gtc/type_precision.hpp
View File

@ -43,6 +43,9 @@ namespace glm
///////////////////////////
// Signed int vector types
/// \addtogroup gtc_type_precision
///@{
typedef detail::int8 int8; //!< \brief 8bit signed integer. (from GLM_GTC_type_precision extension)
typedef detail::int16 int16; //!< \brief 16bit signed integer. (from GLM_GTC_type_precision extension)
typedef detail::int32 int32; //!< \brief 32bit signed integer. (from GLM_GTC_type_precision extension)
@ -210,6 +213,8 @@ namespace glm
typedef detail::tquat<f32> f32quat; //!< \brief Single-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
typedef detail::tquat<f64> f64quat; //!< \brief Double-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
///@}
}//namespace type_precision
}//namespace gtc
}//namespace glm

5
glm/gtc/type_ptr.hpp
View File

@ -30,6 +30,9 @@ namespace glm
//! GLM_GTC_type_ptr extension: Get access to vectors & matrices value type address.
namespace type_ptr{
/// \addtogroup gtc_type_ptr
///@{
//! Get the const address of the vector content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
@ -291,6 +294,8 @@ namespace glm
return &(mat[0].x);
}
///@}
}//namespace type_ptr
}//namespace gtc
}//namespace glm

4
glm/gtx/associated_min_max.hpp
View File

@ -32,6 +32,9 @@ namespace glm
//! GLM_GTX_associated_min_max extension: Min and max functions that return associated values not the compared onces.
namespace associated_min_max
{
/// \addtogroup gtx_associated_min_max
///@{
//! \brief Min comparison between 2 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMin(
@ -73,6 +76,7 @@ namespace glm
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c,
const genTypeT& w, const genTypeU& d);
///@}
}//namespace associated_min_max

3
glm/gtx/bit.hpp
View File

@ -34,6 +34,8 @@ namespace glm
{
using namespace gtc::half_float;
/// \addtogroup gtx_bit
///@{
//! Build a mask of 'count' bits
//! From GLM_GTX_bit extension.
template <typename genIType>
@ -97,6 +99,7 @@ namespace glm
//! From GLM_GTX_bit extension.
template <typename genType>
genType bitRotateLeft(genType const & In, std::size_t Shift);
///@}
}//namespace bit
}//namespace gtx

4
glm/gtx/closest_point.hpp
View File

@ -30,6 +30,9 @@ namespace glm
//! GLM_GTX_closest_point extension: Find the point on a straight line which is the closet of a point.
namespace closest_point{
/// \addtogroup gtx_closest_point
///@{
//! Find the point on a straight line which is the closet of a point.
//! From GLM_GTX_closest_point extension.
template <typename T>
@ -37,6 +40,7 @@ namespace glm
detail::tvec3<T> const & point,
detail::tvec3<T> const & a,
detail::tvec3<T> const & b);
///@}
}//namespace closest_point
}//namespace gtx

5
glm/gtx/color_cast.hpp
View File

@ -34,6 +34,9 @@ namespace glm
{
using namespace gtx::number_precision;
/// \addtogroup gtx_color_cast
///@{
//! Conversion of a floating value into a 8bit unsigned int value.
//! From GLM_GTX_color_cast extension.
template <typename valType> gtc::type_precision::uint8 u8channel_cast(valType a);
@ -97,6 +100,8 @@ namespace glm
template <typename T> gtc::type_precision::f64vec4 f64_argb_cast(T c); //!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f64vec4 f64_bgra_cast(T c); //!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f64vec4 f64_abgr_cast(T c); //!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
///@}
}//namespace color_space
}//namespace gtx
}//namespace glm

5
glm/gtx/color_space.hpp
View File

@ -30,6 +30,9 @@ namespace glm
//! GLM_GTX_color_space extension: Related to RGB to HSV conversions and operations
namespace color_space
{
/// \addtogroup gtx_color_space
///@{
//! Converts a color from HSV color space to its color in RGB color space.
//! From GLM_GTX_color_space extension.
template <typename valType>
@ -67,6 +70,8 @@ namespace glm
template <typename valType>
valType luminosity(
detail::tvec3<valType> const & color);
///@}
}//namespace color_space
}//namespace gtx

4
glm/gtx/color_space_YCoCg.hpp
View File

@ -30,6 +30,9 @@ namespace glm
//! GLM_GTX_color_space_YCoCg extension: RGB to YCoCg conversions and operations
namespace color_space_YCoCg
{
/// \addtogroup gtx_color_space_YCoCg
///@{
//! Convert a color from RGB color space to YCoCg color space.
//! From GLM_GTX_color_space_YCoCg extension.
template <typename valType>
@ -56,6 +59,7 @@ namespace glm
detail::tvec3<valType> YCoCgR2rgb(
detail::tvec3<valType> const & YCoCgColor);
///@}
}//namespace color_space_YCoCg
}//namespace gtx
}//namespace glm

5
glm/gtx/compatibility.hpp
View File

@ -38,6 +38,9 @@ namespace glm
//! GLM_GTX_compatibility extension: Provide functions to increase the compatibility with Cg and HLSL languages
namespace compatibility
{
/// \addtogroup gtx_compatibility
///@{
template <typename T> inline 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> inline detail::tvec2<T> lerp(const detail::tvec2<T>& x, const detail::tvec2<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> inline detail::tvec3<T> lerp(const detail::tvec3<T>& x, const detail::tvec3<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)
@ -151,6 +154,8 @@ namespace glm
typedef detail::tmat4x3<double> double4x3; //!< \brief double-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x4<double> double4x4; //!< \brief double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
///@}
}//namespace compatibility
}//namespace gtx
}//namespace glm

5
glm/gtx/component_wise.hpp
View File

@ -30,6 +30,9 @@ namespace glm
//! GLM_GTX_component_wise extension: Operations between components of a type
namespace component_wise
{
/// \addtogroup gtx_component_wise
///@{
//! Add all vector components together.
//! From GLM_GTX_component_wise extension.
template <typename genType>
@ -54,6 +57,8 @@ namespace glm
typename genType::value_type compMax(
genType const & v);
///@}
}//namespace component_wise
}//namespace gtx
}//namespace glm

7
glm/gtx/epsilon.hpp
View File

@ -29,9 +29,12 @@ namespace glm
}//namespace test
namespace gtx{
//! GLM_GTX_epsilon extension: Comparaison functions for a user defined epsilon values.
//! GLM_GTX_epsilon extension: Comparison functions for a user defined epsilon values.
namespace epsilon
{
/// \addtogroup gtx_epsilon
///@{
//! Returns the component-wise compare of |x - y| < epsilon.
//! From GLM_GTX_epsilon extension.
template <typename genTypeT, typename genTypeU>
@ -48,6 +51,8 @@ namespace glm
genTypeT const & y,
genTypeU const & epsilon);
///@}
}//namespace epsilon
}//namespace gtx
}//namespace glm

7
glm/gtx/euler_angles.hpp
View File

@ -29,9 +29,12 @@
namespace glm
{
namespace gtx{
//! GLM_GTX_euler_angles extension: Build matrices from euler angles.
//! GLM_GTX_euler_angles extension: Build matrices from Euler angles.
namespace euler_angles
{
/// \addtogroup gtx_euler_angles
///@{
//! Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X.
//! From GLM_GTX_euler_angles extension.
template <typename valType>
@ -127,6 +130,8 @@ namespace glm
//! From GLM_GTX_euler_angles extension.
template <typename T>
detail::tmat4x4<T> orientate4(detail::tvec3<T> const & angles);
///@}
}//namespace euler_angles
}//namespace gtx
}//namespace glm

5
glm/gtx/extend.hpp
View File

@ -30,6 +30,9 @@ namespace glm
//! GLM_GTX_extend extension: Extend a position from a source to a position at a defined length.
namespace extend
{
/// \addtogroup gtx_extend
///@{
//! Extends of Length the Origin position using the (Source - Origin) direction.
//! From GLM_GTX_extend extension.
template <typename genType>
@ -38,6 +41,8 @@ namespace glm
genType const & Source,
typename genType::value_type const Length);
///@}
}//namespace extend
}//namespace gtx
}//namespace glm

5
glm/gtx/extented_min_max.hpp
View File

@ -32,6 +32,9 @@ namespace glm
//! GLM_GTX_extented_min_max extension: Min and max functions for 3 to 4 parameters.
namespace extented_min_max
{
/// \addtogroup gtx_extented_min_max
///@{
//< Return the minimum component-wise values of 3 inputs
//< From GLM_GTX_extented_min_max extension
template <typename T>
@ -166,6 +169,8 @@ namespace glm
C<T> const & z,
C<T> const & w);
///@}
}//namespace extented_min_max
}//namespace gtx
}//namespace glm

4
glm/gtx/fast_exponential.hpp
View File

@ -33,6 +33,8 @@ namespace glm
namespace fast_exponential
{
using namespace gtc::half_float;
/// \addtogroup gtx_fast_exponential
///@{
//! Faster than the common pow function but less accurate.
//! From GLM_GTX_fast_exponential extension.
@ -73,6 +75,8 @@ namespace glm
template <typename T>
T fastLn(const T& x);
///@}
}//namespace fast_exponential
}//namespace gtx
}//namespace glm

5
glm/gtx/fast_square_root.hpp
View File

@ -34,6 +34,9 @@ namespace glm
//! GLM_GTX_fast_square_root extension: Fast but less accurate implementations of square root based functions.
namespace fast_square_root
{
/// \addtogroup gtx_fast_square_root
///@{
//! Faster than the common sqrt function but less accurate.
//! From GLM_GTX_fast_square_root extension.
template <typename genType>
@ -59,6 +62,8 @@ namespace glm
template <typename genType>
genType fastNormalize(genType const & x);
///@}
}//namespace fast_square_root
}// namespace gtx
}//namespace glm

5
glm/gtx/fast_trigonometry.hpp
View File

@ -30,6 +30,9 @@ namespace glm
//! GLM_GTX_fast_trigonometry extension: Fast but less accurate implementations of trigonometric functions.
namespace fast_trigonometry
{
/// \addtogroup gtx_fast_trigonometry
///@{
//! Faster than the common sin function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
@ -72,6 +75,8 @@ namespace glm
template <typename T>
T fastAtan(const T& angle);
///@}
}//namespace fast_trigonometry
}//namespace gtx
}//namespace glm

7
glm/gtx/handed_coordinate_space.hpp
View File

@ -23,9 +23,12 @@
namespace glm
{
namespace gtx{
//! GLM_GTX_handed_coordinate_space extension: To know if a triedron is right or left handed
//! GLM_GTX_handed_coordinate_space extension: To know if a set of three basis vectors defines a right or left-handed coordinate system.
namespace handed_coordinate_space
{
/// \addtogroup gtx_handed_coordinate_space
///@{
//! Return if a trihedron right handed or not.
//! From GLM_GTX_handed_coordinate_space extension.
template <typename T>
@ -42,6 +45,8 @@ namespace glm
detail::tvec3<T> const & binormal,
detail::tvec3<T> const & normal);
///@}
}//namespace handed_coordinate_space
}//namespace gtx
}//namespace glm

5
glm/gtx/inertia.hpp
View File

@ -26,6 +26,9 @@ namespace glm
//! GLM_GTX_inertia extension: Create inertia matrices
namespace inertia
{
/// \addtogroup gtx_inertia
///@{
//! Build an inertia matrix for a box.
//! From GLM_GTX_inertia extension.
template <typename T>
@ -82,6 +85,8 @@ namespace glm
const T Mass,
const T Radius);
///@}
}//namespace inertia
}//namespace gtx
}//namespace glm

5
glm/gtx/int_10_10_10_2.hpp
View File

@ -29,10 +29,15 @@ namespace glm
{
using namespace gtx::raw_data;
/// \addtogroup gtx_int_10_10_10_2
///@{
//! From GLM_GTX_int_10_10_10_2 extension.
//! Cast a vec4 to an u_10_10_10_2.
dword uint10_10_10_2_cast(glm::vec4 const & v);
///@}
}//namespace integer
}//namespace gtx
}//namespace glm

5
glm/gtx/integer.hpp
View File

@ -26,6 +26,9 @@ namespace glm
//! GLM_GTX_integer extension: Add support for integer for core functions
namespace integer
{
/// \addtogroup gtx_integer
///@{
//! Returns x raised to the y power.
//! From GLM_GTX_integer extension.
int pow(int x, int y);
@ -43,6 +46,8 @@ namespace glm
template <typename genType>
genType factorial(genType const & x);
///@}
}//namespace integer
}//namespace gtx
}//namespace glm

7
glm/gtx/intersect.hpp
View File

@ -32,7 +32,10 @@ namespace glm
//! GLM_GTX_intersect extension: Add intersection functions
namespace intersect
{
//! Compute the intersection of a ray and a triangle.
/// \addtogroup gtx_intersect
///@{
//! Compute the intersection of a ray and a triangle.
//! From GLM_GTX_intersect extension.
template <typename genType>
bool intersectRayTriangle(
@ -64,6 +67,8 @@ namespace glm
genType const & center, typename genType::value_type radius,
genType & position, genType & normal);
///@}
}//namespace intersect
}//namespace gtx
}//namespace glm

5
glm/gtx/log_base.hpp
View File

@ -30,6 +30,9 @@ namespace glm
//! GLM_GTX_log_base extension: Logarithm for any base. base can be a vector or a scalar.
namespace log_base
{
/// \addtogroup gtx_log_base
///@{
//! Logarithm for any base.
//! From GLM_GTX_log_base.
template <typename genType>
@ -37,6 +40,8 @@ namespace glm
genType const & x,
genType const & base);
///@}
}//namespace extend
}//namespace gtx
}//namespace glm

5
glm/gtx/matrix_cross_product.hpp
View File

@ -30,6 +30,9 @@ namespace glm
//! GLM_GTX_matrix_cross_product: Build cross product matrices
namespace matrix_cross_product
{
/// \addtogroup gtx_matrix_cross_product
///@{
//! Build a cross product matrix.
//! From GLM_GTX_matrix_cross_product extension.
template <typename T>
@ -42,6 +45,8 @@ namespace glm
detail::tmat4x4<T> matrixCross4(
detail::tvec3<T> const & x);
///@}
}//namespace matrix_cross_product
}//namespace gtx
}//namespace glm

7
glm/gtx/matrix_major_storage.hpp
View File

@ -23,9 +23,12 @@
namespace glm
{
namespace gtx{
//! GLM_GTX_matrix_cross_product: Build matrices with specific matrix order, row or column
//! GLM_GTX_matrix_major_storage: Build matrices with specific matrix order, row or column
namespace matrix_major_storage
{
/// \addtogroup gtx_matrix_major_storage
///@{
//! Build a row major matrix from row vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
@ -109,6 +112,8 @@ namespace glm
template <typename T>
detail::tmat4x4<T> colMajor4(
const detail::tmat4x4<T>& m);
///@}
}//namespace matrix_major_storage
}//namespace gtx

7
glm/gtx/matrix_operation.hpp
View File

@ -27,9 +27,12 @@ namespace glm
}//namespace test
namespace gtx{
//! GLM_GTX_matrix_operation: Build cross product matrices
//! GLM_GTX_matrix_operation: Build diagonal matrices
namespace matrix_operation
{
/// \addtogroup gtx_matrix_operation
///@{
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename valType>
@ -84,6 +87,8 @@ namespace glm
detail::tmat4x4<valType> diagonal4x4(
detail::tvec4<valType> const & v);
///@}
}//namespace matrix_operation
}//namespace gtx
}//namespace glm

6
glm/gtx/matrix_query.hpp
View File

@ -27,9 +27,12 @@ namespace glm
}//namespace test
namespace gtx{
//! GLM_GTX_matrix_query: Query to evaluate matrices properties
//! GLM_GTX_matrix_query: Query to evaluate matrix properties
namespace matrix_query
{
/// \addtogroup gtx_matrix_query
///@{
//! Return if a matrix a null matrix.
//! From GLM_GTX_matrix_query extension.
template<typename T>
@ -86,6 +89,7 @@ namespace glm
const genType& m,
const typename genType::value_type epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
///@}
}//namespace matrix_query
}//namespace gtx
}//namespace glm

5
glm/gtx/mixed_product.hpp
View File

@ -30,12 +30,17 @@ namespace glm
//! GLM_GTX_mixed_product extension: Mixed product of 3 vectors.
namespace mixed_product
{
/// \addtogroup gtx_mixed_product
///@{
//! \brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension)
template <typename valType>
valType mixedProduct(
detail::tvec3<valType> const & v1,
detail::tvec3<valType> const & v2,
detail::tvec3<valType> const & v3);
///@}
}//namespace mixed_product
}//namespace gtx
}//namespace glm

5
glm/gtx/multiple.hpp
View File

@ -30,6 +30,9 @@ namespace glm
//! GLM_GTX_multiple: Find the closest number of a number multiple of other number.
namespace multiple
{
/// \addtogroup gtx_multiple
///@{
//! Higher Multiple number of Source.
//! From GLM_GTX_multiple extension.
template <typename genType>
@ -44,6 +47,8 @@ namespace glm
genType const & Source,
genType const & Multiple);
///@}
}//namespace multiple
}//namespace gtx
}//namespace glm

7
glm/gtx/norm.hpp
View File

@ -32,9 +32,12 @@ namespace glm
}//namespace test
namespace gtx{
//! GLM_GTX_norm extension: Varius way to compute vector norms.
//! GLM_GTX_norm extension: Various way to compute vector norms.
namespace norm
{
/// \addtogroup gtx_norm
///@{
//! Returns the squared length of x.
//! From GLM_GTX_norm extension.
template <typename T>
@ -134,6 +137,8 @@ namespace glm
const detail::tvec3<T>& x,
unsigned int Depth);
///@}
}//namespace norm
}//namespace gtx
}//namespace glm

5
glm/gtx/normal.hpp
View File

@ -30,6 +30,9 @@ namespace glm
//! GLM_GTX_normal extension: Compute the normal of a triangle.
namespace normal
{
/// \addtogroup gtx_normal
///@{
//! Computes triangle normal from triangle points.
//! From GLM_GTX_normal extension.
template <typename T>
@ -38,6 +41,8 @@ namespace glm
detail::tvec3<T> const & p2,
detail::tvec3<T> const & p3);
///@}
}//namespace normal
}//namespace gtx
}//namespace glm

5
glm/gtx/normalize_dot.hpp
View File

@ -30,6 +30,9 @@ namespace glm
{
using namespace gtx::fast_square_root;
/// \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.
@ -46,6 +49,8 @@ namespace glm
genType const & x,
genType const & y);
///@}
}//namespace normalize_dot
}//namespace gtx
}//namespace glm

4
glm/gtx/number_precision.hpp
View File

@ -33,6 +33,9 @@ namespace number_precision
/////////////////////////////
// Unsigned int vector types
/// \addtogroup gtx_number_precision
///@{
typedef u8 u8vec1; //!< \brief 8bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
typedef u16 u16vec1; //!< \brief 16bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
typedef u32 u32vec1; //!< \brief 32bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
@ -55,6 +58,7 @@ namespace number_precision
typedef f64 f64mat1; //!< \brief Double-precision floating-point scalar. (from GLM_GTX_number_precision extension)
typedef f64 f64mat1x1; //!< \brief Double-precision floating-point scalar. (from GLM_GTX_number_precision extension)
///@}
}//namespace number_precision
}//namespace gtx
}//namespace glm

5
glm/gtx/ocl_type.hpp
View File

@ -28,6 +28,9 @@ namespace ocl_type
///////////////////////////
// Scalar types
/// \addtogroup gtx_ocl_type
///@{
typedef detail::int8 cl_char; //!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
typedef detail::int16 cl_short; //!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
typedef detail::int32 cl_int; //!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
@ -96,6 +99,8 @@ namespace ocl_type
//typedef detail::tvec4<detail::float16> cl_half4; //!< \brief Half-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
typedef detail::tvec4<detail::float32> cl_float4; //!< \brief Single-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
///@}
}//namespace ocl_type
}//namespace gtx
}//namespace glm

7
glm/gtx/optimum_pow.hpp
View File

@ -27,9 +27,12 @@ namespace glm
}//namespace test
namespace gtx{
//! GLM_GTX_optimum_pow extension: Integer exponenciation of power functions.
//! GLM_GTX_optimum_pow extension: Integer exponentiation of power functions.
namespace optimum_pow
{
/// \addtogroup gtx_optimum_pow
///@{
//! Returns x raised to the power of 2.
//! From GLM_GTX_optimum_pow extension.
template <typename genType>
@ -61,6 +64,8 @@ namespace glm
//! From GLM_GTX_optimum_pow extension.
detail::tvec4<bool> powOfTwo(const detail::tvec4<int>& x);
///@}
}//namespace optimum_pow
}//namespace gtx
}//namespace glm

7
glm/gtx/orthonormalize.hpp
View File

@ -30,7 +30,10 @@ namespace glm
//! GLM_GTX_orthonormalize extension: Orthonormalize matrices.
namespace orthonormalize
{
//! Returns the orthonormalized matrix of m.
/// \addtogroup gtx_orthonormalize
///@{
//! Returns the orthonormalized matrix of m.
//! From GLM_GTX_orthonormalize extension.
template <typename T>
detail::tmat3x3<T> orthonormalize(
@ -43,6 +46,8 @@ namespace glm
const detail::tvec3<T>& x,
const detail::tvec3<T>& y);
///@}
}//namespace orthonormalize
}//namespace gtx
}//namespace glm

8
glm/gtx/perpendicular.hpp
View File

@ -32,7 +32,10 @@ namespace glm
//! GLM_GTX_perpendicular extension: Perpendicular of a vector from other one
namespace perpendicular
{
//! Projects x a perpendicular axis of Normal.
/// \addtogroup gtx_perpendicular
///@{
//! Projects x a perpendicular axis of Normal.
//! From GLM_GTX_perpendicular extension.
template <typename T>
detail::tvec2<T> perp(
@ -52,6 +55,9 @@ namespace glm
detail::tvec4<T> perp(
detail::tvec4<T> const & x,
detail::tvec4<T> const & Normal);
///@}
}//namespace perpendicular
}//namespace gtx

5
glm/gtx/polar_coordinates.hpp
View File

@ -26,6 +26,9 @@ namespace glm
//! GLM_GTX_polar_coordinates extension: Conversion from Euclidean space to polar space and revert.
namespace polar_coordinates
{
/// \addtogroup gtx_polar_coordinates
///@{
//! Convert Euclidean to Polar coordinates, x is the xz distance, y, the latitude and z the longitude.
//! From GLM_GTX_polar_coordinates extension.
template <typename T>
@ -36,6 +39,8 @@ namespace glm
template <typename T>
detail::tvec3<T> euclidean(const detail::tvec3<T>& polar);
///@}
}//namespace polar_coordinates
}//namespace gtx
}//namespace glm

5
glm/gtx/projection.hpp
View File

@ -30,6 +30,9 @@ namespace glm
//! GLM_GTX_projection extension: Projection of a vector to other one
namespace projection
{
/// \addtogroup gtx_projection
///@{
//! Projects x on Normal.
//! From GLM_GTX_projection extension.
template <typename T>
@ -50,6 +53,8 @@ namespace glm
detail::tvec4<T> proj(
detail::tvec4<T> const & x,
detail::tvec4<T> const & Normal);
///@}
}//namespace projection
}//namespace gtx

7
glm/gtx/quaternion.hpp
View File

@ -33,7 +33,10 @@ namespace glm
{
using namespace gtc::quaternion;
//! Compute a cross product between a quaternion and a vector.
/// \addtogroup gtx_quaternion
///@{
//! Compute a cross product between a quaternion and a vector.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tvec3<valType> cross(
@ -188,6 +191,8 @@ namespace glm
detail::tquat<valType> toQuat(
detail::tmat4x4<valType> const & x){return gtc::quaternion::quat_cast(x);}
///@}
}//namespace quaternion
}//namespace gtx
} //namespace glm

6
glm/gtx/random.hpp
View File

@ -25,9 +25,12 @@
namespace glm{
namespace gtx{
//! GLM_GTX_random extension: Generate random number from varius distribution methods
//! GLM_GTX_random extension: Generate random number from various distribution methods
namespace random
{
/// \addtogroup gtx_random
///@{
//! Generate a random number in the interval [-1, 1], according a linear distribution.
//! From GLM_GTX_random extension.
template <typename T> T signedRand1();
@ -75,6 +78,7 @@ namespace random
template <typename T> detail::tvec3<T> gaussRand3(const detail::tvec3<T>& mean, const detail::tvec3<T>& std_deviation); //!< \brief Gererate 3 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
template <typename T> detail::tvec4<T> gaussRand4(const detail::tvec4<T>& mean, const detail::tvec4<T>& std_deviation); //!< \brief Gererate 4 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
///@}
}//namespace random
}//namespace gtx
}//namespace glm

5
glm/gtx/raw_data.hpp
View File

@ -29,6 +29,9 @@ namespace gtx
{
using namespace gtc::type_precision;
/// \addtogroup gtx_raw_data
///@{
//! Type for byte numbers.
//! From GLM_GTX_raw_data extension.
typedef uint8 byte;
@ -44,6 +47,8 @@ namespace gtx
//! Type for qword numbers.
//! From GLM_GTX_raw_data extension.
typedef uint64 qword;
///@}
}
}//namespace gtx
}//namespace glm

5
glm/gtx/reciprocal.hpp
View File

@ -27,6 +27,9 @@ namespace glm
//! GLM_GTX_reciprocal extension: Define secant, cosecant and cotangent functions.
namespace reciprocal
{
/// \addtogroup gtx_reciprocal
///@{
//! Secant function.
//! hypotenuse / adjacent or 1 / cos(x)
//! From GLM_GTX_reciprocal extension.
@ -90,6 +93,8 @@ namespace glm
template <typename genType>
genType acoth(genType const & x);
///@}
}//namespace reciprocal
}//namespace gtx
}//namespace glm

21
glm/gtx/rotate_vector.hpp
View File

@ -29,14 +29,17 @@ namespace glm
{
using namespace transform;
//! Rotate a two dimentionnals vector.
/// \addtogroup gtx_rotate_vector
///@{
//! Rotate a two dimensional vector.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec2<T> rotate(
const detail::tvec2<T>& v,
T angle);
//! Rotate a three dimentionnals vector around an axis.
//! Rotate a three dimensional vector around an axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec3<T> rotate(
@ -44,28 +47,28 @@ namespace glm
T angle,
const detail::tvec3<T>& normal);
//! Rotate a four dimentionnals vector around an axis.
//! Rotate a four dimensional vector around an axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec4<T> rotate(
const detail::tvec4<T>& v, T angle,
const detail::tvec3<T>& normal);
//! Rotate a three dimentionnals vector around the X axis.
//! Rotate a three dimensional vector around the X axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec3<T> rotateX(
const detail::tvec3<T>& v,
T angle);
//! Rotate a three dimentionnals vector around the Y axis.
//! Rotate a three dimensional vector around the Y axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec3<T> rotateY(
const detail::tvec3<T>& v,
T angle);
//! Rotate a three dimentionnals vector around the Z axis.
//! Rotate a three dimensional vector around the Z axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec3<T> rotateZ(
@ -79,14 +82,14 @@ namespace glm
const detail::tvec4<T>& v,
T angle);
//! Rotate a four dimentionnals vector around the X axis.
//! Rotate a four dimensional vector around the X axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec4<T> rotateY(
const detail::tvec4<T>& v,
T angle);
//! Rotate a four dimentionnals vector around the X axis.
//! Rotate a four dimensional vector around the X axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec4<T> rotateZ(
@ -99,6 +102,8 @@ namespace glm
detail::tmat4x4<T> orientation(
const detail::tvec3<T>& Normal,
const detail::tvec3<T>& Up);
///@}
}//namespace rotate_vector
}//namespace gtx

9
glm/gtx/simd_mat4.hpp
View File

@ -32,6 +32,8 @@ namespace glm
{
namespace detail
{
/// 4x4 Matrix implemented using SIMD SEE intrinsics.
/// \ingroup gtx_simd_mat4
GLM_ALIGN(16) struct fmat4x4SIMD
{
enum ctor{null};
@ -129,11 +131,14 @@ namespace glm
}//namespace detail
namespace gtx{
//! GLM_GTX_simd_mat4 extension: SIMD implementation of vec4 type.
//! GLM_GTX_simd_mat4 extension: SIMD implementation of mat4 type.
namespace simd_mat4
{
typedef detail::fmat4x4SIMD simdMat4;
/// \addtogroup gtx_simd_mat4
///@{
//! Convert a simdMat4 to a mat4.
//! (From GLM_GTX_simd_mat4 extension)
detail::tmat4x4<float> mat4_cast(
@ -169,6 +174,8 @@ namespace glm
detail::fmat4x4SIMD simdInverse(
detail::fmat4x4SIMD const & m);
///@}
}//namespace simd_mat4
}//namespace gtx
}//namespace glm

7
glm/gtx/simd_vec4.hpp
View File

@ -32,6 +32,8 @@ namespace glm
{
namespace detail
{
/// 4-dimensional vector implemented using SIMD SEE intrinsics.
/// \ingroup gtx_simd_vec4
GLM_ALIGN(4) struct fvec4SIMD
{
enum ctor{null};
@ -117,6 +119,9 @@ namespace glm
{
typedef detail::fvec4SIMD simdVec4;
/// \addtogroup gtx_simd_vec4
///@{
//! Convert a simdVec4 to a vec4.
//! (From GLM_GTX_simd_vec4 extension)
detail::tvec4<float> vec4_cast(
@ -401,6 +406,8 @@ namespace glm
detail::fvec4SIMD const & I,
detail::fvec4SIMD const & N,
float const & eta);
///@}
}//namespace simd_vec4
}//namespace gtx
}//namespace glm

7
glm/gtx/spline.hpp
View File

@ -29,7 +29,10 @@ namespace glm
{
using namespace gtx::optimum_pow;
//! Return a point from a catmull rom curve.
/// \addtogroup gtx_spline
///@{
//! Return a point from a catmull rom curve.
//! From GLM_GTX_spline extension.
template <typename genType>
genType catmullRom(
@ -59,6 +62,8 @@ namespace glm
const genType& v4,
const GLMvalType& s);
///@}
}//namespace spline
}//namespace gtx
}//namespace glm

5
glm/gtx/string_cast.hpp
View File

@ -43,11 +43,16 @@ namespace glm
using namespace gtx::unsigned_int;
using namespace gtx::quaternion;
/// \addtogroup gtx_string_cast
///@{
//! Create a string from a GLM type value.
//! From GLM_GTX_string_cast extension.
template <typename genType>
std::string to_string(genType const & x);
///@}
}//namespace string_cast
}//namespace gtx
}//namespace glm

5
glm/gtx/transform.hpp
View File

@ -34,6 +34,9 @@ namespace glm
{
using namespace gtc::matrix_transform;
/// \addtogroup gtx_transform
///@{
//! Builds a translation 4 * 4 matrix created from 3 scalars.
//! From GLM_GTX_transform extension.
template <typename T>
@ -94,6 +97,8 @@ namespace glm
detail::tmat4x4<T> scale(
detail::tvec3<T> const & v);
///@}
}//namespace transform
}//namespace gtx
}//namespace glm

5
glm/gtx/transform2.hpp
View File

@ -34,6 +34,9 @@ namespace glm
{
using namespace gtx::transform;
/// \addtogroup gtx_transform2
///@{
//! Transforms a matrix with a shearing on X axis.
//! From GLM_GTX_transform2 extension.
template <typename T>
@ -109,6 +112,8 @@ namespace glm
valType scale,
valType bias);
///@}
}//namespace transform2
}//namespace gtx
}//namespace glm

5
glm/gtx/unsigned_int.hpp
View File

@ -34,6 +34,9 @@ namespace glm
{
using namespace gtx::integer;
/// \addtogroup gtx_unsigned_int
///@{
//! 32bit signed integer.
//! From GLM_GTX_unsigned_int extension.
typedef signed int sint;
@ -50,6 +53,8 @@ namespace glm
//! From GLM_GTX_unsigned_int extension.
uint mod(uint x, uint y);
///@}
}//namespace unsigned_int
}//namespace gtx
}//namespace glm

18
glm/gtx/vec1.hpp
View File

@ -34,41 +34,41 @@ namespace glm
namespace precision
{
//! 1 component vector of high precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::highp_vec1_t highp_vec1;
//! 1 component vector of medium precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::mediump_vec1_t mediump_vec1;
//! 1 component vector of low precision floating-point numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::lowp_vec1_t lowp_vec1;
//! 1 component vector of high precision signed integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::highp_ivec1_t highp_ivec1;
//! 1 component vector of medium precision signed integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::mediump_ivec1_t mediump_ivec1;
//! 1 component vector of low precision signed integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::lowp_ivec1_t lowp_ivec1;
//! 1 component vector of high precision unsigned integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::highp_uvec1_t highp_uvec1;
//! 1 component vector of medium precision unsigned integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::mediump_uvec1_t mediump_uvec1;
//! 1 component vector of low precision unsigned integer numbers.
//! There is no garanty on the actual precision.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::lowp_uvec1_t lowp_uvec1;
}//namespace precision

5
glm/gtx/vector_access.hpp
View File

@ -30,6 +30,9 @@ namespace glm
//! GLM_GTX_vector_access extension: Function to set values to vectors
namespace vector_access
{
/// \addtogroup gtx_vector_access
///@{
//! Set values to a 2 components vector.
//! From GLM_GTX_vector_access extension.
template <typename valType>
@ -57,6 +60,8 @@ namespace glm
valType const & z,
valType const & w);
///@}
}//namespace vector_access
}//namespace gtx
}//namespace glm

5
glm/gtx/vector_angle.hpp
View File

@ -37,6 +37,9 @@ namespace glm
using namespace quaternion;
using namespace epsilon;
/// \addtogroup gtx_vector_angle
///@{
//! Returns the absolute angle between x and y.
//! Parameters need to be normalized.
//! From GLM_GTX_vector_angle extension
@ -61,6 +64,8 @@ namespace glm
vecType const & x,
vecType const & y,
detail::tvec3<typename vecType::value_type> const & ref);
///@}
}//namespace vector_angle
}//namespace gtx
}//namespace glm

7
glm/gtx/vector_query.hpp
View File

@ -32,7 +32,10 @@ namespace glm
//! GLM_GTX_vector_query extension: Query informations of vector types
namespace vector_query
{
//! Check if two vectors are collinears.
/// \addtogroup gtx_vector_query
///@{
//! Check if two vectors are collinears.
//! From GLM_GTX_vector_query extensions.
template <typename genType>
bool areCollinear(
@ -86,6 +89,8 @@ namespace glm
const genType& v1,
const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon());
///@}
}//namespace vector_query
}//namespace gtx
}//namespace glm

5
glm/gtx/verbose_operator.hpp
View File

@ -30,6 +30,9 @@ namespace glm
//! GLM_GTX_verbose_operator extension: Use words to replace operators
namespace verbose_operator
{
/// \addtogroup gtx_verbose_operator
///@{
//! Addition of two values
//! From GLM_GTX_verbose_operator extension.
template <typename genTypeT, typename genTypeU>
@ -54,6 +57,8 @@ namespace glm
//! From GLM_GTX_verbose_operator extension.
template <typename genTypeT, typename genTypeU, typename genTypeV>
genTypeT mad(genTypeT const & a, genTypeU const & b, genTypeV const & c);
///@}
}//namespace verbose_operator
}//namespace gtx
}//namespace glm

5
glm/gtx/wrap.hpp
View File

@ -30,6 +30,9 @@ namespace glm
//! GLM_GTX_wrap: Wrapping mode using my texture samping.
namespace wrap
{
/// \addtogroup gtx_wrap
///@{
//! Simulate GL_CLAMP OpenGL wrap mode
//! From GLM_GTX_wrap extension.
template <typename genType>
@ -45,6 +48,8 @@ namespace glm
template <typename genType>
genType mirrorRepeat(genType const & Texcoord);
///@}
}//namespace wrap
}//namespace gtx
}//namespace glm