miniassimp

annotate include/miniassimp/matrix4x4.h @ 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 /** @file matrix4x4.h
nuclear@0 44 * @brief 4x4 matrix structure, including operators when compiling in C++
nuclear@0 45 */
nuclear@0 46 #pragma once
nuclear@0 47 #ifndef AI_MATRIX4X4_H_INC
nuclear@0 48 #define AI_MATRIX4X4_H_INC
nuclear@0 49
nuclear@0 50 #include "vector3.h"
nuclear@0 51 #include "defs.h"
nuclear@0 52
nuclear@0 53 #ifdef __cplusplus
nuclear@0 54
nuclear@0 55 template<typename TReal> class aiMatrix3x3t;
nuclear@0 56 template<typename TReal> class aiQuaterniont;
nuclear@0 57
nuclear@0 58 // ---------------------------------------------------------------------------
nuclear@0 59 /** @brief Represents a row-major 4x4 matrix, use this for homogeneous
nuclear@0 60 * coordinates.
nuclear@0 61 *
nuclear@0 62 * There's much confusion about matrix layouts (column vs. row order).
nuclear@0 63 * This is *always* a row-major matrix. Not even with the
nuclear@0 64 * #aiProcess_ConvertToLeftHanded flag, which absolutely does not affect
nuclear@0 65 * matrix order - it just affects the handedness of the coordinate system
nuclear@0 66 * defined thereby.
nuclear@0 67 */
nuclear@0 68 template<typename TReal>
nuclear@0 69 class aiMatrix4x4t
nuclear@0 70 {
nuclear@0 71 public:
nuclear@0 72
nuclear@0 73 /** set to identity */
nuclear@0 74 aiMatrix4x4t() AI_NO_EXCEPT;
nuclear@0 75
nuclear@0 76 /** construction from single values */
nuclear@0 77 aiMatrix4x4t ( TReal _a1, TReal _a2, TReal _a3, TReal _a4,
nuclear@0 78 TReal _b1, TReal _b2, TReal _b3, TReal _b4,
nuclear@0 79 TReal _c1, TReal _c2, TReal _c3, TReal _c4,
nuclear@0 80 TReal _d1, TReal _d2, TReal _d3, TReal _d4);
nuclear@0 81
nuclear@0 82
nuclear@0 83 /** construction from 3x3 matrix, remaining elements are set to identity */
nuclear@0 84 explicit aiMatrix4x4t( const aiMatrix3x3t<TReal>& m);
nuclear@0 85
nuclear@0 86 /** construction from position, rotation and scaling components
nuclear@0 87 * @param scaling The scaling for the x,y,z axes
nuclear@0 88 * @param rotation The rotation as a hamilton quaternion
nuclear@0 89 * @param position The position for the x,y,z axes
nuclear@0 90 */
nuclear@0 91 aiMatrix4x4t(const aiVector3t<TReal>& scaling, const aiQuaterniont<TReal>& rotation,
nuclear@0 92 const aiVector3t<TReal>& position);
nuclear@0 93
nuclear@0 94 public:
nuclear@0 95
nuclear@0 96 // array access operators
nuclear@0 97 /** @fn TReal* operator[] (unsigned int p_iIndex)
nuclear@0 98 * @param [in] p_iIndex - index of the row.
nuclear@0 99 * @return pointer to pointed row.
nuclear@0 100 */
nuclear@0 101 TReal* operator[] (unsigned int p_iIndex);
nuclear@0 102
nuclear@0 103 /** @fn const TReal* operator[] (unsigned int p_iIndex) const
nuclear@0 104 * @overload TReal* operator[] (unsigned int p_iIndex)
nuclear@0 105 */
nuclear@0 106 const TReal* operator[] (unsigned int p_iIndex) const;
nuclear@0 107
nuclear@0 108 // comparison operators
nuclear@0 109 bool operator== (const aiMatrix4x4t& m) const;
nuclear@0 110 bool operator!= (const aiMatrix4x4t& m) const;
nuclear@0 111
nuclear@0 112 bool Equal(const aiMatrix4x4t& m, TReal epsilon = 1e-6) const;
nuclear@0 113
nuclear@0 114 // matrix multiplication.
nuclear@0 115 aiMatrix4x4t& operator *= (const aiMatrix4x4t& m);
nuclear@0 116 aiMatrix4x4t operator * (const aiMatrix4x4t& m) const;
nuclear@0 117 aiMatrix4x4t operator * (const TReal& aFloat) const;
nuclear@0 118 aiMatrix4x4t operator + (const aiMatrix4x4t& aMatrix) const;
nuclear@0 119
nuclear@0 120 template <typename TOther>
nuclear@0 121 operator aiMatrix4x4t<TOther> () const;
nuclear@0 122
nuclear@0 123 public:
nuclear@0 124
nuclear@0 125 // -------------------------------------------------------------------
nuclear@0 126 /** @brief Transpose the matrix */
nuclear@0 127 aiMatrix4x4t& Transpose();
nuclear@0 128
nuclear@0 129 // -------------------------------------------------------------------
nuclear@0 130 /** @brief Invert the matrix.
nuclear@0 131 * If the matrix is not invertible all elements are set to qnan.
nuclear@0 132 * Beware, use (f != f) to check whether a TReal f is qnan.
nuclear@0 133 */
nuclear@0 134 aiMatrix4x4t& Inverse();
nuclear@0 135 TReal Determinant() const;
nuclear@0 136
nuclear@0 137
nuclear@0 138 // -------------------------------------------------------------------
nuclear@0 139 /** @brief Returns true of the matrix is the identity matrix.
nuclear@0 140 * The check is performed against a not so small epsilon.
nuclear@0 141 */
nuclear@0 142 inline bool IsIdentity() const;
nuclear@0 143
nuclear@0 144 // -------------------------------------------------------------------
nuclear@0 145 /** @brief Decompose a trafo matrix into its original components
nuclear@0 146 * @param scaling Receives the output scaling for the x,y,z axes
nuclear@0 147 * @param rotation Receives the output rotation as a hamilton
nuclear@0 148 * quaternion
nuclear@0 149 * @param position Receives the output position for the x,y,z axes
nuclear@0 150 */
nuclear@0 151 void Decompose (aiVector3t<TReal>& scaling, aiQuaterniont<TReal>& rotation,
nuclear@0 152 aiVector3t<TReal>& position) const;
nuclear@0 153
nuclear@0 154 // -------------------------------------------------------------------
nuclear@0 155 /** @fn void Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TReal>& pRotation, aiVector3t<TReal>& pPosition) const
nuclear@0 156 * @brief Decompose a trafo matrix into its original components.
nuclear@0 157 * Thx to good FAQ at http://www.gamedev.ru/code/articles/faq_matrix_quat
nuclear@0 158 * @param [out] pScaling - Receives the output scaling for the x,y,z axes.
nuclear@0 159 * @param [out] pRotation - Receives the output rotation as a Euler angles.
nuclear@0 160 * @param [out] pPosition - Receives the output position for the x,y,z axes.
nuclear@0 161 */
nuclear@0 162 void Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TReal>& pRotation, aiVector3t<TReal>& pPosition) const;
nuclear@0 163
nuclear@0 164 // -------------------------------------------------------------------
nuclear@0 165 /** @fn void Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TReal>& pRotationAxis, TReal& pRotationAngle, aiVector3t<TReal>& pPosition) const
nuclear@0 166 * @brief Decompose a trafo matrix into its original components
nuclear@0 167 * Thx to good FAQ at http://www.gamedev.ru/code/articles/faq_matrix_quat
nuclear@0 168 * @param [out] pScaling - Receives the output scaling for the x,y,z axes.
nuclear@0 169 * @param [out] pRotationAxis - Receives the output rotation axis.
nuclear@0 170 * @param [out] pRotationAngle - Receives the output rotation angle for @ref pRotationAxis.
nuclear@0 171 * @param [out] pPosition - Receives the output position for the x,y,z axes.
nuclear@0 172 */
nuclear@0 173 void Decompose(aiVector3t<TReal>& pScaling, aiVector3t<TReal>& pRotationAxis, TReal& pRotationAngle, aiVector3t<TReal>& pPosition) const;
nuclear@0 174
nuclear@0 175 // -------------------------------------------------------------------
nuclear@0 176 /** @brief Decompose a trafo matrix with no scaling into its
nuclear@0 177 * original components
nuclear@0 178 * @param rotation Receives the output rotation as a hamilton
nuclear@0 179 * quaternion
nuclear@0 180 * @param position Receives the output position for the x,y,z axes
nuclear@0 181 */
nuclear@0 182 void DecomposeNoScaling (aiQuaterniont<TReal>& rotation,
nuclear@0 183 aiVector3t<TReal>& position) const;
nuclear@0 184
nuclear@0 185
nuclear@0 186 // -------------------------------------------------------------------
nuclear@0 187 /** @brief Creates a trafo matrix from a set of euler angles
nuclear@0 188 * @param x Rotation angle for the x-axis, in radians
nuclear@0 189 * @param y Rotation angle for the y-axis, in radians
nuclear@0 190 * @param z Rotation angle for the z-axis, in radians
nuclear@0 191 */
nuclear@0 192 aiMatrix4x4t& FromEulerAnglesXYZ(TReal x, TReal y, TReal z);
nuclear@0 193 aiMatrix4x4t& FromEulerAnglesXYZ(const aiVector3t<TReal>& blubb);
nuclear@0 194
nuclear@0 195 public:
nuclear@0 196 // -------------------------------------------------------------------
nuclear@0 197 /** @brief Returns a rotation matrix for a rotation around the x axis
nuclear@0 198 * @param a Rotation angle, in radians
nuclear@0 199 * @param out Receives the output matrix
nuclear@0 200 * @return Reference to the output matrix
nuclear@0 201 */
nuclear@0 202 static aiMatrix4x4t& RotationX(TReal a, aiMatrix4x4t& out);
nuclear@0 203
nuclear@0 204 // -------------------------------------------------------------------
nuclear@0 205 /** @brief Returns a rotation matrix for a rotation around the y axis
nuclear@0 206 * @param a Rotation angle, in radians
nuclear@0 207 * @param out Receives the output matrix
nuclear@0 208 * @return Reference to the output matrix
nuclear@0 209 */
nuclear@0 210 static aiMatrix4x4t& RotationY(TReal a, aiMatrix4x4t& out);
nuclear@0 211
nuclear@0 212 // -------------------------------------------------------------------
nuclear@0 213 /** @brief Returns a rotation matrix for a rotation around the z axis
nuclear@0 214 * @param a Rotation angle, in radians
nuclear@0 215 * @param out Receives the output matrix
nuclear@0 216 * @return Reference to the output matrix
nuclear@0 217 */
nuclear@0 218 static aiMatrix4x4t& RotationZ(TReal a, aiMatrix4x4t& out);
nuclear@0 219
nuclear@0 220 // -------------------------------------------------------------------
nuclear@0 221 /** Returns a rotation matrix for a rotation around an arbitrary axis.
nuclear@0 222 * @param a Rotation angle, in radians
nuclear@0 223 * @param axis Rotation axis, should be a normalized vector.
nuclear@0 224 * @param out Receives the output matrix
nuclear@0 225 * @return Reference to the output matrix
nuclear@0 226 */
nuclear@0 227 static aiMatrix4x4t& Rotation(TReal a, const aiVector3t<TReal>& axis,
nuclear@0 228 aiMatrix4x4t& out);
nuclear@0 229
nuclear@0 230 // -------------------------------------------------------------------
nuclear@0 231 /** @brief Returns a translation matrix
nuclear@0 232 * @param v Translation vector
nuclear@0 233 * @param out Receives the output matrix
nuclear@0 234 * @return Reference to the output matrix
nuclear@0 235 */
nuclear@0 236 static aiMatrix4x4t& Translation( const aiVector3t<TReal>& v,
nuclear@0 237 aiMatrix4x4t& out);
nuclear@0 238
nuclear@0 239 // -------------------------------------------------------------------
nuclear@0 240 /** @brief Returns a scaling matrix
nuclear@0 241 * @param v Scaling vector
nuclear@0 242 * @param out Receives the output matrix
nuclear@0 243 * @return Reference to the output matrix
nuclear@0 244 */
nuclear@0 245 static aiMatrix4x4t& Scaling( const aiVector3t<TReal>& v, aiMatrix4x4t& out);
nuclear@0 246
nuclear@0 247 // -------------------------------------------------------------------
nuclear@0 248 /** @brief A function for creating a rotation matrix that rotates a
nuclear@0 249 * vector called "from" into another vector called "to".
nuclear@0 250 * Input : from[3], to[3] which both must be *normalized* non-zero vectors
nuclear@0 251 * Output: mtx[3][3] -- a 3x3 matrix in column-major form
nuclear@0 252 * Authors: Tomas Mueller, John Hughes
nuclear@0 253 * "Efficiently Building a Matrix to Rotate One Vector to Another"
nuclear@0 254 * Journal of Graphics Tools, 4(4):1-4, 1999
nuclear@0 255 */
nuclear@0 256 static aiMatrix4x4t& FromToMatrix(const aiVector3t<TReal>& from,
nuclear@0 257 const aiVector3t<TReal>& to, aiMatrix4x4t& out);
nuclear@0 258
nuclear@0 259 public:
nuclear@0 260 TReal a1, a2, a3, a4;
nuclear@0 261 TReal b1, b2, b3, b4;
nuclear@0 262 TReal c1, c2, c3, c4;
nuclear@0 263 TReal d1, d2, d3, d4;
nuclear@0 264 };
nuclear@0 265
nuclear@0 266 typedef aiMatrix4x4t<ai_real> aiMatrix4x4;
nuclear@0 267
nuclear@0 268 #else
nuclear@0 269
nuclear@0 270 struct aiMatrix4x4 {
nuclear@0 271 ai_real a1, a2, a3, a4;
nuclear@0 272 ai_real b1, b2, b3, b4;
nuclear@0 273 ai_real c1, c2, c3, c4;
nuclear@0 274 ai_real d1, d2, d3, d4;
nuclear@0 275 };
nuclear@0 276
nuclear@0 277
nuclear@0 278 #endif // __cplusplus
nuclear@0 279
nuclear@0 280 #endif // AI_MATRIX4X4_H_INC