anulax
/
glm
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity

Merge branch 'master' into 0.9.5

Browse Source
master
Maksim Vorobiev ago%!(EXTRA string=13 years)
parent c868666c79 93f0527b12
commit 23a84732ef
5 changed files with 843 additions and 0 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      glm/ext.hpp
  2. 242
      glm/gtc/dual_quaternion.hpp
  3. 426
      glm/gtc/dual_quaternion.inl
  4. 1
      test/gtc/CMakeLists.txt
  5. 173
      test/gtc/gtc_dual_quaternion.cpp

1
glm/ext.hpp
Unescape View File

@ -72,6 +72,7 @@
#include "./gtc/matrix_transform.hpp"
#include "./gtc/noise.hpp"
#include "./gtc/quaternion.hpp"
#include "./gtc/dual_quaternion.hpp"
#include "./gtc/random.hpp"
#include "./gtc/reciprocal.hpp"
#include "./gtc/swizzle.hpp"

242
glm/gtc/dual_quaternion.hpp
Unescape View File

@ -0,0 +1,242 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref gtc_dual_quaternion
/// @file glm/gtc/dual_quaternion.hpp
/// @date 2013-02-10 / 2013-02-13
/// @author Maksim Vorobiev (msomeone@gmail.com)
///
/// @see core (dependence)
/// @see gtc_half_float (dependence)
/// @see gtc_constants (dependence)
/// @see gtc_quaternion (dependence)
///
/// @defgroup gtc_dual_quaternion GLM_GTC_dual_quaternion
/// @ingroup gtc
///
/// @brief Defines a templated dual-quaternion type and several dual-quaternion operations.
///
/// <glm/gtc/dual_quaternion.hpp> need to be included to use these functionalities.
///////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_GTC_dual_quaternion
#define GLM_GTC_dual_quaternion GLM_VERSION
// Dependency:
#include "../glm.hpp"
#include "../gtc/half_float.hpp"
#include "../gtc/constants.hpp"
#include "../gtc/quaternion.hpp"
#if(defined(GLM_MESSAGES) && !defined(glm_ext))
# pragma message("GLM: GLM_GTC_dual_quaternion extension included")
#endif
namespace glm{
namespace detail
{
template <typename T>
struct tdualquat// : public genType<T, tquat>
{
enum ctor{null};
typedef T value_type;
typedef glm::detail::tquat<T> part_type;
typedef std::size_t size_type;
public:
glm::detail::tquat<T> real, dual;
GLM_FUNC_DECL size_type length() const;
// Constructors
tdualquat();
explicit tdualquat(tquat<T> const & real);
tdualquat(tquat<T> const & real,tquat<T> const & dual);
tdualquat(tquat<T> const & orientation,tvec3<T> const& translation);
//////////////////////////////////////////////////////////////
// tdualquat conversions
explicit tdualquat(tmat2x4<T> const & holder_mat);
explicit tdualquat(tmat3x4<T> const & aug_mat);
// Accesses
typename part_type & operator[](int i);
typename part_type const & operator[](int i) const;
// Operators
tdualquat<T> & operator*=(value_type const & s);
tdualquat<T> & operator/=(value_type const & s);
};
template <typename T>
detail::tquat<T> operator- (
detail::tquat<T> const & q);
template <typename T>
detail::tdualquat<T> operator+ (
detail::tdualquat<T> const & q,
detail::tdualquat<T> const & p);
template <typename T>
detail::tdualquat<T> operator* (
detail::tdualquat<T> const & q,
detail::tdualquat<T> const & p);
template <typename T>
detail::tvec3<T> operator* (
detail::tquat<T> const & q,
detail::tvec3<T> const & v);
template <typename T>
detail::tvec3<T> operator* (
detail::tvec3<T> const & v,
detail::tquat<T> const & q);
template <typename T>
detail::tvec4<T> operator* (
detail::tquat<T> const & q,
detail::tvec4<T> const & v);
template <typename T>
detail::tvec4<T> operator* (
detail::tvec4<T> const & v,
detail::tquat<T> const & q);
template <typename T>
detail::tdualquat<T> operator* (
detail::tdualquat<T> const & q,
typename detail::tdualquat<T>::value_type const & s);
template <typename T>
detail::tdualquat<T> operator* (
typename detail::tdualquat<T>::value_type const & s,
detail::tdualquat<T> const & q);
template <typename T>
detail::tdualquat<T> operator/ (
detail::tdualquat<T> const & q,
typename detail::tdualquat<T>::value_type const & s);
} //namespace detail
/// @addtogroup gtc_dual_quaternion
/// @{
/// Returns the normalized quaternion.
///
/// @see gtc_dual_quaternion
template <typename T>
detail::tdualquat<T> normalize(
detail::tdualquat<T> const & q);
/// Returns the linear interpolation of two dual quaternion.
///
/// @see gtc_dual_quaternion
template <typename T>
detail::tdualquat<T> lerp (
detail::tdualquat<T> const & x,
detail::tdualquat<T> const & y,
typename detail::tdualquat<T>::value_type const & a);
/// Returns the q inverse.
///
/// @see gtc_dual_quaternion
template <typename T>
detail::tdualquat<T> inverse(
detail::tdualquat<T> const & q);
/// Extracts a rotation part from dual-quaternion to a 3 * 3 matrix.
///
/// @see gtc_dual_quaternion
template <typename T>
detail::tmat3x3<T> mat3_cast(
detail::tdualquat<T> const & x);
/// Converts a quaternion to a 2 * 4 matrix.
///
/// @see gtc_dual_quaternion
template <typename T>
detail::tmat2x4<T> mat2x4_cast(
detail::tdualquat<T> const & x);
/// Converts a quaternion to a 3 * 4 matrix.
///
/// @see gtc_dual_quaternion
template <typename T>
detail::tmat3x4<T> mat3x4_cast(
detail::tdualquat<T> const & x);
/// Converts a 2 * 4 matrix (matrix which holds real and dual parts) to a quaternion.
///
/// @see gtc_dual_quaternion
template <typename T>
detail::tdualquat<T> dualquat_cast(
detail::tmat2x4<T> const & x);
/// Converts a 3 * 4 matrix (augmented matrix rotation + translation) to a quaternion.
///
/// @see gtc_dual_quaternion
template <typename T>
detail::tdualquat<T> dualquat_cast(
detail::tmat3x4<T> const & x);
/// Dual-quaternion of floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<float> dualquat;
/// Dual-quaternion of half-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<detail::half> hdualquat;
/// Dual-quaternion of single-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<float> fdualquat;
/// Dual-quaternion of double-precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<double> ddualquat;
/// Dual-quaternion of low precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<lowp_float> lowp_dualquat;
/// Dual-quaternion of medium precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<mediump_float> mediump_dualquat;
/// Dual-quaternion of high precision floating-point numbers.
///
/// @see gtc_dual_quaternion
typedef detail::tdualquat<highp_float> highp_dualquat;
/// @}
} //namespace glm
#include "dual_quaternion.inl"
#endif//GLM_GTC_dual_quaternion

426
glm/gtc/dual_quaternion.inl
Unescape View File

@ -0,0 +1,426 @@
///////////////////////////////////////////////////////////////////////////////////
/// OpenGL Mathematics (glm.g-truc.net)
///
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref gtc_quaternion
/// @file glm/gtc/quaternion.inl
/// @date 2013-02-10 / 2013-02-13
/// @author Maksim Vorobiev (msomeone@gmail.com)
///////////////////////////////////////////////////////////////////////////////////
#include <limits>
namespace glm{
namespace detail
{
template <typename T>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename tdualquat<T>::size_type tdualquat<T>::length() const
{
return 8;
}
template <typename T>
GLM_FUNC_QUALIFIER tdualquat<T>::tdualquat() :
real(tquat<T>()),
dual(tquat<T>(tdualquat<T>::value_type(0),tdualquat<T>::value_type(0),tdualquat<T>::value_type(0),tdualquat<T>::value_type(0)))
{}
template <typename T>
GLM_FUNC_QUALIFIER tdualquat<T>::tdualquat
(
tquat<T> const & r
) :
real(r),
dual(tquat<T>(tdualquat<T>::value_type(0),tdualquat<T>::value_type(0),tdualquat<T>::value_type(0),tdualquat<T>::value_type(0)))
{}
template <typename T>
GLM_FUNC_QUALIFIER tdualquat<T>::tdualquat
(
tquat<T> const & r,
tquat<T> const & d
) :
real(r),
dual(d)
{}
template <typename T>
GLM_FUNC_QUALIFIER tdualquat<T>::tdualquat
(
tquat<T> const & q,
tvec3<T> const& p
) :
real(q),
dual(-0.5f*( p.x*q.x + p.y*q.y + p.z*q.z),
0.5f*( p.x*q.w + p.y*q.z - p.z*q.y),
0.5f*(-p.x*q.z + p.y*q.w + p.z*q.x),
0.5f*( p.x*q.y - p.y*q.x + p.z*q.w))
{}
//////////////////////////////////////////////////////////////
// tdualquat conversions
template <typename T>
GLM_FUNC_QUALIFIER tdualquat<T>::tdualquat
(
tmat2x4<T> const & holder_mat
)
{
*this = dualquat_cast<>
}
template <typename T>
GLM_FUNC_QUALIFIER tdualquat<T>::tdualquat
(
tmat3x4<T> const & m
)
{
*this = dualquat_cast(m);
}
//////////////////////////////////////////////////////////////
// tdualquat<T> accesses
template <typename T>
GLM_FUNC_QUALIFIER typename tdualquat<T>::part_type & tdualquat<T>::operator [] (int i)
{
return (&real)[i];
}
template <typename T>
GLM_FUNC_QUALIFIER typename tdualquat<T>::part_type const & tdualquat<T>::operator [] (int i) const
{
return (&real)[i];
}
//////////////////////////////////////////////////////////////
// tdualquat<valType> operators
template <typename T>
GLM_FUNC_QUALIFIER tdualquat<T> & tdualquat<T>::operator *=
(
value_type const & s
)
{
this->real *= s;
this->dual *= s;
return *this;
}
template <typename T>
GLM_FUNC_QUALIFIER tdualquat<T> & tdualquat<T>::operator /=
(
value_type const & s
)
{
this->real /= s;
this->dual /= s;
return *this;
}
//////////////////////////////////////////////////////////////
// tquat<valType> external operators
template <typename T>
GLM_FUNC_QUALIFIER detail::tdualquat<T> operator-
(
detail::tdualquat<T> const & q
)
{
return detail::tdualquat<T>(-this->real,-this->dual);
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tdualquat<T> operator+
(
detail::tdualquat<T> const & q,
detail::tdualquat<T> const & p
)
{
return detail::tdualquat<T>(q.real + p.real,q.dual + p.dual);
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tdualquat<T> operator*
(
detail::tdualquat<T> const & p,
detail::tdualquat<T> const & o
)
{
return detail::tdualquat<T>(p.real * o.real,p.real * o.dual + p.dual * o.real);
}
// Transformation
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> operator*
(
detail::tdualquat<T> const & q,
detail::tvec3<T> const & v
)
{
const detail::tvec3<T> real_v3(q.real.x,q.real.y,q.real.z);
const detail::tvec3<T> dual_v3(q.dual.x,q.dual.y,q.dual.z);
return (cross(real_v3, cross(real_v3,v) + v * q.real.w + dual_v3) + dual_v3 * q.real.w - real_v3 * q.dual.w) * detail::tdualquat<T>::value_type(2) + v;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> operator*
(
detail::tvec3<T> const & v,
detail::tdualquat<T> const & q
)
{
return inverse(q) * v;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> operator*
(
detail::tdualquat<T> const & q,
detail::tvec4<T> const & v
)
{
return detail::tvec4<T>(q * detail::tvec3<T>(v), v.w);
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> operator* (
detail::tvec4<T> const & v,
detail::tdualquat<T> const & q)
{
return inverse(q) * v;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tdualquat<T> operator*
(
detail::tdualquat<T> const & q,
typename detail::tdualquat<T>::value_type const & s
)
{
return detail::tdualquat<T>(q.real * s, q.dual * s);
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tdualquat<T> operator*
(
typename detail::tdualquat<T>::value_type const & s,
detail::tdualquat<T> const & q
)
{
return q * s;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tdualquat<T> operator/
(
detail::tdualquat<T> const & q,
typename detail::tdualquat<T>::value_type const & s
)
{
return detail::tdualquat<T>(q.real / s, q.dual / s);
}
//////////////////////////////////////
// Boolean operators
template <typename T>
GLM_FUNC_QUALIFIER bool operator==
(
detail::tdualquat<T> const & q1,
detail::tdualquat<T> const & q2
)
{
return (q1.real == q2.real) && (q1.dual == q2.dual);
}
template <typename T>
GLM_FUNC_QUALIFIER bool operator!=
(
detail::tdualquat<T> const & q1,
detail::tdualquat<T> const & q2
)
{
return (q1.real != q2.dual) || (q1.real != q2.dual);
}
}//namespace detail
////////////////////////////////////////////////////////
template <typename T>
GLM_FUNC_QUALIFIER detail::tdualquat<T> normalize
(
detail::tdualquat<T> const & q
)
{
return q / length(q.real);
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tdualquat<T> lerp
(
detail::tdualquat<T> const & x,
detail::tdualquat<T> const & y,
typename detail::tdualquat<T>::value_type const & a
)
{ // Dual Quaternion Linear blend aka DLB:
// Lerp is only defined in [0, 1]
assert(a >= T(0));
assert(a <= T(1));
const detail::tdualquat<T>::value_type k = dot(x.real,y.real) < detail::tdualquat<T>::value_type(0) ? -a : a;
const detail::tdualquat<T>::value_type one(1);
return detail::tdualquat<T>(x * (one - a) + y * k);
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tdualquat<T> inverse
(
detail::tdualquat<T> const & q
)
{
const glm::detail::tquat<T> real = conjugate(q.real);
const glm::detail::tquat<T> dual = conjugate(q.dual);
return detail::tdualquat<T>(real, dual + (real * (-2.0f * dot(real,dual))));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T> mat3_cast
(
detail::tdualquat<T> const & x
)
{
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat2x4<T> mat2x4_cast
(
detail::tdualquat<T> const & x
)
{
return detail::tmat2x4<T>( x[0].x, x[0].y, x[0].z, x[0].w, x[1].x, x[1].y, x[1].z, x[1].w );
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x4<T> mat3x4_cast
(
detail::tdualquat<T> const & x
)
{
detail::tquat<T> r = x.real / length2(x.real);
const detail::tquat<T> rr(r.w * x.real.w, r.x * x.real.x, r.y * x.real.y, r.z * x.real.z);
r *= detail::tdualquat<T>::value_type(2);
const detail::tdualquat<T>::value_type xy = r.x*d.real.y;
const detail::tdualquat<T>::value_type xz = r.x*d.real.z;
const detail::tdualquat<T>::value_type yz = r.y*d.real.z;
const detail::tdualquat<T>::value_type wx = r.w*d.real.x;
const detail::tdualquat<T>::value_type wy = r.w*d.real.y;
const detail::tdualquat<T>::value_type wz = r.w*d.real.z;
const detail::tvec4<T> a(
rr.w + rr.x - rr.y - rr.z,
xy - wz,
xz + wy,
-(x.dual.w * r.x - x.dual.x * r.w + x.dual.y * r.z - x.dual.z * r.y)
);
const detail::tvec4<T> b(
xy + wz,
rr.w + rr.y - rr.x - rr.z,
yz - wx,
-(x.dual.w * r.y - x.dual.x * r.z - x.dual.y * r.w + x.dual.z * r.x)
);
const detail::tvec4<T> c(
xz - wy,
yz + wx,
rr.w + rr.z - rr.x - rr.y,
-(x.dual.w * r.z + x.dual.x * r.y - x.dual.y * r.x - x.dual.z * r.w)
);
return detail::tmat3x4<T>(a,b,c);
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tdualquat<T> dualquat_cast
(
detail::tmat2x4<T> const & x
)
{
return detail::tdualquat (
detail::tquat<T> ( x[0].w, x[0].x, x[0].y, x[0].z ),
detail::tquat<T> ( x[1].w, x[1].x, x[1].y, x[1].z )
);
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tdualquat<T> dualquat_cast
(
detail::tmat3x4<T> const & x
)
{
detail::tquat<T> real;
const detail::tdualquat<T>::value_type trace = x[0].x + x[1].y + x[2].z;
if(trace > detail::tdualquat<T>::value_type(0))
{
const detail::tdualquat<T>::value_type r = sqrt(detail::tdualquat<T>::value_type(1) + trace);
const detail::tdualquat<T>::value_type invr = detail::tdualquat<T>::value_type(0.5) / r;
real.w = detail::tdualquat<T>::value_type(0.5) * r;
real.x = (x[2].y - x[1].z) * invr;
real.y = (x[0].z - x[2].x) * invr;
real.z = (x[1].x - x[0].y) * invr;
}
else if(x[0].x > x[1].y && x[0].x > x[2].z)
{
const detail::tdualquat<T>::value_type r = sqrt(detail::tdualquat<T>::value_type(1) + x[0].x - x[1].y - x[2].z);
const detail::tdualquat<T>::value_type invr = detail::tdualquat<T>::value_type(0.5) / r;
real.x = detail::tdualquat<T>::value_type(0.5)*r;
real.y = (x[1].x + x[0].y) * invr;
real.z = (x[0].z + x[2].x) * invr;
real.w = (x[2].y - x[1].z) * invr;
}
else if(x[1].y > x[2].z)
{
const detail::tdualquat<T>::value_type r = sqrt(detail::tdualquat<T>::value_type(1) + x[1].y - x[0].x - x[2].z);
const detail::tdualquat<T>::value_type invr = detail::tdualquat<T>::value_type(0.5) / r;
x = (x[1].x + x[0].y) * invr;
y = detail::tdualquat<T>::value_type(0.5) * r;
z = (x[2].y + x[1].z) * invr;
w = (x[0].z - x[2].x) * invr;
}
else
{
const detail::tdualquat<T>::value_type r = sqrt(detail::tdualquat<T>::value_type(1) + x[2].z - x[0].x - x[1].y);
const detail::tdualquat<T>::value_type invr = detail::tdualquat<T>::value_type(0.5) / r;
x = (x[0].z + x[2].x) * invr;
y = (x[2].y + x[1].z) * invr;
z = detail::tdualquat<T>::value_type(0.5) * r;
w = (x[1].x - x[0].y) * invr;
}
const detail::tquat<T> dual;
dual.x = 0.5f*( x[0].w*real.w + x[1].w*real.z - x[2].w*real.y);
dual.y = 0.5f*(-x[0].w*real.z + x[1].w*real.w + x[2].w*real.x);
dual.z = 0.5f*( x[0].w*real.y - x[1].w*real.x + x[2].w*real.w);
dual.w = -0.5f*( x[0].w*real.x + x[1].w*real.y + x[2].w*real.z);
return detail::tdualquat<T>(real,dual);
}
}//namespace glm

1
test/gtc/CMakeLists.txt
Unescape View File

@ -7,6 +7,7 @@ glmCreateTestGTC(gtc_matrix_inverse)
glmCreateTestGTC(gtc_matrix_transform)
glmCreateTestGTC(gtc_noise)
glmCreateTestGTC(gtc_quaternion)
glmCreateTestGTC(gtc_dual_quaternion)
glmCreateTestGTC(gtc_random)
glmCreateTestGTC(gtc_reciprocal)
glmCreateTestGTC(gtc_swizzle)

173
test/gtc/gtc_dual_quaternion.cpp
Unescape View File

@ -0,0 +1,173 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2013-02-10
// Updated : 2013-02-11
// Licence : This source is under MIT licence
// File : test/gtc/gtc_dual_quaternion.cpp
///////////////////////////////////////////////////////////////////////////////////////////////////
#include <glm/glm.hpp>
#include <glm/gtc/dual_quaternion.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/epsilon.hpp>
#include <glm/gtx/euler_angles.hpp>
#include <iostream>
int myrand()
{
static int holdrand = 1;
return (((holdrand = holdrand * 214013L + 2531011L) >> 16) & 0x7fff);
}
float myfrand() // returns values from -1 to 1 inclusive
{
return float(double(myrand()) / double( 0x7ffff )) * 2.0f - 1.0f;
}
int test_dquat_type()
{
glm::dvec3 vA;
glm::dquat dqA,dqB;
glm::ddualquat C(dqA,dqB);
glm::ddualquat B(dqA);
glm::ddualquat D(dqA,vA);
return 0;
}
int test_scalars() {
float const Epsilon = 0.0001f;
int Error(0);
glm::quat src_q1 = glm::quat(1.0f,2.0f,3.0f,4.0f);
glm::quat src_q2 = glm::quat(5.0f,6.0f,7.0f,8.0f);
glm::dualquat src1(src_q1,src_q2);
{
glm::dualquat dst1 = src1 * 2.0f;
glm::dualquat dst2 = 2.0f * src1;
glm::dualquat dst3 = src1;
dst3 *= 2.0f;
glm::dualquat dstCmp(src_q1 * 2.0f,src_q2 * 2.0f);
Error += glm::all(glm::epsilonEqual(dst1.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst1.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
Error += glm::all(glm::epsilonEqual(dst2.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst2.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
Error += glm::all(glm::epsilonEqual(dst3.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst3.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
}
{
glm::dualquat dst1 = src1 / 2.0f;
glm::dualquat dst2 = src1;
dst2 /= 2.0f;
glm::dualquat dstCmp(src_q1 / 2.0f,src_q2 / 2.0f);
Error += glm::all(glm::epsilonEqual(dst1.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst1.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
Error += glm::all(glm::epsilonEqual(dst2.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst2.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
}
return Error;
}
int test_inverse()
{
int Error(0);
float const Epsilon = 0.0001f;
glm::dualquat dqid;
glm::mat4x4 mid(1.0f);
for (int j = 0; j < 100; ++j) {
glm::mat4x4 rot = glm::yawPitchRoll(myfrand() * 360.0f, myfrand() * 360.0f, myfrand() * 360.0f);
glm::vec3 vt = glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f);
glm::mat4x4 m = glm::translate(mid, vt) * rot;
glm::quat qr = glm::quat_cast(m);
glm::dualquat dq(qr);
glm::dualquat invdq = glm::inverse(dq);
glm::dualquat r1 = invdq * dq;
glm::dualquat r2 = dq * invdq;
Error += glm::all(glm::epsilonEqual(r1.real, dqid.real, Epsilon)) && glm::all(glm::epsilonEqual(r1.dual, dqid.dual, Epsilon)) ? 0 : 1;
Error += glm::all(glm::epsilonEqual(r2.real, dqid.real, Epsilon)) && glm::all(glm::epsilonEqual(r2.dual, dqid.dual, Epsilon)) ? 0 : 1;
// testing commutative property
glm::dualquat r ( glm::quat( myfrand() * glm::pi<float>() * 2.0f, myfrand(), myfrand(), myfrand() ),
glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f) );
glm::dualquat riq = (r * invdq) * dq;
glm::dualquat rqi = (r * dq) * invdq;
Error += glm::all(glm::epsilonEqual(riq.real, rqi.real, Epsilon)) && glm::all(glm::epsilonEqual(riq.dual, rqi.dual, Epsilon)) ? 0 : 1;
}
return Error;
}
int test_mul()
{
int Error(0);
float const Epsilon = 0.0001f;
glm::mat4x4 mid(1.0f);
for (int j = 0; j < 100; ++j) {
// generate random rotations and translations and compare transformed by matrix and dualquats random points
glm::vec3 vt1 = glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f);
glm::vec3 vt2 = glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f);
glm::mat4x4 rot1 = glm::yawPitchRoll(myfrand() * 360.0f, myfrand() * 360.0f, myfrand() * 360.0f);
glm::mat4x4 rot2 = glm::yawPitchRoll(myfrand() * 360.0f, myfrand() * 360.0f, myfrand() * 360.0f);
glm::mat4x4 m1 = glm::translate(mid, vt1) * rot1;
glm::mat4x4 m2 = glm::translate(mid, vt2) * rot2;
glm::mat4x4 m3 = m2 * m1;
glm::mat4x4 m4 = m1 * m2;
glm::quat qrot1 = glm::quat_cast(rot1);
glm::quat qrot2 = glm::quat_cast(rot2);
glm::dualquat dq1 = glm::dualquat(qrot1,vt1);
glm::dualquat dq2 = glm::dualquat(qrot2,vt2);
glm::dualquat dq3 = dq2 * dq1;
glm::dualquat dq4 = dq1 * dq2;
for (int i = 0; i < 100; ++i) {
glm::vec4 src_pt = glm::vec4(myfrand() * 4.0f, myfrand() * 5.0f, myfrand() * 3.0f,1.0f);
// test both multiplication orders
glm::vec4 dst_pt_m3 = m3 * src_pt;
glm::vec4 dst_pt_dq3 = dq3 * src_pt;
glm::vec4 dst_pt_m3_i = glm::inverse(m3) * src_pt;
glm::vec4 dst_pt_dq3_i = src_pt * dq3;
glm::vec4 dst_pt_m4 = m4 * src_pt;
glm::vec4 dst_pt_dq4 = dq4 * src_pt;
glm::vec4 dst_pt_m4_i = glm::inverse(m4) * src_pt;
glm::vec4 dst_pt_dq4_i = src_pt * dq4;
Error += glm::all(glm::epsilonEqual(dst_pt_m3, dst_pt_dq3, Epsilon)) ? 0 : 1;
Error += glm::all(glm::epsilonEqual(dst_pt_m4, dst_pt_dq4, Epsilon)) ? 0 : 1;
Error += glm::all(glm::epsilonEqual(dst_pt_m3_i, dst_pt_dq3_i, Epsilon)) ? 0 : 1;
Error += glm::all(glm::epsilonEqual(dst_pt_m4_i, dst_pt_dq4_i, Epsilon)) ? 0 : 1;
}
}
return Error;
}
int main()
{
int Error(0);
Error += test_dquat_type();
Error += test_scalars();
Error += test_inverse();
Error += test_mul();
//std::cout << "Errors count: " << Error << std::endl;
return Error;
}
Write Preview
Loading…
Cancel
Save