1 /* 2 * Copyright 2008 Haiku Inc. All rights reserved. 3 * Distributed under the terms of the MIT License. 4 * 5 * Authors: 6 * Alexandre Deckner 7 * 8 */ 9 10 /* 11 * 12 * This is a refactored and stripped down version of bullet-2.66 src\LinearMath\btVector3.h 13 * The dependancies on base class btQuadWord have been removed for simplification. 14 * 15 */ 16 17 /* 18 Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans http://continuousphysics.com/Bullet/ 19 20 This software is provided 'as-is', without any express or implied warranty. 21 In no event will the authors be held liable for any damages arising from the use of this software. 22 Permission is granted to anyone to use this software for any purpose, 23 including commercial applications, and to alter it and redistribute it freely, 24 subject to the following restrictions: 25 26 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. 27 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 28 3. This notice may not be removed or altered from any source distribution. 29 */ 30 31 32 #ifndef __VECTOR3_H__ 33 #define __VECTOR3_H__ 34 35 ///Vector3 can be used to represent 3D points and vectors. 36 37 class Vector3 { 38 protected: 39 float m_x; 40 float m_y; 41 float m_z; 42 43 public: 44 inline Vector3() {} 45 46 47 inline Vector3(const Vector3& v) 48 { 49 *((Vector3*)this) = v; 50 } 51 52 53 inline Vector3(const float& x, const float& y, const float& z) 54 { 55 m_x = x, m_y = y, m_z = z; 56 } 57 58 59 inline const float& x() const { return m_x; } 60 61 62 inline const float& y() const { return m_y; } 63 64 65 inline const float& z() const { return m_z; } 66 67 68 inline void setValue(const float& x, const float& y, const float& z) 69 { 70 m_x=x; 71 m_y=y; 72 m_z=z; 73 } 74 75 inline Vector3& operator+=(const Vector3& v) 76 { 77 m_x += v.x(); m_y += v.y(); m_z += v.z(); 78 return *this; 79 } 80 81 82 inline Vector3& operator-=(const Vector3& v) 83 { 84 m_x -= v.x(); m_y -= v.y(); m_z -= v.z(); 85 return *this; 86 } 87 88 89 inline Vector3& operator*=(const float& s) 90 { 91 m_x *= s; m_y *= s; m_z *= s; 92 return *this; 93 } 94 95 96 inline Vector3& operator/=(const float& s) 97 { 98 assert(s != 0.0f); 99 return *this *= 1.0f / s; 100 } 101 102 103 inline float dot(const Vector3& v) const 104 { 105 return m_x * v.x() + m_y * v.y() + m_z * v.z(); 106 } 107 108 109 inline float length2() const 110 { 111 return dot(*this); 112 } 113 114 115 inline float length() const 116 { 117 return sqrt(length2()); 118 } 119 120 121 inline float distance2(const Vector3& v) const; 122 123 124 inline float distance(const Vector3& v) const; 125 126 127 inline Vector3& normalize() 128 { 129 return *this /= length(); 130 } 131 132 133 inline Vector3 normalized() const; 134 135 136 inline Vector3 rotate( const Vector3& wAxis, const float angle ); 137 138 139 inline float angle(const Vector3& v) const 140 { 141 float s = sqrt(length2() * v.length2()); 142 assert(s != 0.0f); 143 return acos(dot(v) / s); 144 } 145 146 147 inline Vector3 absolute() const 148 { 149 return Vector3( 150 fabs(m_x), 151 fabs(m_y), 152 fabs(m_z)); 153 } 154 155 156 inline Vector3 cross(const Vector3& v) const 157 { 158 return Vector3( 159 m_y * v.z() - m_z * v.y(), 160 m_z * v.x() - m_x * v.z(), 161 m_x * v.y() - m_y * v.x()); 162 } 163 164 165 inline float triple(const Vector3& v1, const Vector3& v2) const 166 { 167 return m_x * (v1.y() * v2.z() - v1.z() * v2.y()) + 168 m_y * (v1.z() * v2.x() - v1.x() * v2.z()) + 169 m_z * (v1.x() * v2.y() - v1.y() * v2.x()); 170 } 171 172 173 inline int minAxis() const 174 { 175 return m_x < m_y ? (m_x < m_z ? 0 : 2) : (m_y < m_z ? 1 : 2); 176 } 177 178 179 inline int maxAxis() const 180 { 181 return m_x < m_y ? (m_y < m_z ? 2 : 1) : (m_x < m_z ? 2 : 0); 182 } 183 184 185 inline int furthestAxis() const 186 { 187 return absolute().minAxis(); 188 } 189 190 191 inline int closestAxis() const 192 { 193 return absolute().maxAxis(); 194 } 195 196 197 inline void setInterpolate3(const Vector3& v0, const Vector3& v1, float rt) 198 { 199 float s = 1.0f - rt; 200 m_x = s * v0.x() + rt * v1.x(); 201 m_y = s * v0.y() + rt * v1.y(); 202 m_z = s * v0.z() + rt * v1.z(); 203 //don't do the unused w component 204 // m_co[3] = s * v0[3] + rt * v1[3]; 205 } 206 207 208 inline Vector3 lerp(const Vector3& v, const float& t) const 209 { 210 return Vector3(m_x + (v.x() - m_x) * t, 211 m_y + (v.y() - m_y) * t, 212 m_z + (v.z() - m_z) * t); 213 } 214 215 216 inline Vector3& operator*=(const Vector3& v) 217 { 218 m_x *= v.x(); m_y *= v.y(); m_z *= v.z(); 219 return *this; 220 } 221 222 }; 223 224 inline Vector3 225 operator+(const Vector3& v1, const Vector3& v2) 226 { 227 return Vector3(v1.x() + v2.x(), v1.y() + v2.y(), v1.z() + v2.z()); 228 } 229 230 inline Vector3 231 operator*(const Vector3& v1, const Vector3& v2) 232 { 233 return Vector3(v1.x() * v2.x(), v1.y() * v2.y(), v1.z() * v2.z()); 234 } 235 236 inline Vector3 237 operator-(const Vector3& v1, const Vector3& v2) 238 { 239 return Vector3(v1.x() - v2.x(), v1.y() - v2.y(), v1.z() - v2.z()); 240 } 241 242 inline Vector3 243 operator-(const Vector3& v) 244 { 245 return Vector3(-v.x(), -v.y(), -v.z()); 246 } 247 248 inline Vector3 249 operator*(const Vector3& v, const float& s) 250 { 251 return Vector3(v.x() * s, v.y() * s, v.z() * s); 252 } 253 254 inline Vector3 255 operator*(const float& s, const Vector3& v) 256 { 257 return v * s; 258 } 259 260 inline Vector3 261 operator/(const Vector3& v, const float& s) 262 { 263 assert(s != 0.0f); 264 return v * (1.0f / s); 265 } 266 267 inline Vector3 268 operator/(const Vector3& v1, const Vector3& v2) 269 { 270 return Vector3(v1.x() / v2.x(),v1.y() / v2.y(),v1.z() / v2.z()); 271 } 272 273 inline float 274 dot(const Vector3& v1, const Vector3& v2) 275 { 276 return v1.dot(v2); 277 } 278 279 inline float 280 distance2(const Vector3& v1, const Vector3& v2) 281 { 282 return v1.distance2(v2); 283 } 284 285 286 inline float 287 distance(const Vector3& v1, const Vector3& v2) 288 { 289 return v1.distance(v2); 290 } 291 292 inline float 293 angle(const Vector3& v1, const Vector3& v2) 294 { 295 return v1.angle(v2); 296 } 297 298 inline Vector3 299 cross(const Vector3& v1, const Vector3& v2) 300 { 301 return v1.cross(v2); 302 } 303 304 inline float 305 triple(const Vector3& v1, const Vector3& v2, const Vector3& v3) 306 { 307 return v1.triple(v2, v3); 308 } 309 310 inline Vector3 311 lerp(const Vector3& v1, const Vector3& v2, const float& t) 312 { 313 return v1.lerp(v2, t); 314 } 315 316 317 inline bool operator==(const Vector3& p1, const Vector3& p2) 318 { 319 return p1.x() == p2.x() && p1.y() == p2.y() && p1.z() == p2.z(); 320 } 321 322 inline float Vector3::distance2(const Vector3& v) const 323 { 324 return (v - *this).length2(); 325 } 326 327 inline float Vector3::distance(const Vector3& v) const 328 { 329 return (v - *this).length(); 330 } 331 332 inline Vector3 Vector3::normalized() const 333 { 334 return *this / length(); 335 } 336 337 inline Vector3 Vector3::rotate( const Vector3& wAxis, const float angle ) 338 { 339 // wAxis must be a unit lenght vector 340 341 Vector3 o = wAxis * wAxis.dot( *this ); 342 Vector3 x = *this - o; 343 Vector3 y; 344 345 y = wAxis.cross( *this ); 346 347 return ( o + x * cos( angle ) + y * sin( angle ) ); 348 } 349 350 #endif //__VECTOR3_H__ 351