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

Updated documentation and refactoring of GTC_type_ptr code

Browse Source
This commit is contained in:
Christophe Riccio 2011-12-07 10:28:56 +00:00
parent dad27d9b37
commit 85a187761d
3 changed files with 489 additions and 399 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
glm/gtc/noise.hpp
View File

@ -54,20 +54,20 @@ namespace glm
/// @{
/// Classic perlin noise.
/// From GLM_GTC_noise extension.
/// @see gtc_noise
template <typename T, template<typename> class vecType>
T perlin(
vecType<T> const & p);
/// Periodic perlin noise.
/// From GLM_GTC_noise extension.
/// @see gtc_noise
template <typename T, template<typename> class vecType>
T perlin(
vecType<T> const & p,
vecType<T> const & rep);
/// Simplex noise.
/// From GLM_GTC_noise extension.
/// @see gtc_noise
template <typename T, template<typename> class vecType>
T simplex(
vecType<T> const & p);

444
glm/gtc/type_ptr.hpp
View File

@ -75,430 +75,90 @@ namespace glm
/// @{
/// Return the constant address to the data of the input parameter.
/// From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tvec2<T> const & vec
)
{
return &(vec.x);
}
/// @see gtc_type_ptr
template<typename genType>
typename genType::value_type const * value_ptr(genType const & vec);
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
/// Build a vector from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tvec2<T> & vec
)
{
return &(vec.x);
}
detail::tvec2<T> make_vec2(T const * const ptr);
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
/// Build a vector from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tvec3<T> const & vec
)
{
return &(vec.x);
}
detail::tvec3<T> make_vec3(T const * const ptr);
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
/// Build a vector from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tvec3<T> & vec
)
{
return &(vec.x);
}
detail::tvec4<T> make_vec4(T const * const ptr);
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tvec4<T> const & vec
)
{
return &(vec.x);
}
detail::tmat2x2<T> make_mat2x2(T const * const ptr);
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tvec4<T> & vec
)
{
return &(vec.x);
}
detail::tmat2x3<T> make_mat2x3(T const * const ptr);
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat2x2<T> const & mat
)
{
return &(mat[0].x);
}
detail::tmat2x4<T> make_mat2x4(T const * const ptr);
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat2x2<T> & mat
)
{
return &(mat[0].x);
}
detail::tmat3x2<T> make_mat3x2(T const * const ptr);
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat3x3<T> const & mat
)
{
return &(mat[0].x);
}
detail::tmat3x3<T> make_mat3x3(T const * const ptr);
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat3x3<T> & mat
)
{
return &(mat[0].x);
}
detail::tmat3x4<T> make_mat3x4(T const * const ptr);
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat4x4<T> const & mat
)
{
return &(mat[0].x);
}
detail::tmat4x2<T> make_mat4x2(
T const * const ptr);
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat4x4<T> & mat
)
{
return &(mat[0].x);
}
detail::tmat4x3<T> make_mat4x3(T const * const ptr);
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat2x3<T> const & mat
)
{
return &(mat[0].x);
}
detail::tmat4x4<T> make_mat4x4(T const * const ptr);
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat2x3<T> & mat
)
{
return &(mat[0].x);
}
detail::tmat2x2<T> make_mat2(T const * const ptr);
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat3x2<T> const & mat
)
{
return &(mat[0].x);
}
detail::tmat3x3<T> make_mat3(T const * const ptr);
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
/// Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat3x2<T> & mat
)
{
return &(mat[0].x);
}
detail::tmat4x4<T> make_mat4(T const * const ptr);
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
/// Build a quaternion from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat2x4<T> const & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat2x4<T> & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat4x2<T> const & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat4x2<T> & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat3x4<T> const & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat3x4<T> & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat4x3<T> const & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tquat<T> const & q
)
{
return &(q[0]);
}
//! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr(detail::tmat4x3<T> & mat)
{
return &(mat[0].x);
}
//! Build a vector from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> make_vec2(T const * const ptr)
{
detail::tvec2<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tvec2<T>));
return Result;
}
//! Build a vector from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> make_vec3(T const * const ptr)
{
detail::tvec3<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tvec3<T>));
return Result;
}
//! Build a vector from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> make_vec4(T const * const ptr)
{
detail::tvec4<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tvec4<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2x2(T const * const ptr)
{
detail::tmat2x2<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x2<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat2x3<T> make_mat2x3(T const * const ptr)
{
detail::tmat2x3<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x3<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat2x4<T> make_mat2x4(T const * const ptr)
{
detail::tmat2x4<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x4<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat3x2<T> make_mat3x2(T const * const ptr)
{
detail::tmat3x2<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x2<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3x3(T const * const ptr)
{
detail::tmat3x3<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x3<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat3x4<T> make_mat3x4(T const * const ptr)
{
detail::tmat3x4<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x4<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat4x2<T> make_mat4x2(T const * const ptr)
{
detail::tmat4x2<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x2<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat4x3<T> make_mat4x3(T const * const ptr)
{
detail::tmat4x3<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x3<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4x4(T const * const ptr)
{
detail::tmat4x4<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x4<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2(T const * const ptr)
{
return make_mat2x2(ptr);
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3(T const * const ptr)
{
return make_mat3x3(ptr);
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4(T const * const ptr)
{
return make_mat4x4(ptr);
}
//! Build a quaternion from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tquat<T> make_quat(T const * const ptr)
{
detail::tquat<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tquat<T>));
return Result;
}
detail::tquat<T> make_quat(T const * const ptr);
/// @}
}//namespace glm

432
glm/gtc/type_ptr.inl
View File

@ -22,11 +22,441 @@
///
/// @ref gtc_type_ptr
/// @file glm/gtc/type_ptr.inl
/// @date 2011-06-15 / 2011-06-15
/// @date 2011-06-15 / 2011-12-07
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
namespace glm
{
/// @addtogroup gtc_type_ptr
/// @{
/// Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tvec2<T> const & vec
)
{
return &(vec.x);
}
//! Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tvec2<T> & vec
)
{
return &(vec.x);
}
//! Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tvec3<T> const & vec
)
{
return &(vec.x);
}
//! Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tvec3<T> & vec
)
{
return &(vec.x);
}
//! Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tvec4<T> const & vec
)
{
return &(vec.x);
}
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tvec4<T> & vec
)
{
return &(vec.x);
}
//! Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat2x2<T> const & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat2x2<T> & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat3x3<T> const & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat3x3<T> & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat4x4<T> const & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat4x4<T> & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat2x3<T> const & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat2x3<T> & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat3x2<T> const & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat3x2<T> & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat2x4<T> const & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat2x4<T> & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat4x2<T> const & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat4x2<T> & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat3x4<T> const & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat3x4<T> & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat4x3<T> const & mat
)
{
return &(mat[0].x);
}
//! Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tquat<T> const & q
)
{
return &(q[0]);
}
//! Get the address of the matrix content.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr(detail::tmat4x3<T> & mat)
{
return &(mat[0].x);
}
//! Build a vector from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> make_vec2(T const * const ptr)
{
detail::tvec2<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tvec2<T>));
return Result;
}
//! Build a vector from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> make_vec3(T const * const ptr)
{
detail::tvec3<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tvec3<T>));
return Result;
}
//! Build a vector from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> make_vec4(T const * const ptr)
{
detail::tvec4<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tvec4<T>));
return Result;
}
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2x2(T const * const ptr)
{
detail::tmat2x2<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x2<T>));
return Result;
}
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat2x3<T> make_mat2x3(T const * const ptr)
{
detail::tmat2x3<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x3<T>));
return Result;
}
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat2x4<T> make_mat2x4(T const * const ptr)
{
detail::tmat2x4<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x4<T>));
return Result;
}
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat3x2<T> make_mat3x2(T const * const ptr)
{
detail::tmat3x2<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x2<T>));
return Result;
}
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3x3(T const * const ptr)
{
detail::tmat3x3<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x3<T>));
return Result;
}
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat3x4<T> make_mat3x4(T const * const ptr)
{
detail::tmat3x4<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x4<T>));
return Result;
}
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat4x2<T> make_mat4x2(T const * const ptr)
{
detail::tmat4x2<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x2<T>));
return Result;
}
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat4x3<T> make_mat4x3(T const * const ptr)
{
detail::tmat4x3<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x3<T>));
return Result;
}
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4x4(T const * const ptr)
{
detail::tmat4x4<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x4<T>));
return Result;
}
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2(T const * const ptr)
{
return make_mat2x2(ptr);
}
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3(T const * const ptr)
{
return make_mat3x3(ptr);
}
//! Build a matrix from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4(T const * const ptr)
{
return make_mat4x4(ptr);
}
//! Build a quaternion from a pointer.
/// @see gtc_type_ptr
template<typename T>
GLM_FUNC_QUALIFIER detail::tquat<T> make_quat(T const * const ptr)
{
detail::tquat<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tquat<T>));
return Result;
}
/// @}
}//namespace glm