miniassimp

annotate include/miniassimp/matrix4x4.inl @ 0:879c81d94345

find changesets by author, revision, files, or words in the commit message
initial commit
author John Tsiombikas <nuclear@member.fsf.org>
date Mon, 28 Jan 2019 18:19:26 +0200
parents
children
rev   line source
nuclear@0 1 /*
nuclear@0 2 ---------------------------------------------------------------------------
nuclear@0 3 Open Asset Import Library (assimp)
nuclear@0 4 ---------------------------------------------------------------------------
nuclear@0 5
nuclear@0 6 Copyright (c) 2006-2018, assimp team
nuclear@0 7
nuclear@0 8
nuclear@0 9
nuclear@0 10 All rights reserved.
nuclear@0 11
nuclear@0 12 Redistribution and use of this software in source and binary forms,
nuclear@0 13 with or without modification, are permitted provided that the following
nuclear@0 14 conditions are met:
nuclear@0 15
nuclear@0 16 * Redistributions of source code must retain the above
nuclear@0 17 copyright notice, this list of conditions and the
nuclear@0 18 following disclaimer.
nuclear@0 19
nuclear@0 20 * Redistributions in binary form must reproduce the above
nuclear@0 21 copyright notice, this list of conditions and the
nuclear@0 22 following disclaimer in the documentation and/or other
nuclear@0 23 materials provided with the distribution.
nuclear@0 24
nuclear@0 25 * Neither the name of the assimp team, nor the names of its
nuclear@0 26 contributors may be used to endorse or promote products
nuclear@0 27 derived from this software without specific prior
nuclear@0 28 written permission of the assimp team.
nuclear@0 29
nuclear@0 30 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
nuclear@0 31 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
nuclear@0 32 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
nuclear@0 33 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
nuclear@0 34 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
nuclear@0 35 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
nuclear@0 36 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
nuclear@0 37 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
nuclear@0 38 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
nuclear@0 39 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
nuclear@0 40 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
nuclear@0 41 ---------------------------------------------------------------------------
nuclear@0 42 */
nuclear@0 43
nuclear@0 44 /** @file matrix4x4.inl
nuclear@0 45 * @brief Inline implementation of the 4x4 matrix operators
nuclear@0 46 */
nuclear@0 47 #pragma once
nuclear@0 48 #ifndef AI_MATRIX4X4_INL_INC
nuclear@0 49 #define AI_MATRIX4X4_INL_INC
nuclear@0 50
nuclear@0 51 #ifdef __cplusplus
nuclear@0 52
nuclear@0 53 #include "matrix4x4.h"
nuclear@0 54 #include "matrix3x3.h"
nuclear@0 55 #include "quaternion.h"
nuclear@0 56
nuclear@0 57 #include <algorithm>
nuclear@0 58 #include <limits>
nuclear@0 59 #include <cmath>
nuclear@0 60
nuclear@0 61 // ----------------------------------------------------------------------------------------
nuclear@0 62 template <typename TReal>
nuclear@0 63 aiMatrix4x4t<TReal>::aiMatrix4x4t() AI_NO_EXCEPT :
nuclear@0 64 a1(1.0f), a2(), a3(), a4(),
nuclear@0 65 b1(), b2(1.0f), b3(), b4(),
nuclear@0 66 c1(), c2(), c3(1.0f), c4(),
nuclear@0 67 d1(), d2(), d3(), d4(1.0f)
nuclear@0 68 {
nuclear@0 69
nuclear@0 70 }
nuclear@0 71
nuclear@0 72 // ----------------------------------------------------------------------------------------
nuclear@0 73 template <typename TReal>
nuclear@0 74 aiMatrix4x4t<TReal>::aiMatrix4x4t (TReal _a1, TReal _a2, TReal _a3, TReal _a4,
nuclear@0 75 TReal _b1, TReal _b2, TReal _b3, TReal _b4,
nuclear@0 76 TReal _c1, TReal _c2, TReal _c3, TReal _c4,
nuclear@0 77 TReal _d1, TReal _d2, TReal _d3, TReal _d4) :
nuclear@0 78 a1(_a1), a2(_a2), a3(_a3), a4(_a4),
nuclear@0 79 b1(_b1), b2(_b2), b3(_b3), b4(_b4),
nuclear@0 80 c1(_c1), c2(_c2), c3(_c3), c4(_c4),
nuclear@0 81 d1(_d1), d2(_d2), d3(_d3), d4(_d4)
nuclear@0 82 {
nuclear@0 83
nuclear@0 84 }
nuclear@0 85
nuclear@0 86 // ------------------------------------------------------------------------------------------------
nuclear@0 87 template <typename TReal>
nuclear@0 88 template <typename TOther>
nuclear@0 89 aiMatrix4x4t<TReal>::operator aiMatrix4x4t<TOther> () const
nuclear@0 90 {
nuclear@0 91 return aiMatrix4x4t<TOther>(static_cast<TOther>(a1),static_cast<TOther>(a2),static_cast<TOther>(a3),static_cast<TOther>(a4),
nuclear@0 92 static_cast<TOther>(b1),static_cast<TOther>(b2),static_cast<TOther>(b3),static_cast<TOther>(b4),
nuclear@0 93 static_cast<TOther>(c1),static_cast<TOther>(c2),static_cast<TOther>(c3),static_cast<TOther>(c4),
nuclear@0 94 static_cast<TOther>(d1),static_cast<TOther>(d2),static_cast<TOther>(d3),static_cast<TOther>(d4));
nuclear@0 95 }
nuclear@0 96
nuclear@0 97
nuclear@0 98 // ----------------------------------------------------------------------------------------
nuclear@0 99 template <typename TReal>
nuclear@0 100 inline aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiMatrix3x3t<TReal>& m)
nuclear@0 101 {
nuclear@0 102 a1 = m.a1; a2 = m.a2; a3 = m.a3; a4 = static_cast<TReal>(0.0);
nuclear@0 103 b1 = m.b1; b2 = m.b2; b3 = m.b3; b4 = static_cast<TReal>(0.0);
nuclear@0 104 c1 = m.c1; c2 = m.c2; c3 = m.c3; c4 = static_cast<TReal>(0.0);
nuclear@0 105 d1 = static_cast<TReal>(0.0); d2 = static_cast<TReal>(0.0); d3 = static_cast<TReal>(0.0); d4 = static_cast<TReal>(1.0);
nuclear@0 106 }
nuclear@0 107
nuclear@0 108 // ----------------------------------------------------------------------------------------
nuclear@0 109 template <typename TReal>
nuclear@0 110 inline aiMatrix4x4t<TReal>::aiMatrix4x4t (const aiVector3t<TReal>& scaling, const aiQuaterniont<TReal>& rotation, const aiVector3t<TReal>& position)
nuclear@0 111 {
nuclear@0 112 // build a 3x3 rotation matrix
nuclear@0 113 aiMatrix3x3t<TReal> m = rotation.GetMatrix();
nuclear@0 114
nuclear@0 115 a1 = m.a1 * scaling.x;
nuclear@0 116 a2 = m.a2 * scaling.x;
nuclear@0 117 a3 = m.a3 * scaling.x;
nuclear@0 118 a4 = position.x;
nuclear@0 119
nuclear@0 120 b1 = m.b1 * scaling.y;
nuclear@0 121 b2 = m.b2 * scaling.y;
nuclear@0 122 b3 = m.b3 * scaling.y;
nuclear@0 123 b4 = position.y;
nuclear@0 124
nuclear@0 125 c1 = m.c1 * scaling.z;
nuclear@0 126 c2 = m.c2 * scaling.z;
nuclear@0 127 c3 = m.c3 * scaling.z;
nuclear@0 128 c4= position.z;
nuclear@0 129
nuclear@0 130 d1 = static_cast<TReal>(0.0);
nuclear@0 131 d2 = static_cast<TReal>(0.0);
nuclear@0 132 d3 = static_cast<TReal>(0.0);
nuclear@0 133 d4 = static_cast<TReal>(1.0);
nuclear@0 134 }
nuclear@0 135
nuclear@0 136 // ----------------------------------------------------------------------------------------
nuclear@0 137 template <typename TReal>
nuclear@0 138 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::operator *= (const aiMatrix4x4t<TReal>& m)
nuclear@0 139 {
nuclear@0 140 *this = aiMatrix4x4t<TReal>(
nuclear@0 141 m.a1 * a1 + m.b1 * a2 + m.c1 * a3 + m.d1 * a4,
nuclear@0 142 m.a2 * a1 + m.b2 * a2 + m.c2 * a3 + m.d2 * a4,
nuclear@0 143 m.a3 * a1 + m.b3 * a2 + m.c3 * a3 + m.d3 * a4,
nuclear@0 144 m.a4 * a1 + m.b4 * a2 + m.c4 * a3 + m.d4 * a4,
nuclear@0 145 m.a1 * b1 + m.b1 * b2 + m.c1 * b3 + m.d1 * b4,
nuclear@0 146 m.a2 * b1 + m.b2 * b2 + m.c2 * b3 + m.d2 * b4,
nuclear@0 147 m.a3 * b1 + m.b3 * b2 + m.c3 * b3 + m.d3 * b4,
nuclear@0 148 m.a4 * b1 + m.b4 * b2 + m.c4 * b3 + m.d4 * b4,
nuclear@0 149 m.a1 * c1 + m.b1 * c2 + m.c1 * c3 + m.d1 * c4,
nuclear@0 150 m.a2 * c1 + m.b2 * c2 + m.c2 * c3 + m.d2 * c4,
nuclear@0 151 m.a3 * c1 + m.b3 * c2 + m.c3 * c3 + m.d3 * c4,
nuclear@0 152 m.a4 * c1 + m.b4 * c2 + m.c4 * c3 + m.d4 * c4,
nuclear@0 153 m.a1 * d1 + m.b1 * d2 + m.c1 * d3 + m.d1 * d4,
nuclear@0 154 m.a2 * d1 + m.b2 * d2 + m.c2 * d3 + m.d2 * d4,
nuclear@0 155 m.a3 * d1 + m.b3 * d2 + m.c3 * d3 + m.d3 * d4,
nuclear@0 156 m.a4 * d1 + m.b4 * d2 + m.c4 * d3 + m.d4 * d4);
nuclear@0 157 return *this;
nuclear@0 158 }
nuclear@0 159
nuclear@0 160 // ----------------------------------------------------------------------------------------
nuclear@0 161 template <typename TReal>
nuclear@0 162 inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const TReal& aFloat) const
nuclear@0 163 {
nuclear@0 164 aiMatrix4x4t<TReal> temp(
nuclear@0 165 a1 * aFloat,
nuclear@0 166 a2 * aFloat,
nuclear@0 167 a3 * aFloat,
nuclear@0 168 a4 * aFloat,
nuclear@0 169 b1 * aFloat,
nuclear@0 170 b2 * aFloat,
nuclear@0 171 b3 * aFloat,
nuclear@0 172 b4 * aFloat,
nuclear@0 173 c1 * aFloat,
nuclear@0 174 c2 * aFloat,
nuclear@0 175 c3 * aFloat,
nuclear@0 176 c4 * aFloat,
nuclear@0 177 d1 * aFloat,
nuclear@0 178 d2 * aFloat,
nuclear@0 179 d3 * aFloat,
nuclear@0 180 d4 * aFloat);
nuclear@0 181 return temp;
nuclear@0 182 }
nuclear@0 183
nuclear@0 184 // ----------------------------------------------------------------------------------------
nuclear@0 185 template <typename TReal>
nuclear@0 186 inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator+ (const aiMatrix4x4t<TReal>& m) const
nuclear@0 187 {
nuclear@0 188 aiMatrix4x4t<TReal> temp(
nuclear@0 189 m.a1 + a1,
nuclear@0 190 m.a2 + a2,
nuclear@0 191 m.a3 + a3,
nuclear@0 192 m.a4 + a4,
nuclear@0 193 m.b1 + b1,
nuclear@0 194 m.b2 + b2,
nuclear@0 195 m.b3 + b3,
nuclear@0 196 m.b4 + b4,
nuclear@0 197 m.c1 + c1,
nuclear@0 198 m.c2 + c2,
nuclear@0 199 m.c3 + c3,
nuclear@0 200 m.c4 + c4,
nuclear@0 201 m.d1 + d1,
nuclear@0 202 m.d2 + d2,
nuclear@0 203 m.d3 + d3,
nuclear@0 204 m.d4 + d4);
nuclear@0 205 return temp;
nuclear@0 206 }
nuclear@0 207
nuclear@0 208 // ----------------------------------------------------------------------------------------
nuclear@0 209 template <typename TReal>
nuclear@0 210 inline aiMatrix4x4t<TReal> aiMatrix4x4t<TReal>::operator* (const aiMatrix4x4t<TReal>& m) const
nuclear@0 211 {
nuclear@0 212 aiMatrix4x4t<TReal> temp( *this);
nuclear@0 213 temp *= m;
nuclear@0 214 return temp;
nuclear@0 215 }
nuclear@0 216
nuclear@0 217
nuclear@0 218 // ----------------------------------------------------------------------------------------
nuclear@0 219 template <typename TReal>
nuclear@0 220 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Transpose()
nuclear@0 221 {
nuclear@0 222 // (TReal&) don't remove, GCC complains cause of packed fields
nuclear@0 223 std::swap( (TReal&)b1, (TReal&)a2);
nuclear@0 224 std::swap( (TReal&)c1, (TReal&)a3);
nuclear@0 225 std::swap( (TReal&)c2, (TReal&)b3);
nuclear@0 226 std::swap( (TReal&)d1, (TReal&)a4);
nuclear@0 227 std::swap( (TReal&)d2, (TReal&)b4);
nuclear@0 228 std::swap( (TReal&)d3, (TReal&)c4);
nuclear@0 229 return *this;
nuclear@0 230 }
nuclear@0 231
nuclear@0 232
nuclear@0 233 // ----------------------------------------------------------------------------------------
nuclear@0 234 template <typename TReal>
nuclear@0 235 inline TReal aiMatrix4x4t<TReal>::Determinant() const
nuclear@0 236 {
nuclear@0 237 return a1*b2*c3*d4 - a1*b2*c4*d3 + a1*b3*c4*d2 - a1*b3*c2*d4
nuclear@0 238 + a1*b4*c2*d3 - a1*b4*c3*d2 - a2*b3*c4*d1 + a2*b3*c1*d4
nuclear@0 239 - a2*b4*c1*d3 + a2*b4*c3*d1 - a2*b1*c3*d4 + a2*b1*c4*d3
nuclear@0 240 + a3*b4*c1*d2 - a3*b4*c2*d1 + a3*b1*c2*d4 - a3*b1*c4*d2
nuclear@0 241 + a3*b2*c4*d1 - a3*b2*c1*d4 - a4*b1*c2*d3 + a4*b1*c3*d2
nuclear@0 242 - a4*b2*c3*d1 + a4*b2*c1*d3 - a4*b3*c1*d2 + a4*b3*c2*d1;
nuclear@0 243 }
nuclear@0 244
nuclear@0 245 // ----------------------------------------------------------------------------------------
nuclear@0 246 template <typename TReal>
nuclear@0 247 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Inverse()
nuclear@0 248 {
nuclear@0 249 // Compute the reciprocal determinant
nuclear@0 250 const TReal det = Determinant();
nuclear@0 251 if(det == static_cast<TReal>(0.0))
nuclear@0 252 {
nuclear@0 253 // Matrix not invertible. Setting all elements to nan is not really
nuclear@0 254 // correct in a mathematical sense but it is easy to debug for the
nuclear@0 255 // programmer.
nuclear@0 256 const TReal nan = std::numeric_limits<TReal>::quiet_NaN();
nuclear@0 257 *this = aiMatrix4x4t<TReal>(
nuclear@0 258 nan,nan,nan,nan,
nuclear@0 259 nan,nan,nan,nan,
nuclear@0 260 nan,nan,nan,nan,
nuclear@0 261 nan,nan,nan,nan);
nuclear@0 262
nuclear@0 263 return *this;
nuclear@0 264 }
nuclear@0 265
nuclear@0 266 const TReal invdet = static_cast<TReal>(1.0) / det;
nuclear@0 267
nuclear@0 268 aiMatrix4x4t<TReal> res;
nuclear@0 269 res.a1 = invdet * (b2 * (c3 * d4 - c4 * d3) + b3 * (c4 * d2 - c2 * d4) + b4 * (c2 * d3 - c3 * d2));
nuclear@0 270 res.a2 = -invdet * (a2 * (c3 * d4 - c4 * d3) + a3 * (c4 * d2 - c2 * d4) + a4 * (c2 * d3 - c3 * d2));
nuclear@0 271 res.a3 = invdet * (a2 * (b3 * d4 - b4 * d3) + a3 * (b4 * d2 - b2 * d4) + a4 * (b2 * d3 - b3 * d2));
nuclear@0 272 res.a4 = -invdet * (a2 * (b3 * c4 - b4 * c3) + a3 * (b4 * c2 - b2 * c4) + a4 * (b2 * c3 - b3 * c2));
nuclear@0 273 res.b1 = -invdet * (b1 * (c3 * d4 - c4 * d3) + b3 * (c4 * d1 - c1 * d4) + b4 * (c1 * d3 - c3 * d1));
nuclear@0 274 res.b2 = invdet * (a1 * (c3 * d4 - c4 * d3) + a3 * (c4 * d1 - c1 * d4) + a4 * (c1 * d3 - c3 * d1));
nuclear@0 275 res.b3 = -invdet * (a1 * (b3 * d4 - b4 * d3) + a3 * (b4 * d1 - b1 * d4) + a4 * (b1 * d3 - b3 * d1));
nuclear@0 276 res.b4 = invdet * (a1 * (b3 * c4 - b4 * c3) + a3 * (b4 * c1 - b1 * c4) + a4 * (b1 * c3 - b3 * c1));
nuclear@0 277 res.c1 = invdet * (b1 * (c2 * d4 - c4 * d2) + b2 * (c4 * d1 - c1 * d4) + b4 * (c1 * d2 - c2 * d1));
nuclear@0 278 res.c2 = -invdet * (a1 * (c2 * d4 - c4 * d2) + a2 * (c4 * d1 - c1 * d4) + a4 * (c1 * d2 - c2 * d1));
nuclear@0 279 res.c3 = invdet * (a1 * (b2 * d4 - b4 * d2) + a2 * (b4 * d1 - b1 * d4) + a4 * (b1 * d2 - b2 * d1));
nuclear@0 280 res.c4 = -invdet * (a1 * (b2 * c4 - b4 * c2) + a2 * (b4 * c1 - b1 * c4) + a4 * (b1 * c2 - b2 * c1));
nuclear@0 281 res.d1 = -invdet * (b1 * (c2 * d3 - c3 * d2) + b2 * (c3 * d1 - c1 * d3) + b3 * (c1 * d2 - c2 * d1));
nuclear@0 282 res.d2 = invdet * (a1 * (c2 * d3 - c3 * d2) + a2 * (c3 * d1 - c1 * d3) + a3 * (c1 * d2 - c2 * d1));
nuclear@0 283 res.d3 = -invdet * (a1 * (b2 * d3 - b3 * d2) + a2 * (b3 * d1 - b1 * d3) + a3 * (b1 * d2 - b2 * d1));
nuclear@0 284 res.d4 = invdet * (a1 * (b2 * c3 - b3 * c2) + a2 * (b3 * c1 - b1 * c3) + a3 * (b1 * c2 - b2 * c1));
nuclear@0 285 *this = res;
nuclear@0 286
nuclear@0 287 return *this;
nuclear@0 288 }
nuclear@0 289
nuclear@0 290 // ----------------------------------------------------------------------------------------
nuclear@0 291 template <typename TReal>
nuclear@0 292 inline TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) {
nuclear@0 293 if (p_iIndex > 3) {
nuclear@0 294 return NULL;
nuclear@0 295 }
nuclear@0 296 switch ( p_iIndex ) {
nuclear@0 297 case 0:
nuclear@0 298 return &a1;
nuclear@0 299 case 1:
nuclear@0 300 return &b1;
nuclear@0 301 case 2:
nuclear@0 302 return &c1;
nuclear@0 303 case 3:
nuclear@0 304 return &d1;
nuclear@0 305 default:
nuclear@0 306 break;
nuclear@0 307 }
nuclear@0 308 return &a1;
nuclear@0 309 }
nuclear@0 310
nuclear@0 311 // ----------------------------------------------------------------------------------------
nuclear@0 312 template <typename TReal>
nuclear@0 313 inline const TReal* aiMatrix4x4t<TReal>::operator[](unsigned int p_iIndex) const {
nuclear@0 314 if (p_iIndex > 3) {
nuclear@0 315 return NULL;
nuclear@0 316 }
nuclear@0 317
nuclear@0 318 switch ( p_iIndex ) {
nuclear@0 319 case 0:
nuclear@0 320 return &a1;
nuclear@0 321 case 1:
nuclear@0 322 return &b1;
nuclear@0 323 case 2:
nuclear@0 324 return &c1;
nuclear@0 325 case 3:
nuclear@0 326 return &d1;
nuclear@0 327 default:
nuclear@0 328 break;
nuclear@0 329 }
nuclear@0 330 return &a1;
nuclear@0 331 }
nuclear@0 332
nuclear@0 333 // ----------------------------------------------------------------------------------------
nuclear@0 334 template <typename TReal>
nuclear@0 335 inline bool aiMatrix4x4t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const
nuclear@0 336 {
nuclear@0 337 return (a1 == m.a1 && a2 == m.a2 && a3 == m.a3 && a4 == m.a4 &&
nuclear@0 338 b1 == m.b1 && b2 == m.b2 && b3 == m.b3 && b4 == m.b4 &&
nuclear@0 339 c1 == m.c1 && c2 == m.c2 && c3 == m.c3 && c4 == m.c4 &&
nuclear@0 340 d1 == m.d1 && d2 == m.d2 && d3 == m.d3 && d4 == m.d4);
nuclear@0 341 }
nuclear@0 342
nuclear@0 343 // ----------------------------------------------------------------------------------------
nuclear@0 344 template <typename TReal>
nuclear@0 345 inline bool aiMatrix4x4t<TReal>::operator!= (const aiMatrix4x4t<TReal>& m) const
nuclear@0 346 {
nuclear@0 347 return !(*this == m);
nuclear@0 348 }
nuclear@0 349
nuclear@0 350 // ---------------------------------------------------------------------------
nuclear@0 351 template<typename TReal>
nuclear@0 352 inline bool aiMatrix4x4t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon) const {
nuclear@0 353 return
nuclear@0 354 std::abs(a1 - m.a1) <= epsilon &&
nuclear@0 355 std::abs(a2 - m.a2) <= epsilon &&
nuclear@0 356 std::abs(a3 - m.a3) <= epsilon &&
nuclear@0 357 std::abs(a4 - m.a4) <= epsilon &&
nuclear@0 358 std::abs(b1 - m.b1) <= epsilon &&
nuclear@0 359 std::abs(b2 - m.b2) <= epsilon &&
nuclear@0 360 std::abs(b3 - m.b3) <= epsilon &&
nuclear@0 361 std::abs(b4 - m.b4) <= epsilon &&
nuclear@0 362 std::abs(c1 - m.c1) <= epsilon &&
nuclear@0 363 std::abs(c2 - m.c2) <= epsilon &&
nuclear@0 364 std::abs(c3 - m.c3) <= epsilon &&
nuclear@0 365 std::abs(c4 - m.c4) <= epsilon &&
nuclear@0 366 std::abs(d1 - m.d1) <= epsilon &&
nuclear@0 367 std::abs(d2 - m.d2) <= epsilon &&
nuclear@0 368 std::abs(d3 - m.d3) <= epsilon &&
nuclear@0 369 std::abs(d4 - m.d4) <= epsilon;
nuclear@0 370 }
nuclear@0 371
nuclear@0 372 // ----------------------------------------------------------------------------------------
nuclear@0 373
nuclear@0 374 #define ASSIMP_MATRIX4_4_DECOMPOSE_PART \
nuclear@0 375 const aiMatrix4x4t<TReal>& _this = *this;/* Create alias for conveniance. */ \
nuclear@0 376 \
nuclear@0 377 /* extract translation */ \
nuclear@0 378 pPosition.x = _this[0][3]; \
nuclear@0 379 pPosition.y = _this[1][3]; \
nuclear@0 380 pPosition.z = _this[2][3]; \
nuclear@0 381 \
nuclear@0 382 /* extract the columns of the matrix. */ \
nuclear@0 383 aiVector3t<TReal> vCols[3] = { \
nuclear@0 384 aiVector3t<TReal>(_this[0][0],_this[1][0],_this[2][0]), \
nuclear@0 385 aiVector3t<TReal>(_this[0][1],_this[1][1],_this[2][1]), \
nuclear@0 386 aiVector3t<TReal>(_this[0][2],_this[1][2],_this[2][2]) \
nuclear@0 387 }; \
nuclear@0 388 \
nuclear@0 389 /* extract the scaling factors */ \
nuclear@0 390 pScaling.x = vCols[0].Length(); \
nuclear@0 391 pScaling.y = vCols[1].Length(); \
nuclear@0 392 pScaling.z = vCols[2].Length(); \
nuclear@0 393 \
nuclear@0 394 /* and the sign of the scaling */ \
nuclear@0 395 if (Determinant() < 0) pScaling = -pScaling; \
nuclear@0 396 \
nuclear@0 397 /* and remove all scaling from the matrix */ \
nuclear@0 398 if(pScaling.x) vCols[0] /= pScaling.x; \
nuclear@0 399 if(pScaling.y) vCols[1] /= pScaling.y; \
nuclear@0 400 if(pScaling.z) vCols[2] /= pScaling.z; \
nuclear@0 401 \
nuclear@0 402 do {} while(false)
nuclear@0 403
nuclear@0 404
nuclear@0 405
nuclear@0 406
nuclear@0 407 template <typename TReal>
nuclear@0 408 inline void aiMatrix4x4t<TReal>::Decompose (aiVector3t<TReal>& pScaling, aiQuaterniont<TReal>& pRotation,
nuclear@0 409 aiVector3t<TReal>& pPosition) const
nuclear@0 410 {
nuclear@0 411 ASSIMP_MATRIX4_4_DECOMPOSE_PART;
nuclear@0 412
nuclear@0 413 // build a 3x3 rotation matrix
nuclear@0 414 aiMatrix3x3t<TReal> m(vCols[0].x,vCols[1].x,vCols[2].x,
nuclear@0 415 vCols[0].y,vCols[1].y,vCols[2].y,
nuclear@0 416 vCols[0].z,vCols[1].z,vCols[2].z);
nuclear@0 417
nuclear@0 418 // and generate the rotation quaternion from it
nuclear@0 419 pRotation = aiQuaterniont<TReal>(m);
nuclear@0 420 }
nuclear@0 421
nuclear@0 422 template <typename TReal>
nuclear@0 423 inline void aiMatrix4x4t<TReal>::Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TReal>& pRotation, aiVector3t<TReal>& pPosition) const
nuclear@0 424 {
nuclear@0 425 ASSIMP_MATRIX4_4_DECOMPOSE_PART;
nuclear@0 426
nuclear@0 427 /*
nuclear@0 428 assuming a right-handed coordinate system
nuclear@0 429 and post-multiplication of column vectors,
nuclear@0 430 the rotation matrix for an euler XYZ rotation is M = Rz * Ry * Rx.
nuclear@0 431 combining gives:
nuclear@0 432
nuclear@0 433 | CE BDE-AF ADE+BF 0 |
nuclear@0 434 M = | CF BDF+AE ADF-BE 0 |
nuclear@0 435 | -D CB AC 0 |
nuclear@0 436 | 0 0 0 1 |
nuclear@0 437
nuclear@0 438 where
nuclear@0 439 A = cos(angle_x), B = sin(angle_x);
nuclear@0 440 C = cos(angle_y), D = sin(angle_y);
nuclear@0 441 E = cos(angle_z), F = sin(angle_z);
nuclear@0 442 */
nuclear@0 443
nuclear@0 444 // Use a small epsilon to solve floating-point inaccuracies
nuclear@0 445 const TReal epsilon = 10e-3f;
nuclear@0 446
nuclear@0 447 pRotation.y = std::asin(-vCols[0].z);// D. Angle around oY.
nuclear@0 448
nuclear@0 449 TReal C = std::cos(pRotation.y);
nuclear@0 450
nuclear@0 451 if(std::fabs(C) > epsilon)
nuclear@0 452 {
nuclear@0 453 // Finding angle around oX.
nuclear@0 454 TReal tan_x = vCols[2].z / C;// A
nuclear@0 455 TReal tan_y = vCols[1].z / C;// B
nuclear@0 456
nuclear@0 457 pRotation.x = std::atan2(tan_y, tan_x);
nuclear@0 458 // Finding angle around oZ.
nuclear@0 459 tan_x = vCols[0].x / C;// E
nuclear@0 460 tan_y = vCols[0].y / C;// F
nuclear@0 461 pRotation.z = std::atan2(tan_y, tan_x);
nuclear@0 462 }
nuclear@0 463 else
nuclear@0 464 {// oY is fixed.
nuclear@0 465 pRotation.x = 0;// Set angle around oX to 0. => A == 1, B == 0, C == 0, D == 1.
nuclear@0 466
nuclear@0 467 // And finding angle around oZ.
nuclear@0 468 TReal tan_x = vCols[1].y;// BDF+AE => E
nuclear@0 469 TReal tan_y = -vCols[1].x;// BDE-AF => F
nuclear@0 470
nuclear@0 471 pRotation.z = std::atan2(tan_y, tan_x);
nuclear@0 472 }
nuclear@0 473 }
nuclear@0 474
nuclear@0 475 #undef ASSIMP_MATRIX4_4_DECOMPOSE_PART
nuclear@0 476
nuclear@0 477 template <typename TReal>
nuclear@0 478 inline void aiMatrix4x4t<TReal>::Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TReal>& pRotationAxis, TReal& pRotationAngle,
nuclear@0 479 aiVector3t<TReal>& pPosition) const
nuclear@0 480 {
nuclear@0 481 aiQuaterniont<TReal> pRotation;
nuclear@0 482
nuclear@0 483 Decompose(pScaling, pRotation, pPosition);
nuclear@0 484 pRotation.Normalize();
nuclear@0 485
nuclear@0 486 TReal angle_cos = pRotation.w;
nuclear@0 487 TReal angle_sin = std::sqrt(1.0f - angle_cos * angle_cos);
nuclear@0 488
nuclear@0 489 pRotationAngle = std::acos(angle_cos) * 2;
nuclear@0 490
nuclear@0 491 // Use a small epsilon to solve floating-point inaccuracies
nuclear@0 492 const TReal epsilon = 10e-3f;
nuclear@0 493
nuclear@0 494 if(std::fabs(angle_sin) < epsilon) angle_sin = 1;
nuclear@0 495
nuclear@0 496 pRotationAxis.x = pRotation.x / angle_sin;
nuclear@0 497 pRotationAxis.y = pRotation.y / angle_sin;
nuclear@0 498 pRotationAxis.z = pRotation.z / angle_sin;
nuclear@0 499 }
nuclear@0 500
nuclear@0 501 // ----------------------------------------------------------------------------------------
nuclear@0 502 template <typename TReal>
nuclear@0 503 inline void aiMatrix4x4t<TReal>::DecomposeNoScaling (aiQuaterniont<TReal>& rotation,
nuclear@0 504 aiVector3t<TReal>& position) const
nuclear@0 505 {
nuclear@0 506 const aiMatrix4x4t<TReal>& _this = *this;
nuclear@0 507
nuclear@0 508 // extract translation
nuclear@0 509 position.x = _this[0][3];
nuclear@0 510 position.y = _this[1][3];
nuclear@0 511 position.z = _this[2][3];
nuclear@0 512
nuclear@0 513 // extract rotation
nuclear@0 514 rotation = aiQuaterniont<TReal>((aiMatrix3x3t<TReal>)_this);
nuclear@0 515 }
nuclear@0 516
nuclear@0 517 // ----------------------------------------------------------------------------------------
nuclear@0 518 template <typename TReal>
nuclear@0 519 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(const aiVector3t<TReal>& blubb)
nuclear@0 520 {
nuclear@0 521 return FromEulerAnglesXYZ(blubb.x,blubb.y,blubb.z);
nuclear@0 522 }
nuclear@0 523
nuclear@0 524 // ----------------------------------------------------------------------------------------
nuclear@0 525 template <typename TReal>
nuclear@0 526 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromEulerAnglesXYZ(TReal x, TReal y, TReal z)
nuclear@0 527 {
nuclear@0 528 aiMatrix4x4t<TReal>& _this = *this;
nuclear@0 529
nuclear@0 530 TReal cx = std::cos(x);
nuclear@0 531 TReal sx = std::sin(x);
nuclear@0 532 TReal cy = std::cos(y);
nuclear@0 533 TReal sy = std::sin(y);
nuclear@0 534 TReal cz = std::cos(z);
nuclear@0 535 TReal sz = std::sin(z);
nuclear@0 536
nuclear@0 537 // mz*my*mx
nuclear@0 538 _this.a1 = cz * cy;
nuclear@0 539 _this.a2 = cz * sy * sx - sz * cx;
nuclear@0 540 _this.a3 = sz * sx + cz * sy * cx;
nuclear@0 541
nuclear@0 542 _this.b1 = sz * cy;
nuclear@0 543 _this.b2 = cz * cx + sz * sy * sx;
nuclear@0 544 _this.b3 = sz * sy * cx - cz * sx;
nuclear@0 545
nuclear@0 546 _this.c1 = -sy;
nuclear@0 547 _this.c2 = cy * sx;
nuclear@0 548 _this.c3 = cy * cx;
nuclear@0 549
nuclear@0 550 return *this;
nuclear@0 551 }
nuclear@0 552
nuclear@0 553 // ----------------------------------------------------------------------------------------
nuclear@0 554 template <typename TReal>
nuclear@0 555 inline bool aiMatrix4x4t<TReal>::IsIdentity() const
nuclear@0 556 {
nuclear@0 557 // Use a small epsilon to solve floating-point inaccuracies
nuclear@0 558 const static TReal epsilon = 10e-3f;
nuclear@0 559
nuclear@0 560 return (a2 <= epsilon && a2 >= -epsilon &&
nuclear@0 561 a3 <= epsilon && a3 >= -epsilon &&
nuclear@0 562 a4 <= epsilon && a4 >= -epsilon &&
nuclear@0 563 b1 <= epsilon && b1 >= -epsilon &&
nuclear@0 564 b3 <= epsilon && b3 >= -epsilon &&
nuclear@0 565 b4 <= epsilon && b4 >= -epsilon &&
nuclear@0 566 c1 <= epsilon && c1 >= -epsilon &&
nuclear@0 567 c2 <= epsilon && c2 >= -epsilon &&
nuclear@0 568 c4 <= epsilon && c4 >= -epsilon &&
nuclear@0 569 d1 <= epsilon && d1 >= -epsilon &&
nuclear@0 570 d2 <= epsilon && d2 >= -epsilon &&
nuclear@0 571 d3 <= epsilon && d3 >= -epsilon &&
nuclear@0 572 a1 <= 1.f+epsilon && a1 >= 1.f-epsilon &&
nuclear@0 573 b2 <= 1.f+epsilon && b2 >= 1.f-epsilon &&
nuclear@0 574 c3 <= 1.f+epsilon && c3 >= 1.f-epsilon &&
nuclear@0 575 d4 <= 1.f+epsilon && d4 >= 1.f-epsilon);
nuclear@0 576 }
nuclear@0 577
nuclear@0 578 // ----------------------------------------------------------------------------------------
nuclear@0 579 template <typename TReal>
nuclear@0 580 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationX(TReal a, aiMatrix4x4t<TReal>& out)
nuclear@0 581 {
nuclear@0 582 /*
nuclear@0 583 | 1 0 0 0 |
nuclear@0 584 M = | 0 cos(A) -sin(A) 0 |
nuclear@0 585 | 0 sin(A) cos(A) 0 |
nuclear@0 586 | 0 0 0 1 | */
nuclear@0 587 out = aiMatrix4x4t<TReal>();
nuclear@0 588 out.b2 = out.c3 = std::cos(a);
nuclear@0 589 out.b3 = -(out.c2 = std::sin(a));
nuclear@0 590 return out;
nuclear@0 591 }
nuclear@0 592
nuclear@0 593 // ----------------------------------------------------------------------------------------
nuclear@0 594 template <typename TReal>
nuclear@0 595 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationY(TReal a, aiMatrix4x4t<TReal>& out)
nuclear@0 596 {
nuclear@0 597 /*
nuclear@0 598 | cos(A) 0 sin(A) 0 |
nuclear@0 599 M = | 0 1 0 0 |
nuclear@0 600 | -sin(A) 0 cos(A) 0 |
nuclear@0 601 | 0 0 0 1 |
nuclear@0 602 */
nuclear@0 603 out = aiMatrix4x4t<TReal>();
nuclear@0 604 out.a1 = out.c3 = std::cos(a);
nuclear@0 605 out.c1 = -(out.a3 = std::sin(a));
nuclear@0 606 return out;
nuclear@0 607 }
nuclear@0 608
nuclear@0 609 // ----------------------------------------------------------------------------------------
nuclear@0 610 template <typename TReal>
nuclear@0 611 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::RotationZ(TReal a, aiMatrix4x4t<TReal>& out)
nuclear@0 612 {
nuclear@0 613 /*
nuclear@0 614 | cos(A) -sin(A) 0 0 |
nuclear@0 615 M = | sin(A) cos(A) 0 0 |
nuclear@0 616 | 0 0 1 0 |
nuclear@0 617 | 0 0 0 1 | */
nuclear@0 618 out = aiMatrix4x4t<TReal>();
nuclear@0 619 out.a1 = out.b2 = std::cos(a);
nuclear@0 620 out.a2 = -(out.b1 = std::sin(a));
nuclear@0 621 return out;
nuclear@0 622 }
nuclear@0 623
nuclear@0 624 // ----------------------------------------------------------------------------------------
nuclear@0 625 // Returns a rotation matrix for a rotation around an arbitrary axis.
nuclear@0 626 template <typename TReal>
nuclear@0 627 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Rotation( TReal a, const aiVector3t<TReal>& axis, aiMatrix4x4t<TReal>& out)
nuclear@0 628 {
nuclear@0 629 TReal c = std::cos( a), s = std::sin( a), t = 1 - c;
nuclear@0 630 TReal x = axis.x, y = axis.y, z = axis.z;
nuclear@0 631
nuclear@0 632 // Many thanks to MathWorld and Wikipedia
nuclear@0 633 out.a1 = t*x*x + c; out.a2 = t*x*y - s*z; out.a3 = t*x*z + s*y;
nuclear@0 634 out.b1 = t*x*y + s*z; out.b2 = t*y*y + c; out.b3 = t*y*z - s*x;
nuclear@0 635 out.c1 = t*x*z - s*y; out.c2 = t*y*z + s*x; out.c3 = t*z*z + c;
nuclear@0 636 out.a4 = out.b4 = out.c4 = static_cast<TReal>(0.0);
nuclear@0 637 out.d1 = out.d2 = out.d3 = static_cast<TReal>(0.0);
nuclear@0 638 out.d4 = static_cast<TReal>(1.0);
nuclear@0 639
nuclear@0 640 return out;
nuclear@0 641 }
nuclear@0 642
nuclear@0 643 // ----------------------------------------------------------------------------------------
nuclear@0 644 template <typename TReal>
nuclear@0 645 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Translation( const aiVector3t<TReal>& v, aiMatrix4x4t<TReal>& out)
nuclear@0 646 {
nuclear@0 647 out = aiMatrix4x4t<TReal>();
nuclear@0 648 out.a4 = v.x;
nuclear@0 649 out.b4 = v.y;
nuclear@0 650 out.c4 = v.z;
nuclear@0 651 return out;
nuclear@0 652 }
nuclear@0 653
nuclear@0 654 // ----------------------------------------------------------------------------------------
nuclear@0 655 template <typename TReal>
nuclear@0 656 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::Scaling( const aiVector3t<TReal>& v, aiMatrix4x4t<TReal>& out)
nuclear@0 657 {
nuclear@0 658 out = aiMatrix4x4t<TReal>();
nuclear@0 659 out.a1 = v.x;
nuclear@0 660 out.b2 = v.y;
nuclear@0 661 out.c3 = v.z;
nuclear@0 662 return out;
nuclear@0 663 }
nuclear@0 664
nuclear@0 665 // ----------------------------------------------------------------------------------------
nuclear@0 666 /** A function for creating a rotation matrix that rotates a vector called
nuclear@0 667 * "from" into another vector called "to".
nuclear@0 668 * Input : from[3], to[3] which both must be *normalized* non-zero vectors
nuclear@0 669 * Output: mtx[3][3] -- a 3x3 matrix in colum-major form
nuclear@0 670 * Authors: Tomas Möller, John Hughes
nuclear@0 671 * "Efficiently Building a Matrix to Rotate One Vector to Another"
nuclear@0 672 * Journal of Graphics Tools, 4(4):1-4, 1999
nuclear@0 673 */
nuclear@0 674 // ----------------------------------------------------------------------------------------
nuclear@0 675 template <typename TReal>
nuclear@0 676 inline aiMatrix4x4t<TReal>& aiMatrix4x4t<TReal>::FromToMatrix(const aiVector3t<TReal>& from,
nuclear@0 677 const aiVector3t<TReal>& to, aiMatrix4x4t<TReal>& mtx)
nuclear@0 678 {
nuclear@0 679 aiMatrix3x3t<TReal> m3;
nuclear@0 680 aiMatrix3x3t<TReal>::FromToMatrix(from,to,m3);
nuclear@0 681 mtx = aiMatrix4x4t<TReal>(m3);
nuclear@0 682 return mtx;
nuclear@0 683 }
nuclear@0 684
nuclear@0 685 #endif // __cplusplus
nuclear@0 686 #endif // AI_MATRIX4X4_INL_INC