dali-physics/third-party/bullet3/src/LinearMath/btQuadWord.h

   1 /*
   2 Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans  https://bulletphysics.org
   3
   4 This software is provided 'as-is', without any express or implied warranty.
   5 In no event will the authors be held liable for any damages arising from the use of this software.
   6 Permission is granted to anyone to use this software for any purpose,
   7 including commercial applications, and to alter it and redistribute it freely,
   8 subject to the following restrictions:
   9
  10 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
  11 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
  12 3. This notice may not be removed or altered from any source distribution.
  13 */
  14
  15 #ifndef BT_SIMD_QUADWORD_H
  16 #define BT_SIMD_QUADWORD_H
  17
  18 #include "btScalar.h"
  19 #include "btMinMax.h"
  20
  21 #if defined(__CELLOS_LV2) && defined(__SPU__)
  22 #include <altivec.h>
  23 #endif
  24
  25 /**@brief The btQuadWord class is base class for btVector3 and btQuaternion.
  26  * Some issues under PS3 Linux with IBM 2.1 SDK, gcc compiler prevent from using aligned quadword.
  27  */
  28 #ifndef USE_LIBSPE2
  29 ATTRIBUTE_ALIGNED16(class)
  30 btQuadWord
  31 #else
  32 class btQuadWord
  33 #endif
  34 {
  35 protected:
  36 #if defined(__SPU__) && defined(__CELLOS_LV2__)
  37         union {
  38                 vec_float4 mVec128;
  39                 btScalar m_floats[4];
  40         };
  41
  42 public:
  43         vec_float4 get128() const
  44         {
  45                 return mVec128;
  46         }
  47
  48 protected:
  49 #else  //__CELLOS_LV2__ __SPU__
  50
  51 #if defined(BT_USE_SSE) || defined(BT_USE_NEON)
  52         union {
  53                 btSimdFloat4 mVec128;
  54                 btScalar m_floats[4];
  55         };
  56
  57 public:
  58         SIMD_FORCE_INLINE btSimdFloat4 get128() const
  59         {
  60                 return mVec128;
  61         }
  62         SIMD_FORCE_INLINE void set128(btSimdFloat4 v128)
  63         {
  64                 mVec128 = v128;
  65         }
  66 #else
  67         btScalar m_floats[4];
  68 #endif  // BT_USE_SSE
  69
  70 #endif  //__CELLOS_LV2__ __SPU__
  71
  72 public:
  73 #if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON)
  74
  75         // Set Vector
  76         SIMD_FORCE_INLINE btQuadWord(const btSimdFloat4 vec)
  77         {
  78                 mVec128 = vec;
  79         }
  80
  81         // Copy constructor
  82         SIMD_FORCE_INLINE btQuadWord(const btQuadWord& rhs)
  83         {
  84                 mVec128 = rhs.mVec128;
  85         }
  86
  87         // Assignment Operator
  88         SIMD_FORCE_INLINE btQuadWord&
  89         operator=(const btQuadWord& v)
  90         {
  91                 mVec128 = v.mVec128;
  92
  93                 return *this;
  94         }
  95
  96 #endif
  97
  98         /**@brief Return the x value */
  99         SIMD_FORCE_INLINE const btScalar& getX() const { return m_floats[0]; }
 100         /**@brief Return the y value */
 101         SIMD_FORCE_INLINE const btScalar& getY() const { return m_floats[1]; }
 102         /**@brief Return the z value */
 103         SIMD_FORCE_INLINE const btScalar& getZ() const { return m_floats[2]; }
 104         /**@brief Set the x value */
 105         SIMD_FORCE_INLINE void setX(btScalar _x) { m_floats[0] = _x; };
 106         /**@brief Set the y value */
 107         SIMD_FORCE_INLINE void setY(btScalar _y) { m_floats[1] = _y; };
 108         /**@brief Set the z value */
 109         SIMD_FORCE_INLINE void setZ(btScalar _z) { m_floats[2] = _z; };
 110         /**@brief Set the w value */
 111         SIMD_FORCE_INLINE void setW(btScalar _w) { m_floats[3] = _w; };
 112         /**@brief Return the x value */
 113         SIMD_FORCE_INLINE const btScalar& x() const { return m_floats[0]; }
 114         /**@brief Return the y value */
 115         SIMD_FORCE_INLINE const btScalar& y() const { return m_floats[1]; }
 116         /**@brief Return the z value */
 117         SIMD_FORCE_INLINE const btScalar& z() const { return m_floats[2]; }
 118         /**@brief Return the w value */
 119         SIMD_FORCE_INLINE const btScalar& w() const { return m_floats[3]; }
 120
 121         //SIMD_FORCE_INLINE btScalar&       operator[](int i)       { return (&m_floats[0])[i]; }
 122         //SIMD_FORCE_INLINE const btScalar& operator[](int i) const { return (&m_floats[0])[i]; }
 123         ///operator btScalar*() replaces operator[], using implicit conversion. We added operator != and operator == to avoid pointer comparisons.
 124         SIMD_FORCE_INLINE operator btScalar*() { return &m_floats[0]; }
 125         SIMD_FORCE_INLINE operator const btScalar*() const { return &m_floats[0]; }
 126
 127         SIMD_FORCE_INLINE bool operator==(const btQuadWord& other) const
 128         {
 129 #ifdef BT_USE_SSE
 130                 return (0xf == _mm_movemask_ps((__m128)_mm_cmpeq_ps(mVec128, other.mVec128)));
 131 #else
 132                 return ((m_floats[3] == other.m_floats[3]) &&
 133                                 (m_floats[2] == other.m_floats[2]) &&
 134                                 (m_floats[1] == other.m_floats[1]) &&
 135                                 (m_floats[0] == other.m_floats[0]));
 136 #endif
 137         }
 138
 139         SIMD_FORCE_INLINE bool operator!=(const btQuadWord& other) const
 140         {
 141                 return !(*this == other);
 142         }
 143
 144         /**@brief Set x,y,z and zero w
 145    * @param x Value of x
 146    * @param y Value of y
 147    * @param z Value of z
 148    */
 149         SIMD_FORCE_INLINE void setValue(const btScalar& _x, const btScalar& _y, const btScalar& _z)
 150         {
 151                 m_floats[0] = _x;
 152                 m_floats[1] = _y;
 153                 m_floats[2] = _z;
 154                 m_floats[3] = 0.f;
 155         }
 156
 157         /*              void getValue(btScalar *m) const
 158                 {
 159                         m[0] = m_floats[0];
 160                         m[1] = m_floats[1];
 161                         m[2] = m_floats[2];
 162                 }
 163 */
 164         /**@brief Set the values
 165    * @param x Value of x
 166    * @param y Value of y
 167    * @param z Value of z
 168    * @param w Value of w
 169    */
 170         SIMD_FORCE_INLINE void setValue(const btScalar& _x, const btScalar& _y, const btScalar& _z, const btScalar& _w)
 171         {
 172                 m_floats[0] = _x;
 173                 m_floats[1] = _y;
 174                 m_floats[2] = _z;
 175                 m_floats[3] = _w;
 176         }
 177         /**@brief No initialization constructor */
 178         SIMD_FORCE_INLINE btQuadWord()
 179         //      :m_floats[0](btScalar(0.)),m_floats[1](btScalar(0.)),m_floats[2](btScalar(0.)),m_floats[3](btScalar(0.))
 180         {
 181         }
 182
 183         /**@brief Three argument constructor (zeros w)
 184    * @param x Value of x
 185    * @param y Value of y
 186    * @param z Value of z
 187    */
 188         SIMD_FORCE_INLINE btQuadWord(const btScalar& _x, const btScalar& _y, const btScalar& _z)
 189         {
 190                 m_floats[0] = _x, m_floats[1] = _y, m_floats[2] = _z, m_floats[3] = 0.0f;
 191         }
 192
 193         /**@brief Initializing constructor
 194    * @param x Value of x
 195    * @param y Value of y
 196    * @param z Value of z
 197    * @param w Value of w
 198    */
 199         SIMD_FORCE_INLINE btQuadWord(const btScalar& _x, const btScalar& _y, const btScalar& _z, const btScalar& _w)
 200         {
 201                 m_floats[0] = _x, m_floats[1] = _y, m_floats[2] = _z, m_floats[3] = _w;
 202         }
 203
 204         /**@brief Set each element to the max of the current values and the values of another btQuadWord
 205    * @param other The other btQuadWord to compare with
 206    */
 207         SIMD_FORCE_INLINE void setMax(const btQuadWord& other)
 208         {
 209 #ifdef BT_USE_SSE
 210                 mVec128 = _mm_max_ps(mVec128, other.mVec128);
 211 #elif defined(BT_USE_NEON)
 212                 mVec128 = vmaxq_f32(mVec128, other.mVec128);
 213 #else
 214                 btSetMax(m_floats[0], other.m_floats[0]);
 215                 btSetMax(m_floats[1], other.m_floats[1]);
 216                 btSetMax(m_floats[2], other.m_floats[2]);
 217                 btSetMax(m_floats[3], other.m_floats[3]);
 218 #endif
 219         }
 220         /**@brief Set each element to the min of the current values and the values of another btQuadWord
 221    * @param other The other btQuadWord to compare with
 222    */
 223         SIMD_FORCE_INLINE void setMin(const btQuadWord& other)
 224         {
 225 #ifdef BT_USE_SSE
 226                 mVec128 = _mm_min_ps(mVec128, other.mVec128);
 227 #elif defined(BT_USE_NEON)
 228                 mVec128 = vminq_f32(mVec128, other.mVec128);
 229 #else
 230                 btSetMin(m_floats[0], other.m_floats[0]);
 231                 btSetMin(m_floats[1], other.m_floats[1]);
 232                 btSetMin(m_floats[2], other.m_floats[2]);
 233                 btSetMin(m_floats[3], other.m_floats[3]);
 234 #endif
 235         }
 236 };
 237
 238 #endif  //BT_SIMD_QUADWORD_H