dep/include/g3dlite/G3D/Vector3.inl

   1 /**
   2   @file Vector3.inl
   3
   4   @maintainer Morgan McGuire, matrix@graphics3d.com
   5
   6   @cite Portions based on Dave Eberly's Magic Software Library at http://www.magic-software.com
   7
   8   @created 2001-06-02
   9   @edited  2004-05-21
  10   Copyright 2000-2004, Morgan McGuire.
  11   All rights reserved.
  12  */
  13
  14 //----------------------------------------------------------------------------
  15 #ifdef SSE
  16         // If you receive an error on this line, it is because you do not have the file
  17         // xmmintrin.h needed for MMX & SSE extensions.  Download and install
  18     //
  19     // http://download.microsoft.com/download/vstudio60ent/SP5/Wideband-Full/WIN98Me/EN-US/vs6sp5.exe
  20         // and
  21     // http://download.microsoft.com/download/vb60ent/Update/6/W9X2KXP/EN-US/vcpp5.exe
  22     //
  23     // to get this file.
  24 #   include <xmmintrin.h>
  25 #endif
  26
  27 inline unsigned int hashCode(const G3D::Vector3& v) {
  28      return v.hashCode();
  29 }
  30
  31 namespace G3D {
  32
  33 //----------------------------------------------------------------------------
  34 inline Vector3::Vector3() : x(0.0f), y(0.0f), z(0.0f) {
  35 }
  36
  37 //----------------------------------------------------------------------------
  38
  39 inline Vector3::Vector3 (float fX, float fY, float fZ) : x(fX), y(fY), z(fZ) {
  40 }
  41
  42 //----------------------------------------------------------------------------
  43 inline Vector3::Vector3 (float V[3]) : x(V[0]), y(V[1]), z(V[2]){
  44 }
  45 //----------------------------------------------------------------------------
  46 inline Vector3::Vector3 (double V[3]) : x((float)V[0]), y((float)V[1]), z((float)V[2]){
  47 }
  48
  49 //----------------------------------------------------------------------------
  50 inline Vector3::Vector3 (const Vector3& V) : x(V.x), y(V.y), z(V.z) {
  51 }
  52
  53 //----------------------------------------------------------------------------
  54
  55 //inline Vector3::Vector3 (const __m128& m) {
  56     // Cast from SSE packed floats
  57 //    *this = *(Vector3*)&m;
  58 //}
  59
  60 //----------------------------------------------------------------------------
  61 inline const float& Vector3::operator[] (int i) const {
  62     return ((float*)this)[i];
  63 }
  64
  65 inline float& Vector3::operator[] (int i) {
  66     return ((float*)this)[i];
  67 }
  68
  69
  70 //----------------------------------------------------------------------------
  71 inline Vector3& Vector3::operator= (const Vector3& rkVector) {
  72     x = rkVector.x;
  73     y = rkVector.y;
  74     z = rkVector.z;
  75     return *this;
  76 }
  77
  78 //----------------------------------------------------------------------------
  79
  80 inline bool Vector3::fuzzyEq(const Vector3& other) const {
  81     return G3D::fuzzyEq((*this - other).squaredMagnitude(), 0);
  82 }
  83
  84 //----------------------------------------------------------------------------
  85
  86 inline bool Vector3::fuzzyNe(const Vector3& other) const {
  87     return G3D::fuzzyNe((*this - other).squaredMagnitude(), 0);
  88 }
  89
  90 //----------------------------------------------------------------------------
  91
  92 inline bool Vector3::isFinite() const {
  93     return G3D::isFinite(x) && G3D::isFinite(y) && G3D::isFinite(z);
  94 }
  95
  96 //----------------------------------------------------------------------------
  97 inline bool Vector3::operator== (const Vector3& rkVector) const {
  98     return ( x == rkVector.x && y == rkVector.y && z == rkVector.z );
  99 }
 100
 101 //----------------------------------------------------------------------------
 102 inline bool Vector3::operator!= (const Vector3& rkVector) const {
 103     return ( x != rkVector.x || y != rkVector.y || z != rkVector.z );
 104 }
 105
 106 //----------------------------------------------------------------------------
 107 inline Vector3 Vector3::operator+ (const Vector3& rkVector) const {
 108     return Vector3(x + rkVector.x, y + rkVector.y, z + rkVector.z);
 109 }
 110
 111 //----------------------------------------------------------------------------
 112 inline Vector3 Vector3::operator- (const Vector3& rkVector) const {
 113     return Vector3(x - rkVector.x, y - rkVector.y, z - rkVector.z);
 114 }
 115
 116 //----------------------------------------------------------------------------
 117 inline Vector3 Vector3::operator* (const Vector3& rkVector) const {
 118     return Vector3(x * rkVector.x, y * rkVector.y, z * rkVector.z);
 119 }
 120
 121 inline Vector3 Vector3::operator*(float f) const {
 122     return Vector3(x * f, y * f, z * f);
 123 }
 124
 125 //----------------------------------------------------------------------------
 126 inline Vector3 Vector3::operator/ (const Vector3& rkVector) const {
 127     return Vector3(x / rkVector.x, y / rkVector.y, z / rkVector.z);
 128 }
 129
 130 //----------------------------------------------------------------------------
 131 inline Vector3 Vector3::operator- () const {
 132     return Vector3(-x, -y, -z);
 133 }
 134
 135 //----------------------------------------------------------------------------
 136 inline Vector3& Vector3::operator+= (const Vector3& rkVector) {
 137     x += rkVector.x;
 138     y += rkVector.y;
 139     z += rkVector.z;
 140     return *this;
 141 }
 142
 143 //----------------------------------------------------------------------------
 144 inline Vector3& Vector3::operator-= (const Vector3& rkVector) {
 145     x -= rkVector.x;
 146     y -= rkVector.y;
 147     z -= rkVector.z;
 148     return *this;
 149 }
 150
 151 //----------------------------------------------------------------------------
 152 inline Vector3& Vector3::operator*= (float fScalar) {
 153     x *= fScalar;
 154     y *= fScalar;
 155     z *= fScalar;
 156     return *this;
 157 }
 158
 159 //----------------------------------------------------------------------------
 160 inline Vector3& Vector3::operator*= (const Vector3& rkVector) {
 161     x *= rkVector.x;
 162     y *= rkVector.y;
 163     z *= rkVector.z;
 164     return *this;
 165 }
 166
 167 //----------------------------------------------------------------------------
 168 inline Vector3& Vector3::operator/= (const Vector3& rkVector) {
 169     x /= rkVector.x;
 170     y /= rkVector.y;
 171     z /= rkVector.z;
 172     return *this;
 173 }
 174
 175 //----------------------------------------------------------------------------
 176 inline float Vector3::squaredMagnitude () const {
 177     return x*x + y*y + z*z;
 178 }
 179
 180 //----------------------------------------------------------------------------
 181 inline float Vector3::squaredLength () const {
 182     return squaredMagnitude();
 183 }
 184
 185 //----------------------------------------------------------------------------
 186 inline float Vector3::magnitude() const {
 187     return sqrtf(x*x + y*y + z*z);
 188 }
 189
 190 //----------------------------------------------------------------------------
 191 inline float Vector3::length() const {
 192     return magnitude();
 193 }
 194
 195 //----------------------------------------------------------------------------
 196 inline Vector3 Vector3::direction () const {
 197     float lenSquared = squaredMagnitude();
 198     float invSqrt = 1.0f / sqrtf(lenSquared);
 199     return Vector3(x * invSqrt, y * invSqrt, z * invSqrt);
 200 }
 201
 202 //----------------------------------------------------------------------------
 203
 204 inline Vector3 Vector3::fastDirection () const {
 205     float lenSquared = x * x + y * y + z * z;
 206     float invSqrt = rsq(lenSquared);
 207     return Vector3(x * invSqrt, y * invSqrt, z * invSqrt);
 208 }
 209
 210 //----------------------------------------------------------------------------
 211 inline float Vector3::dot (const Vector3& rkVector) const {
 212     return x*rkVector.x + y*rkVector.y + z*rkVector.z;
 213 }
 214
 215 //----------------------------------------------------------------------------
 216 inline Vector3 Vector3::cross (const Vector3& rkVector) const {
 217     return Vector3(y*rkVector.z - z*rkVector.y, z*rkVector.x - x*rkVector.z,
 218                    x*rkVector.y - y*rkVector.x);
 219 }
 220
 221 //----------------------------------------------------------------------------
 222 inline Vector3 Vector3::unitCross (const Vector3& rkVector) const {
 223     Vector3 kCross(y*rkVector.z - z*rkVector.y, z*rkVector.x - x*rkVector.z,
 224                    x*rkVector.y - y*rkVector.x);
 225     kCross.unitize();
 226     return kCross;
 227 }
 228
 229 //----------------------------------------------------------------------------
 230 inline Vector3 Vector3::min(const Vector3 &v) const {
 231     return Vector3(G3D::min(v.x, x), G3D::min(v.y, y), G3D::min(v.z, z));
 232 }
 233
 234 //----------------------------------------------------------------------------
 235 inline Vector3 Vector3::max(const Vector3 &v) const {
 236     return Vector3(G3D::max(v.x, x), G3D::max(v.y, y), G3D::max(v.z, z));
 237 }
 238
 239 //----------------------------------------------------------------------------
 240 inline bool Vector3::isZero() const {
 241     return G3D::fuzzyEq(squaredMagnitude(), 0.0f);
 242 }
 243
 244 //----------------------------------------------------------------------------
 245
 246 inline bool Vector3::isUnit() const {
 247     return G3D::fuzzyEq(squaredMagnitude(), 1.0f);
 248 }
 249
 250 } // namespace