1 #define GLM_ENABLE_EXPERIMENTAL
2 #define GLM_FORCE_CTOR_INIT
3 #include <glm/gtx/dual_quaternion.hpp>
4 #include <glm/gtc/matrix_transform.hpp>
5 #include <glm/gtc/epsilon.hpp>
6 #include <glm/gtx/euler_angles.hpp>
7 #include <glm/vector_relational.hpp>
8 #if GLM_HAS_TRIVIAL_QUERIES
9 # include <type_traits>
10 #endif
11
myrand()12 int myrand()
13 {
14 static int holdrand = 1;
15 return (((holdrand = holdrand * 214013L + 2531011L) >> 16) & 0x7fff);
16 }
17
myfrand()18 float myfrand() // returns values from -1 to 1 inclusive
19 {
20 return float(double(myrand()) / double( 0x7ffff )) * 2.0f - 1.0f;
21 }
22
test_dquat_type()23 int test_dquat_type()
24 {
25 glm::dvec3 vA;
26 glm::dquat dqA, dqB;
27 glm::ddualquat C(dqA, dqB);
28 glm::ddualquat B(dqA);
29 glm::ddualquat D(dqA, vA);
30 return 0;
31 }
32
test_scalars()33 int test_scalars()
34 {
35 float const Epsilon = 0.0001f;
36
37 int Error(0);
38
39 glm::quat src_q1 = glm::quat(1.0f,2.0f,3.0f,4.0f);
40 glm::quat src_q2 = glm::quat(5.0f,6.0f,7.0f,8.0f);
41 glm::dualquat src1(src_q1,src_q2);
42
43 {
44 glm::dualquat dst1 = src1 * 2.0f;
45 glm::dualquat dst2 = 2.0f * src1;
46 glm::dualquat dst3 = src1;
47 dst3 *= 2.0f;
48 glm::dualquat dstCmp(src_q1 * 2.0f,src_q2 * 2.0f);
49 Error += glm::all(glm::epsilonEqual(dst1.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst1.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
50 Error += glm::all(glm::epsilonEqual(dst2.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst2.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
51 Error += glm::all(glm::epsilonEqual(dst3.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst3.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
52 }
53
54 {
55 glm::dualquat dst1 = src1 / 2.0f;
56 glm::dualquat dst2 = src1;
57 dst2 /= 2.0f;
58 glm::dualquat dstCmp(src_q1 / 2.0f,src_q2 / 2.0f);
59 Error += glm::all(glm::epsilonEqual(dst1.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst1.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
60 Error += glm::all(glm::epsilonEqual(dst2.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst2.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
61 }
62 return Error;
63 }
64
test_inverse()65 int test_inverse()
66 {
67 int Error(0);
68
69 float const Epsilon = 0.0001f;
70
71 glm::dualquat dqid = glm::dual_quat_identity<float, glm::defaultp>();
72 glm::mat4x4 mid(1.0f);
73
74 for (int j = 0; j < 100; ++j)
75 {
76 glm::mat4x4 rot = glm::yawPitchRoll(myfrand() * 360.0f, myfrand() * 360.0f, myfrand() * 360.0f);
77 glm::vec3 vt = glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f);
78
79 glm::mat4x4 m = glm::translate(mid, vt) * rot;
80
81 glm::quat qr = glm::quat_cast(m);
82
83 glm::dualquat dq(qr);
84
85 glm::dualquat invdq = glm::inverse(dq);
86
87 glm::dualquat r1 = invdq * dq;
88 glm::dualquat r2 = dq * invdq;
89
90 Error += glm::all(glm::epsilonEqual(r1.real, dqid.real, Epsilon)) && glm::all(glm::epsilonEqual(r1.dual, dqid.dual, Epsilon)) ? 0 : 1;
91 Error += glm::all(glm::epsilonEqual(r2.real, dqid.real, Epsilon)) && glm::all(glm::epsilonEqual(r2.dual, dqid.dual, Epsilon)) ? 0 : 1;
92
93 // testing commutative property
94 glm::dualquat r ( glm::quat( myfrand() * glm::pi<float>() * 2.0f, myfrand(), myfrand(), myfrand() ),
95 glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f) );
96 glm::dualquat riq = (r * invdq) * dq;
97 glm::dualquat rqi = (r * dq) * invdq;
98
99 Error += glm::all(glm::epsilonEqual(riq.real, rqi.real, Epsilon)) && glm::all(glm::epsilonEqual(riq.dual, rqi.dual, Epsilon)) ? 0 : 1;
100 }
101
102 return Error;
103 }
104
test_mul()105 int test_mul()
106 {
107 int Error(0);
108
109 float const Epsilon = 0.0001f;
110
111 glm::mat4x4 mid(1.0f);
112
113 for (int j = 0; j < 100; ++j)
114 {
115 // generate random rotations and translations and compare transformed by matrix and dualquats random points
116 glm::vec3 vt1 = glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f);
117 glm::vec3 vt2 = glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f);
118
119 glm::mat4x4 rot1 = glm::yawPitchRoll(myfrand() * 360.0f, myfrand() * 360.0f, myfrand() * 360.0f);
120 glm::mat4x4 rot2 = glm::yawPitchRoll(myfrand() * 360.0f, myfrand() * 360.0f, myfrand() * 360.0f);
121 glm::mat4x4 m1 = glm::translate(mid, vt1) * rot1;
122 glm::mat4x4 m2 = glm::translate(mid, vt2) * rot2;
123 glm::mat4x4 m3 = m2 * m1;
124 glm::mat4x4 m4 = m1 * m2;
125
126 glm::quat qrot1 = glm::quat_cast(rot1);
127 glm::quat qrot2 = glm::quat_cast(rot2);
128
129 glm::dualquat dq1 = glm::dualquat(qrot1,vt1);
130 glm::dualquat dq2 = glm::dualquat(qrot2,vt2);
131 glm::dualquat dq3 = dq2 * dq1;
132 glm::dualquat dq4 = dq1 * dq2;
133
134 for (int i = 0; i < 100; ++i)
135 {
136 glm::vec4 src_pt = glm::vec4(myfrand() * 4.0f, myfrand() * 5.0f, myfrand() * 3.0f,1.0f);
137 // test both multiplication orders
138 glm::vec4 dst_pt_m3 = m3 * src_pt;
139 glm::vec4 dst_pt_dq3 = dq3 * src_pt;
140
141 glm::vec4 dst_pt_m3_i = glm::inverse(m3) * src_pt;
142 glm::vec4 dst_pt_dq3_i = src_pt * dq3;
143
144 glm::vec4 dst_pt_m4 = m4 * src_pt;
145 glm::vec4 dst_pt_dq4 = dq4 * src_pt;
146
147 glm::vec4 dst_pt_m4_i = glm::inverse(m4) * src_pt;
148 glm::vec4 dst_pt_dq4_i = src_pt * dq4;
149
150 Error += glm::all(glm::epsilonEqual(dst_pt_m3, dst_pt_dq3, Epsilon)) ? 0 : 1;
151 Error += glm::all(glm::epsilonEqual(dst_pt_m4, dst_pt_dq4, Epsilon)) ? 0 : 1;
152 Error += glm::all(glm::epsilonEqual(dst_pt_m3_i, dst_pt_dq3_i, Epsilon)) ? 0 : 1;
153 Error += glm::all(glm::epsilonEqual(dst_pt_m4_i, dst_pt_dq4_i, Epsilon)) ? 0 : 1;
154 }
155 }
156
157 return Error;
158 }
159
test_dual_quat_ctr()160 int test_dual_quat_ctr()
161 {
162 int Error(0);
163
164 # if GLM_HAS_TRIVIAL_QUERIES
165 // Error += std::is_trivially_default_constructible<glm::dualquat>::value ? 0 : 1;
166 // Error += std::is_trivially_default_constructible<glm::ddualquat>::value ? 0 : 1;
167 // Error += std::is_trivially_copy_assignable<glm::dualquat>::value ? 0 : 1;
168 // Error += std::is_trivially_copy_assignable<glm::ddualquat>::value ? 0 : 1;
169 Error += std::is_trivially_copyable<glm::dualquat>::value ? 0 : 1;
170 Error += std::is_trivially_copyable<glm::ddualquat>::value ? 0 : 1;
171
172 Error += std::is_copy_constructible<glm::dualquat>::value ? 0 : 1;
173 Error += std::is_copy_constructible<glm::ddualquat>::value ? 0 : 1;
174 # endif
175
176 return Error;
177 }
178
test_size()179 int test_size()
180 {
181 int Error = 0;
182
183 Error += 32 == sizeof(glm::dualquat) ? 0 : 1;
184 Error += 64 == sizeof(glm::ddualquat) ? 0 : 1;
185 Error += glm::dualquat().length() == 2 ? 0 : 1;
186 Error += glm::ddualquat().length() == 2 ? 0 : 1;
187 Error += glm::dualquat::length() == 2 ? 0 : 1;
188 Error += glm::ddualquat::length() == 2 ? 0 : 1;
189
190 return Error;
191 }
192
main()193 int main()
194 {
195 int Error = 0;
196
197 Error += test_dual_quat_ctr();
198 Error += test_dquat_type();
199 Error += test_scalars();
200 Error += test_inverse();
201 Error += test_mul();
202 Error += test_size();
203
204 return Error;
205 }
206