NVIDIA(R) PhysX(R) SDK 3.4 API Reference: PxMat44.h Source File

NVIDIA PhysX SDK 3.4 API

PxMat44.h

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2017 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029 
00030 #ifndef PXFOUNDATION_PXMAT44_H
00031 #define PXFOUNDATION_PXMAT44_H
00032 
00036 #include "foundation/PxQuat.h"
00037 #include "foundation/PxVec4.h"
00038 #include "foundation/PxMat33.h"
00039 #include "foundation/PxTransform.h"
00040 
00041 #if !PX_DOXYGEN
00042 namespace physx
00043 {
00044 #endif
00045 
00054 class PxMat44
00055 {
00056   public:
00058     PX_CUDA_CALLABLE PX_INLINE PxMat44()
00059     {
00060     }
00061 
00063     PX_CUDA_CALLABLE PX_INLINE PxMat44(PxIDENTITY r)
00064     : column0(1.0f, 0.0f, 0.0f, 0.0f)
00065     , column1(0.0f, 1.0f, 0.0f, 0.0f)
00066     , column2(0.0f, 0.0f, 1.0f, 0.0f)
00067     , column3(0.0f, 0.0f, 0.0f, 1.0f)
00068     {
00069         PX_UNUSED(r);
00070     }
00071 
00073     PX_CUDA_CALLABLE PX_INLINE PxMat44(PxZERO r) : column0(PxZero), column1(PxZero), column2(PxZero), column3(PxZero)
00074     {
00075         PX_UNUSED(r);
00076     }
00077 
00079     PX_CUDA_CALLABLE PxMat44(const PxVec4& col0, const PxVec4& col1, const PxVec4& col2, const PxVec4& col3)
00080     : column0(col0), column1(col1), column2(col2), column3(col3)
00081     {
00082     }
00083 
00085     explicit PX_CUDA_CALLABLE PX_INLINE PxMat44(float r)
00086     : column0(r, 0.0f, 0.0f, 0.0f)
00087     , column1(0.0f, r, 0.0f, 0.0f)
00088     , column2(0.0f, 0.0f, r, 0.0f)
00089     , column3(0.0f, 0.0f, 0.0f, r)
00090     {
00091     }
00092 
00094     PX_CUDA_CALLABLE PxMat44(const PxVec3& col0, const PxVec3& col1, const PxVec3& col2, const PxVec3& col3)
00095     : column0(col0, 0), column1(col1, 0), column2(col2, 0), column3(col3, 1.0f)
00096     {
00097     }
00098 
00100     explicit PX_CUDA_CALLABLE PX_INLINE PxMat44(float values[])
00101     : column0(values[0], values[1], values[2], values[3])
00102     , column1(values[4], values[5], values[6], values[7])
00103     , column2(values[8], values[9], values[10], values[11])
00104     , column3(values[12], values[13], values[14], values[15])
00105     {
00106     }
00107 
00109     explicit PX_CUDA_CALLABLE PX_INLINE PxMat44(const PxQuat& q)
00110     {
00111         const float x = q.x;
00112         const float y = q.y;
00113         const float z = q.z;
00114         const float w = q.w;
00115 
00116         const float x2 = x + x;
00117         const float y2 = y + y;
00118         const float z2 = z + z;
00119 
00120         const float xx = x2 * x;
00121         const float yy = y2 * y;
00122         const float zz = z2 * z;
00123 
00124         const float xy = x2 * y;
00125         const float xz = x2 * z;
00126         const float xw = x2 * w;
00127 
00128         const float yz = y2 * z;
00129         const float yw = y2 * w;
00130         const float zw = z2 * w;
00131 
00132         column0 = PxVec4(1.0f - yy - zz, xy + zw, xz - yw, 0.0f);
00133         column1 = PxVec4(xy - zw, 1.0f - xx - zz, yz + xw, 0.0f);
00134         column2 = PxVec4(xz + yw, yz - xw, 1.0f - xx - yy, 0.0f);
00135         column3 = PxVec4(0.0f, 0.0f, 0.0f, 1.0f);
00136     }
00137 
00139     explicit PX_CUDA_CALLABLE PX_INLINE PxMat44(const PxVec4& diagonal)
00140     : column0(diagonal.x, 0.0f, 0.0f, 0.0f)
00141     , column1(0.0f, diagonal.y, 0.0f, 0.0f)
00142     , column2(0.0f, 0.0f, diagonal.z, 0.0f)
00143     , column3(0.0f, 0.0f, 0.0f, diagonal.w)
00144     {
00145     }
00146 
00148     PX_CUDA_CALLABLE PxMat44(const PxMat33& axes, const PxVec3& position)
00149     : column0(axes.column0, 0.0f), column1(axes.column1, 0.0f), column2(axes.column2, 0.0f), column3(position, 1.0f)
00150     {
00151     }
00152 
00153     PX_CUDA_CALLABLE PxMat44(const PxTransform& t)
00154     {
00155         *this = PxMat44(PxMat33(t.q), t.p);
00156     }
00157 
00161     PX_CUDA_CALLABLE PX_INLINE bool operator==(const PxMat44& m) const
00162     {
00163         return column0 == m.column0 && column1 == m.column1 && column2 == m.column2 && column3 == m.column3;
00164     }
00165 
00167     PX_CUDA_CALLABLE PX_INLINE PxMat44(const PxMat44& other)
00168     : column0(other.column0), column1(other.column1), column2(other.column2), column3(other.column3)
00169     {
00170     }
00171 
00173     PX_CUDA_CALLABLE PX_INLINE PxMat44& operator=(const PxMat44& other)
00174     {
00175         column0 = other.column0;
00176         column1 = other.column1;
00177         column2 = other.column2;
00178         column3 = other.column3;
00179         return *this;
00180     }
00181 
00183     PX_CUDA_CALLABLE PX_INLINE const PxMat44 getTranspose() const
00184     {
00185         return PxMat44(
00186             PxVec4(column0.x, column1.x, column2.x, column3.x), PxVec4(column0.y, column1.y, column2.y, column3.y),
00187             PxVec4(column0.z, column1.z, column2.z, column3.z), PxVec4(column0.w, column1.w, column2.w, column3.w));
00188     }
00189 
00191     PX_CUDA_CALLABLE PX_INLINE const PxMat44 operator-() const
00192     {
00193         return PxMat44(-column0, -column1, -column2, -column3);
00194     }
00195 
00197     PX_CUDA_CALLABLE PX_INLINE const PxMat44 operator+(const PxMat44& other) const
00198     {
00199         return PxMat44(column0 + other.column0, column1 + other.column1, column2 + other.column2,
00200                        column3 + other.column3);
00201     }
00202 
00204     PX_CUDA_CALLABLE PX_INLINE const PxMat44 operator-(const PxMat44& other) const
00205     {
00206         return PxMat44(column0 - other.column0, column1 - other.column1, column2 - other.column2,
00207                        column3 - other.column3);
00208     }
00209 
00211     PX_CUDA_CALLABLE PX_INLINE const PxMat44 operator*(float scalar) const
00212     {
00213         return PxMat44(column0 * scalar, column1 * scalar, column2 * scalar, column3 * scalar);
00214     }
00215 
00216     friend PxMat44 operator*(float, const PxMat44&);
00217 
00219     PX_CUDA_CALLABLE PX_INLINE const PxMat44 operator*(const PxMat44& other) const
00220     {
00221         // Rows from this <dot> columns from other
00222         // column0 = transform(other.column0) etc
00223         return PxMat44(transform(other.column0), transform(other.column1), transform(other.column2),
00224                        transform(other.column3));
00225     }
00226 
00227     // a <op>= b operators
00228 
00230     PX_CUDA_CALLABLE PX_INLINE PxMat44& operator+=(const PxMat44& other)
00231     {
00232         column0 += other.column0;
00233         column1 += other.column1;
00234         column2 += other.column2;
00235         column3 += other.column3;
00236         return *this;
00237     }
00238 
00240     PX_CUDA_CALLABLE PX_INLINE PxMat44& operator-=(const PxMat44& other)
00241     {
00242         column0 -= other.column0;
00243         column1 -= other.column1;
00244         column2 -= other.column2;
00245         column3 -= other.column3;
00246         return *this;
00247     }
00248 
00250     PX_CUDA_CALLABLE PX_INLINE PxMat44& operator*=(float scalar)
00251     {
00252         column0 *= scalar;
00253         column1 *= scalar;
00254         column2 *= scalar;
00255         column3 *= scalar;
00256         return *this;
00257     }
00258 
00260     PX_CUDA_CALLABLE PX_INLINE PxMat44& operator*=(const PxMat44& other)
00261     {
00262         *this = *this * other;
00263         return *this;
00264     }
00265 
00267     PX_DEPRECATED PX_CUDA_CALLABLE PX_FORCE_INLINE float operator()(unsigned int row, unsigned int col) const
00268     {
00269         return (*this)[col][row];
00270     }
00271 
00273     PX_DEPRECATED PX_CUDA_CALLABLE PX_FORCE_INLINE float& operator()(unsigned int row, unsigned int col)
00274     {
00275         return (*this)[col][row];
00276     }
00277 
00279     PX_CUDA_CALLABLE PX_INLINE const PxVec4 transform(const PxVec4& other) const
00280     {
00281         return column0 * other.x + column1 * other.y + column2 * other.z + column3 * other.w;
00282     }
00283 
00285     PX_CUDA_CALLABLE PX_INLINE const PxVec3 transform(const PxVec3& other) const
00286     {
00287         return transform(PxVec4(other, 1.0f)).getXYZ();
00288     }
00289 
00291     PX_CUDA_CALLABLE PX_INLINE const PxVec4 rotate(const PxVec4& other) const
00292     {
00293         return column0 * other.x + column1 * other.y + column2 * other.z; // + column3*0;
00294     }
00295 
00297     PX_CUDA_CALLABLE PX_INLINE const PxVec3 rotate(const PxVec3& other) const
00298     {
00299         return rotate(PxVec4(other, 1.0f)).getXYZ();
00300     }
00301 
00302     PX_CUDA_CALLABLE PX_INLINE const PxVec3 getBasis(int num) const
00303     {
00304         PX_ASSERT(num >= 0 && num < 3);
00305         return (&column0)[num].getXYZ();
00306     }
00307 
00308     PX_CUDA_CALLABLE PX_INLINE const PxVec3 getPosition() const
00309     {
00310         return column3.getXYZ();
00311     }
00312 
00313     PX_CUDA_CALLABLE PX_INLINE void setPosition(const PxVec3& position)
00314     {
00315         column3.x = position.x;
00316         column3.y = position.y;
00317         column3.z = position.z;
00318     }
00319 
00320     PX_CUDA_CALLABLE PX_FORCE_INLINE const float* front() const
00321     {
00322         return &column0.x;
00323     }
00324 
00325     PX_DEPRECATED PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec4& operator[](unsigned int num)
00326     {
00327         return (&column0)[num];
00328     }
00329     PX_DEPRECATED PX_CUDA_CALLABLE PX_FORCE_INLINE const PxVec4& operator[](unsigned int num) const
00330     {
00331         return (&column0)[num];
00332     }
00333 
00334     PX_CUDA_CALLABLE PX_INLINE void scale(const PxVec4& p)
00335     {
00336         column0 *= p.x;
00337         column1 *= p.y;
00338         column2 *= p.z;
00339         column3 *= p.w;
00340     }
00341 
00342     PX_CUDA_CALLABLE PX_INLINE const PxMat44 inverseRT(void) const
00343     {
00344         PxVec3 r0(column0.x, column1.x, column2.x), r1(column0.y, column1.y, column2.y),
00345             r2(column0.z, column1.z, column2.z);
00346 
00347         return PxMat44(r0, r1, r2, -(r0 * column3.x + r1 * column3.y + r2 * column3.z));
00348     }
00349 
00350     PX_CUDA_CALLABLE PX_INLINE bool isFinite() const
00351     {
00352         return column0.isFinite() && column1.isFinite() && column2.isFinite() && column3.isFinite();
00353     }
00354 
00355     // Data, see above for format!
00356 
00357     PxVec4 column0, column1, column2, column3; // the four base vectors
00358 };
00359 
00360 // implementation from PxTransform.h
00361 PX_CUDA_CALLABLE PX_FORCE_INLINE PxTransform::PxTransform(const PxMat44& m)
00362 {
00363     PxVec3 column0 = PxVec3(m.column0.x, m.column0.y, m.column0.z);
00364     PxVec3 column1 = PxVec3(m.column1.x, m.column1.y, m.column1.z);
00365     PxVec3 column2 = PxVec3(m.column2.x, m.column2.y, m.column2.z);
00366 
00367     q = PxQuat(PxMat33(column0, column1, column2));
00368     p = PxVec3(m.column3.x, m.column3.y, m.column3.z);
00369 }
00370 
00371 #if !PX_DOXYGEN
00372 } // namespace physx
00373 #endif
00374 
00376 #endif // #ifndef PXFOUNDATION_PXMAT44_H


Copyright © 2008-2017 NVIDIA Corporation, 2701 San Tomas Expressway, Santa Clara, CA 95050 U.S.A. All rights reserved. www.nvidia.com