开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 其他游戏 > 查看源码
Matrix.h
资源名称：MMOPRG_server_dev.rar　[点击查看]
上传用户：ghyvgy
上传日期：2009-05-26
资源大小：547k
文件大小：42k
源码类别：

其他游戏

开发平台：

Python

Matrix.h：源码内容
  1. /*
  2. s_p_oneil@hotmail.com
  3. Copyright (c) 2000, Sean O'Neil
  4. All rights reserved.
  6. Redistribution and use in source and binary forms, with or without
  7. modification, are permitted provided that the following conditions are met:
  9. * Redistributions of source code must retain the above copyright notice,
  10.   this list of conditions and the following disclaimer.
  11. * Redistributions in binary form must reproduce the above copyright notice,
  12.   this list of conditions and the following disclaimer in the documentation
  13.   and/or other materials provided with the distribution.
  14. * Neither the name of this project nor the names of its contributors
  15.   may be used to endorse or promote products derived from this software
  16.   without specific prior written permission.
  18. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  19. AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20. IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21. ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  22. LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23. CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24. SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  25. INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  26. CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27. ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28. POSSIBILITY OF SUCH DAMAGE.
  29. */
  31. #ifndef __Matrix_h__
  32. #define __Matrix_h__
  34. #include "Noise.h" // Has some useful defines and inline functions
  36. class CMatrix;
  37. class CQuaternion;
  38. class C3DObject;
  40. /*******************************************************************************
  41. * Template Class: TVector
  42. ********************************************************************************
  43. * This template class implements a simple 3D vector with x, y, and z coordinates.
  44. * Several functions and operators are defined to make working with vectors easier,
  45. * and because it's templatized, any numeric type can be used with it. Macros are
  46. * defined for the most common types.
  47. *******************************************************************************/
  48. #define CVector TVector<float>
  49. #define CDoubleVector TVector<double>
  50. #define CIntVector TVector<int>
  51. #define CByteVector TVector<unsigned char>
  52. template <class T> class TVector
  53. {
  54. public:
  55. T x, y, z;
  57. // Constructors
  58. TVector() {}
  59. TVector(const T a, const T b, const T c) { x = a; y = b; z = c; }
  60. TVector(const T t) { *this = t; }
  61. TVector(const T *pt) { *this = pt; }
  62. TVector(const TVector<T> &v) { *this = v; }
  64. // Casting and unary operators
  65. operator TVector<float>() { return TVector<float>((float)x, (float)y, (float)z); }
  66. operator TVector<double>() { return TVector<double>((double)x, (double)y, (double)z); }
  67. operator T*() { return &x; }
  68. T &operator[](const int n) { return (&x)[n]; }
  69. operator const T*() const { return &x; }
  70. T operator[](const int n) const { return (&x)[n]; }
  71. TVector<T> operator-() const { return TVector<T>(-x, -y, -z); }
  73. // Equal and comparison operators
  74. void operator=(const T t) { x = y = z = t; }
  75. void operator=(const T *pt) { x = pt[0]; y = pt[1]; z = pt[2]; }
  76. void operator=(const TVector<T> &v) { x = v.x; y = v.y; z = v.z; }
  77. bool operator==(TVector<T> &v) const { return (Abs(x - v.x) <= (T)0.001f && Abs(y - v.y) <= 0.001f && Abs(z - v.z) <= 0.001f); }
  78. bool operator!=(TVector<T> &v) const { return !(*this == v); }
  80. // Arithmetic operators (vector with scalar)
  81. TVector<T> operator+(const T t) const { return TVector<T>(x+t, y+t, z+t); }
  82. TVector<T> operator-(const T t) const { return TVector<T>(x-t, y-t, z-t); }
  83. TVector<T> operator*(const T t) const { return TVector<T>(x*t, y*t, z*t); }
  84. TVector<T> operator/(const T t) const { return TVector<T>(x/t, y/t, z/t); }
  85. void operator+=(const T t) { x += t; y += t; z += t; }
  86. void operator-=(const T t) { x -= t; y -= t; z -= t; }
  87. void operator*=(const T t) { x *= t; y *= t; z *= t; }
  88. void operator/=(const T t) { x /= t; y /= t; z /= t; }
  90. // Arithmetic operators (vector with vector)
  91. TVector<T> operator+(const TVector<T> &v) const { return TVector<T>(x+v.x, y+v.y, z+v.z); }
  92. TVector<T> operator-(const TVector<T> &v) const { return TVector<T>(x-v.x, y-v.y, z-v.z); }
  93. TVector<T> operator*(const TVector<T> &v) const { return TVector<T>(x*v.x, y*v.y, z*v.z); }
  94. TVector<T> operator/(const TVector<T> &v) const { return TVector<T>(x/v.x, y/v.y, z/v.z); }
  95. void operator+=(const TVector<T> &v) { x += v.x; y += v.y; z += v.z; }
  96. void operator-=(const TVector<T> &v) { x -= v.x; y -= v.y; z -= v.z; }
  97. void operator*=(const TVector<T> &v) { x *= v.x; y *= v.y; z *= v.z; }
  98. void operator/=(const TVector<T> &v) { x /= v.x; y /= v.y; z /= v.z; }
  100. // Dot and cross product operators
  101. T operator|(const TVector<T> &v) const { return x*v.x + y*v.y + z*v.z; }
  102. TVector<T> operator^(const TVector<T> &v) const { return TVector<T>(y*v.z - z*v.y, z*v.x - x*v.z, x*v.y - y*v.x); }
  103. void operator^=(const TVector<T> &v) { *this = *this ^ v; }
  105. // Magnitude/distance methods
  106. T MagnitudeSquared() const { return x*x + y*y + z*z; }
  107. T Magnitude() const { return (T)sqrt(MagnitudeSquared()); }
  108. T DistanceSquared(const TVector<T> &v) const{ return (*this - v).MagnitudeSquared(); }
  109. T Distance(const TVector<T> &v) const { return (*this - v).Magnitude(); }
  110. TVector<T> Midpoint(const TVector<T> &v) const { return CVector((*this - v) / 2 + v); }
  111. TVector<T> Average(const TVector<T> &v) const { return CVector((*this + v) / 2); }
  113. // Advanced methods (should only be used with float or double types)
  114. void Normalize() { *this /= Magnitude(); }
  115. double Angle(const TVector<T> &v) const { return acos(*this | v); }
  116. TVector<T> Reflect(const TVector<T> &n) const
  117. {
  118. T t = (T)Magnitude();
  119. TVector<T> v = *this / t;
  120. return (v - n * (2 * (v | n))) * t;
  121. }
  122. TVector<T> Rotate(const T tAngle, const CVector &n) const
  123. {
  124. T tCos = (T)cos(tAngle);
  125. T tSin = (T)sin(tAngle);
  126. return TVector<T>(*this * tCos + ((n * *this) * (1 - tCos)) * n + (*this ^ n) * tSin);
  127. }
  128. };
  130. // Returns the normal vector of two vectors (the normalized cross product)
  131. template <class T> inline TVector<T> NormalVector(const TVector<T> &v1, const TVector<T> &v2)
  132. {
  133. TVector<T> v = v1 ^ v2;
  134. v.Normalize();
  135. return v;
  136. }
  138. // Returns the normal vector of a triangle or 3 points on a plane (assumes counter-clockwise orientation)
  139. template <class T> inline TVector<T> NormalVector(const TVector<T> &p1, const TVector<T> &p2, const TVector<T> &p3)
  140. {
  141. return NormalVector(p2-p1, p3-p1);
  142. }
  144. // Returns the direction vector between two points
  145. template <class T> inline TVector<T> DirectionVector(const TVector<T> &p1, const TVector<T> &p2)
  146. {
  147. TVector<T> v = p2 - p1;
  148. v.Normalize();
  149. return v;
  150. }
  153. /*******************************************************************************
  154. * Template Class: TVector4
  155. ********************************************************************************
  156. * This template class implements a simple 4D vector with x, y, z, and w
  157. * coordinates. Like TVector, it is templatized and macros are defined for the
  158. * most common types.
  159. *******************************************************************************/
  160. #define CVector4 TVector4<float>
  161. #define CDoubleVector4 TVector4<double>
  162. #define CIntVector4 TVector4<int>
  163. #define CByteVector4 TVector4<unsigned char>
  164. template <class T> class TVector4
  165. {
  166. public:
  167. T x, y, z, w;
  169. // Constructors
  170. TVector4() {}
  171. TVector4(const T a, const T b, const T c, const T d) { x = a; y = b; z = c; w = d; }
  172. TVector4(const T t) { *this = t; }
  173. TVector4(const T *pt) { *this = pt; }
  174. TVector4(const TVector<T> &v) { *this = v; }
  175. TVector4(const TVector4<T> &v) { *this = v; }
  177. // Casting and unary operators
  178. operator T*() { return &x; }
  179. T &operator[](const int n) { return (&x)[n]; }
  180. operator const T*() const { return &x; }
  181. T operator[](const int n) const { return (&x)[n]; }
  182. TVector4<T> operator-() const { return TVector4<T>(-x, -y, -z, -w); }
  184. // Equal and comparison operators
  185. void operator=(const T t) { x = y = z = w = t; }
  186. void operator=(const T *pt) { x = pt[0]; y = pt[1]; z = pt[2]; w = pt[3]; }
  187. void operator=(const TVector<T> &v) { x = v.x; y = v.y; z = v.z; w = 0; }
  188. void operator=(const TVector4<T> &v) { x = v.x; y = v.y; z = v.z; w = v.w; }
  189. bool operator==(TVector4<T> &v) const { return (Abs(x - v.x) <= (T)DELTA && Abs(y - v.y) <= (T)DELTA && Abs(z - v.z) <= (T)DELTA && Abs(w - v.w) <= (T)DELTA); }
  190. bool operator!=(TVector4<T> &v) const { return !(*this == v); }
  192. // Arithmetic operators (vector with scalar)
  193. TVector4<T> operator+(const T t) const { return TVector4<T>(x+t, y+t, z+t, w+t); }
  194. TVector4<T> operator-(const T t) const { return TVector4<T>(x-t, y-t, z-t, w-t); }
  195. TVector4<T> operator*(const T t) const { return TVector4<T>(x*t, y*t, z*t, w*t); }
  196. TVector4<T> operator/(const T t) const { return TVector4<T>(x/t, y/t, z/t, w/t); }
  197. void operator+=(const T t) { x += t; y += t; z += t; w += t; }
  198. void operator-=(const T t) { x -= t; y -= t; z -= t; w -= t; }
  199. void operator*=(const T t) { x *= t; y *= t; z *= t; w *= t; }
  200. void operator/=(const T t) { x /= t; y /= t; z /= t; w /= t; }
  202. // Arithmetic operators (vector with vector)
  203. TVector4<T> operator+(const TVector4<T> &v) const { return TVector4<T>(x+v.x, y+v.y, z+v.z, w+v.w); }
  204. TVector4<T> operator-(const TVector4<T> &v) const { return TVector4<T>(x-v.x, y-v.y, z-v.z, w-v.w); }
  205. TVector4<T> operator*(const TVector4<T> &v) const { return TVector4<T>(x*v.x, y*v.y, z*v.z, w*v.w); }
  206. TVector4<T> operator/(const TVector4<T> &v) const { return TVector4<T>(x/v.x, y/v.y, z/v.z, w/v.w); }
  207. void operator+=(const TVector4<T> &v) { x += v.x; y += v.y; z += v.z; w += v.w; }
  208. void operator-=(const TVector4<T> &v) { x -= v.x; y -= v.y; z -= v.z; w -= v.w; }
  209. void operator*=(const TVector4<T> &v) { x *= v.x; y *= v.y; z *= v.z; w *= v.w; }
  210. void operator/=(const TVector4<T> &v) { x /= v.x; y /= v.y; z /= v.z; w /= v.w; }
  212. // Magnitude/normalize methods
  213. T MagnitudeSquared() const { return x*x + y*y + z*z + w*w; }
  214. T Magnitude() const { return (T)sqrt(MagnitudeSquared()); }
  215. void Normalize() { *this /= Magnitude(); }
  216. };
  219. /*******************************************************************************
  220. * Class: CQuaternion
  221. ********************************************************************************
  222. * This class implements a 4D quaternion. Several functions and operators are
  223. * defined to make working with quaternions easier. Quaternions are often used to
  224. * represent rotations, and have a number of advantages over other constructs.
  225. * Their main disadvantage is that they are unintuitive.
  226. *
  227. * Note: This class is not templatized because integral data types don't make sense
  228. *       and there's no need for double-precision.
  229. *******************************************************************************/
  230. class CQuaternion
  231. {
  232. public:
  233. float x, y, z, w;
  235. // Constructors
  236. CQuaternion() {}
  237. CQuaternion(const float a, const float b, const float c, const float d) { x = a; y = b; z = c; w = d; }
  238. CQuaternion(const CVector &v, const float f){ SetAxisAngle(v, f); }
  239. CQuaternion(const CVector &v) { *this = v; }
  240. CQuaternion(const CQuaternion &q) { *this = q; }
  241. CQuaternion(const CMatrix &m) { *this = m; }
  242. CQuaternion(const float *p) { *this = p; }
  244. // Casting and unary operators
  245. operator float*() { return &x; }
  246. float &operator[](const int n) { return (&x)[n]; }
  247. operator const float*() const { return &x; }
  248. float operator[](const int n) const { return (&x)[n]; }
  249. CQuaternion operator-() const { return CQuaternion(-x, -y, -z, -w); }
  251. // Equal and comparison operators
  252. void operator=(const CVector &v) { x = v.x; y = v.y; z = v.z; w = 0; }
  253. void operator=(const CQuaternion &q) { x = q.x; y = q.y; z = q.z; w = q.w; }
  254. void operator=(const CMatrix &m);
  255. void operator=(const float *p) { x = p[0]; y = p[1]; z = p[2]; w = p[3]; }
  257. // Arithmetic operators (quaternion and scalar)
  258. CQuaternion operator+(const float f) const { return CQuaternion(x+f, y+f, z+f, w+f); }
  259. CQuaternion operator-(const float f) const { return CQuaternion(x-f, y-f, z-f, w-f); }
  260. CQuaternion operator*(const float f) const { return CQuaternion(x*f, y*f, z*f, w*f); }
  261. CQuaternion operator/(const float f) const { return CQuaternion(x/f, y/f, z/f, w/f); }
  262. void operator+=(const float f) { x+=f; y+=f; z+=f; w+=f; }
  263. void operator-=(const float f) { x-=f; y-=f; z-=f; w-=f; }
  264. void operator*=(const float f) { x*=f; y*=f; z*=f; w*=f; }
  265. void operator/=(const float f) { x/=f; y/=f; z/=f; w/=f; }
  267. // Arithmetic operators (quaternion and quaternion)
  268. CQuaternion operator+(const CQuaternion &q) const { return CQuaternion(x+q.x, y+q.y, z+q.z, w+q.w); }
  269. CQuaternion operator-(const CQuaternion &q) const { return CQuaternion(x-q.x, y-q.y, z-q.z, w-q.w); }
  270. CQuaternion operator*(const CQuaternion &q) const; // Multiplying quaternions is a special operation
  271. void operator+=(const CQuaternion &q) { x+=q.x; y+=q.y; z+=q.z; w+=q.w; }
  272. void operator-=(const CQuaternion &q) { x-=q.x; y-=q.y; z-=q.z; w-=q.w; }
  273. void operator*=(const CQuaternion &q) { *this = *this * q; }
  275. // Magnitude/normalize methods
  276. float MagnitudeSquared() const { return x*x + y*y + z*z + w*w; }
  277. float Magnitude() const { return sqrtf(MagnitudeSquared()); }
  278. void Normalize() { *this /= Magnitude(); }
  280. // Advanced quaternion methods
  281. CQuaternion Conjugate() const { return CQuaternion(-x, -y, -z, w); }
  282. CQuaternion Inverse() const { return Conjugate() / MagnitudeSquared(); }
  283. CQuaternion UnitInverse() const { return Conjugate(); }
  284. CVector RotateVector(const CVector &v) const { return (*this * CQuaternion(v) * UnitInverse()); }
  286. void SetAxisAngle(const CVector &vAxis, const float fAngle)
  287. {
  288. // 4 muls, 2 trig function calls
  289. float f = fAngle * 0.5f;
  290. *this = vAxis * sinf(f);
  291. w = cosf(f);
  292. }
  293. void GetAxisAngle(CVector &vAxis, float &fAngle) const
  294. {
  295. // 4 muls, 1 div, 2 trig function calls
  296. fAngle = acosf(w);
  297. vAxis = *this / sinf(fAngle);
  298. fAngle *= 2.0f;
  299. }
  301. void Rotate(const CQuaternion &q) { *this = q * *this; }
  302. void Rotate(const CVector &vAxis, const float fAngle)
  303. {
  304. CQuaternion q;
  305. q.SetAxisAngle(vAxis, fAngle);
  306. Rotate(q);
  307. }
  309. CVector GetViewAxis() const
  310. {
  311. // 6 muls, 7 adds
  312. float x2 = x + x, y2 = y + y, z2 = z + z;
  313. float xx = x * x2, xz = x * z2;
  314. float yy = y * y2, yz = y * z2;
  315. float wx = w * x2, wy = w * y2;
  316. return -CVector(xz+wy, yz-wx, 1-(xx+yy));
  317. }
  318. CVector GetUpAxis() const
  319. {
  320. // 6 muls, 7 adds
  321. float x2 = x + x, y2 = y + y, z2 = z + z;
  322. float xx = x * x2, xy = x * y2;
  323. float yz = y * z2, zz = z * z2;
  324. float wx = w * x2, wz = w * z2;
  325. return CVector(xy-wz, 1-(xx+zz), yz+wx);
  326. }
  327. CVector GetRightAxis() const
  328. {
  329. // 6 muls, 7 adds
  330. float x2 = x + x, y2 = y + y, z2 = z + z;
  331. float xy = x * y2, xz = x * z2;
  332. float yy = y * y2, zz = z * z2;
  333. float wy = w * y2, wz = w * z2;
  334. return CVector(1-(yy+zz), xy+wz, xz-wy);
  335. }
  336. };
  338. extern CQuaternion Slerp(const CQuaternion &q1, const CQuaternion &q2, const float t);
  340. /*******************************************************************************
  341. * Class: CMatrix
  342. ********************************************************************************
  343. * This class implements a 4x4 matrix. Several functions and operators are
  344. * defined to make working with matrices easier. The values are kept in column-
  345. * major order to make it easier to use with OpenGL. For performance reasons,
  346. * most of the functions assume that all matrices are orthogonal, which means the
  347. * bottom row is [ 0 0 0 1 ]. Since I plan to use the GL_PROJECTION matrix to
  348. * handle the projection matrix, I should never need to use any other kind of
  349. * matrix, and I get a decent performance boost by ignoring the bottom row.
  350. *
  351. * Note: This class is not templatized because integral data types don't make sense
  352. *       and there's no need for double-precision.
  353. *******************************************************************************/
  354. class CMatrix
  355. {
  356. public:
  357. // This class uses column-major order, as used by OpenGL
  358. // Here are the ways in which the matrix values can be accessed:
  359. // | f11 f21 f31 f41 |   | f1[0] f1[4] f1[8]  f1[12] |   | f2[0][0] f2[1][0] f2[2][0] f2[3][0] |
  360. // | f12 f22 f32 f42 |   | f1[1] f1[5] f1[9]  f1[13] |   | f2[0][1] f2[1][1] f2[2][1] f2[3][1] |
  361. // | f13 f23 f33 f43 | = | f1[2] f1[6] f1[10] f1[14] | = | f2[0][2] f2[1][2] f2[2][2] f2[3][2] |
  362. // | f14 f24 f34 f44 |   | f1[3] f1[7] f1[11] f1[15] |   | f2[0][3] f2[1][3] f2[2][3] f2[3][3] |
  363. union
  364. {
  365. struct { float f11, f12, f13, f14, f21, f22, f23, f24, f31, f32, f33, f34, f41, f42, f43, f44; };
  366. float f1[16];
  367. float f2[4][4];
  368. };
  370. CMatrix() {}
  371. CMatrix(const float f) { *this = f; }
  372. CMatrix(const float *pf) { *this = pf; }
  373. CMatrix(const CQuaternion &q) { *this = q; }
  375. // Init functions
  376. void ZeroMatrix()
  377. {
  378. f11 = f12 = f13 = f14 = f21 = f22 = f23 = f24 = f31 = f32 = f33 = f34 = f41 = f42 = f43 = f44 = 0;
  379. }
  380. void IdentityMatrix()
  381. {
  382. f12 = f13 = f14 = f21 = f23 = f24 = f31 = f32 = f34 = f41 = f42 = f43 = 0;
  383. f11 = f22 = f33 = f44 = 1;
  384. }
  386. operator float*() { return f1; }
  387. float &operator[](const int n) { return f1[n]; }
  388. float &operator()(const int i, const int j) { return f2[i][j]; }
  389. operator const float*() const { return f1; }
  390. float operator[](const int n) const { return f1[n]; }
  391. float operator()(const int i, const int j) const{ return f2[i][j]; }
  393. void operator=(const float f) { for(register int i=0; i<16; i++) f1[i] = f; }
  394. void operator=(const float *pf) { for(register int i=0; i<16; i++) f1[i] = pf[i]; }
  395. void operator=(const CQuaternion &q);
  397. CMatrix operator*(const CMatrix &m) const;
  398. void operator*=(const CMatrix &m) { *this = *this * m; }
  399. CVector operator*(const CVector &v) const { return TransformVector(v); }
  401. CVector TransformVector(const CVector &v) const
  402. {
  403. // 9 muls, 9 adds
  404. // | f11 f21 f31 f41 |   | v.x |   | f11*v.x+f21*v.y+f31*v.z+f41 |
  405. // | f12 f22 f32 f42 |   | v.y |   | f12*v.x+f22*v.y+f32*v.z+f42 |
  406. // | f13 f23 f33 f43 | * | v.z | = | f13*v.x+f23*v.y+f33*v.z+f43 |
  407. // | 0   0   0   1   |   | 1   |   | 1                           |
  408. return CVector((f11*v.x+f21*v.y+f31*v.z+f41),
  409.    (f12*v.x+f22*v.y+f32*v.z+f42),
  410.    (f13*v.x+f23*v.y+f33*v.z+f43));
  411. }
  412. CVector TransformNormal(const CVector &v) const
  413. {
  414. // 9 muls, 6 adds
  415. // (Transpose rotation vectors, ignore position)
  416. // | f11 f12 f13 0 |   | v.x |   | f11*v.x+f12*v.y+f13*v.z |
  417. // | f21 f22 f23 0 |   | v.y |   | f21*v.x+f22*v.y+f23*v.z |
  418. // | f31 f32 f33 0 | * | v.z | = | f31*v.x+f32*v.y+f33*v.z |
  419. // | 0   0   0   1 |   | 1   |   | 1                       |
  420. return CVector((f11*v.x+f12*v.y+f13*v.z),
  421.    (f21*v.x+f22*v.y+f23*v.z),
  422.    (f31*v.x+f32*v.y+f33*v.z));
  423. }
  425. // Translate functions
  426. void TranslateMatrix(const float x, const float y, const float z)
  427. {
  428. // | 1  0  0  x |
  429. // | 0  1  0  y |
  430. // | 0  0  1  z |
  431. // | 0  0  0  1 |
  432. f12 = f13 = f14 = f21 = f23 = f24 = f31 = f32 = f34 = 0;
  433. f11 = f22 = f33 = f44 = 1;
  434. f41 = x; f42 = y; f43 = z;
  435. }
  436. void TranslateMatrix(const float *pf) { TranslateMatrix(pf[0], pf[1], pf[2]); }
  437. void Translate(const float x, const float y, const float z)
  438. {
  439. // 9 muls, 9 adds
  440. // | f11 f21 f31 f41 |   | 1  0  0  x |   | f11 f21 f31 f11*x+f21*y+f31*z+f41 |
  441. // | f12 f22 f32 f42 |   | 0  1  0  y |   | f12 f22 f32 f12*x+f22*y+f32*z+f42 |
  442. // | f13 f23 f33 f43 | * | 0  0  1  z | = | f13 f23 f33 f13*x+f23*y+f33*z+f43 |
  443. // | 0   0   0   1   |   | 0  0  0  1 |   | 0   0   0   1                     |
  444. f41 = f11*x+f21*y+f31*z+f41;
  445. f42 = f12*x+f22*y+f32*z+f42;
  446. f43 = f13*x+f23*y+f33*z+f43;
  447. }
  448. void Translate(const float *pf) { Translate(pf[0], pf[1], pf[2]); }
  450. // Scale functions
  451. void ScaleMatrix(const float x, const float y, const float z)
  452. {
  453. // | x  0  0  0 |
  454. // | 0  y  0  0 |
  455. // | 0  0  z  0 |
  456. // | 0  0  0  1 |
  457. f12 = f13 = f14 = f21 = f23 = f24 = f31 = f32 = f34 = f41 = f42 = f43 = 0;
  458. f11 = x; f22 = y; f33 = z; f44 = 1;
  459. }
  460. void ScaleMatrix(const float *pf) { ScaleMatrix(pf[0], pf[1], pf[2]); }
  461. void Scale(const float x, const float y, const float z)
  462. {
  463. // 9 muls
  464. // | f11 f21 f31 f41 |   | x  0  0  0 |   | f11*x f21*y f31*z f41 |
  465. // | f12 f22 f32 f42 |   | 0  y  0  0 |   | f12*x f22*y f32*z f42 |
  466. // | f13 f23 f33 f43 | * | 0  0  z  0 | = | f13*x f23*y f33*z f43 |
  467. // | 0   0   0   1   |   | 0  0  0  1 |   | 0     0     0     1   |
  468. f11 *= x; f21 *= y; f31 *= z;
  469. f12 *= x; f22 *= y; f32 *= z;
  470. f13 *= x; f23 *= y; f33 *= z;
  471. }
  472. void Scale(const float *pf) { Scale(pf[0], pf[1], pf[2]); }
  474. // Rotate functions
  475. void RotateXMatrix(const float fRadians)
  476. {
  477. // | 1 0    0     0 |
  478. // | 0 fCos -fSin 0 |
  479. // | 0 fSin fCos  0 |
  480. // | 0 0    0     1 |
  481. f12 = f13 = f14 = f21 = f24 = f31 = f34 = f41 = f42 = f43 = 0;
  482. f11 = f44 = 1;
  484. float fCos = cosf(fRadians);
  485. float fSin = sinf(fRadians);
  486. f22 = f33 = fCos;
  487. f23 = fSin;
  488. f32 = -fSin;
  489. }
  490. void RotateX(const float fRadians)
  491. {
  492. // 12 muls, 6 adds, 2 trig function calls
  493. // | f11 f21 f31 f41 |   | 1 0    0     0 |   | f11 f21*fCos+f31*fSin f31*fCos-f21*fSin f41 |
  494. // | f12 f22 f32 f42 |   | 0 fCos -fSin 0 |   | f12 f22*fCos+f32*fSin f32*fCos-f22*fSin f42 |
  495. // | f13 f23 f33 f43 | * | 0 fSin fCos  0 | = | f13 f23*fCos+f33*fSin f33*fCos-f23*fSin f43 |
  496. // | 0   0   0   1   |   | 0 0    0     1 |   | 0   0                 0                 1   |
  497. float fTemp, fCos, fSin;
  498. fCos = cosf(fRadians);
  499. fSin = sinf(fRadians);
  500. fTemp = f21*fCos+f31*fSin;
  501. f31 = f31*fCos-f21*fSin;
  502. f21 = fTemp;
  503. fTemp = f22*fCos+f32*fSin;
  504. f32 = f32*fCos-f22*fSin;
  505. f22 = fTemp;
  506. fTemp = f23*fCos+f33*fSin;
  507. f33 = f33*fCos-f23*fSin;
  508. f23 = fTemp;
  509. }
  510. void RotateYMatrix(const float fRadians)
  511. {
  512. // | fCos  0 fSin  0 |
  513. // | 0     1 0     0 |
  514. // | -fSin 0 fCos  0 |
  515. // | 0     0 0     1 |
  516. f12 = f14 = f21 = f23 = f24 = f32 = f34 = f41 = f42 = f43 = 0;
  517. f22 = f44 = 1;
  519. float fCos = cosf(fRadians);
  520. float fSin = sinf(fRadians);
  521. f11 = f33 = fCos;
  522. f13 = -fSin;
  523. f31 = fSin;
  524. }
  525. void RotateY(const float fRadians)
  526. {
  527. // 12 muls, 6 adds, 2 trig function calls
  528. // | f11 f21 f31 f41 |   | fCos  0 fSin  0 |   | f11*fCos-f31*fSin f21 f11*fSin+f31*fCos f41 |
  529. // | f12 f22 f32 f42 |   | 0     1 0     0 |   | f12*fCos-f32*fSin f22 f12*fSin+f32*fCos f42 |
  530. // | f13 f23 f33 f43 | * | -fSin 0 fCos  0 | = | f13*fCos-f33*fSin f23 f13*fSin+f33*fCos f43 |
  531. // | 0   0   0   1   |   | 0     0 0     1 |   | 0                 0   0                 1   |
  532. float fTemp, fCos, fSin;
  533. fCos = cosf(fRadians);
  534. fSin = sinf(fRadians);
  535. fTemp = f11*fCos-f31*fSin;
  536. f31 = f11*fSin+f31*fCos;
  537. f11 = fTemp;
  538. fTemp = f12*fCos-f32*fSin;
  539. f32 = f12*fSin+f32*fCos;
  540. f12 = fTemp;
  541. fTemp = f13*fCos-f33*fSin;
  542. f33 = f13*fSin+f33*fCos;
  543. f13 = fTemp;
  544. }
  545. void RotateZMatrix(const float fRadians)
  546. {
  547. // | fCos -fSin 0 0 |
  548. // | fSin fCos  0 0 |
  549. // | 0    0     1 0 |
  550. // | 0    0     0 1 |
  551. f13 = f14 = f23 = f24 = f31 = f32 = f34 = f41 = f42 = f43 = 0;
  552. f33 = f44 = 1;
  554. float fCos = cosf(fRadians);
  555. float fSin = sinf(fRadians);
  556. f11 = f22 = fCos;
  557. f12 = fSin;
  558. f21 = -fSin;
  559. }
  560. void RotateZ(const float fRadians)
  561. {
  562. // 12 muls, 6 adds, 2 trig function calls
  563. // | f11 f21 f31 f41 |   | fCos -fSin 0 0 |   | f11*fCos+f21*fSin f21*fCos-f11*fSin f31 f41 |
  564. // | f12 f22 f32 f42 |   | fSin fCos  0 0 |   | f12*fCos+f22*fSin f22*fCos-f12*fSin f32 f42 |
  565. // | f13 f23 f33 f43 | * | 0    0     1 0 | = | f13*fCos+f23*fSin f23*fCos-f13*fSin f33 f43 |
  566. // | 0   0   0   1   |   | 0    0     0 1 |   | 0                 0                 0   1   |
  567. float fTemp, fCos, fSin;
  568. fCos = cosf(fRadians);
  569. fSin = sinf(fRadians);
  570. fTemp = f11*fCos+f21*fSin;
  571. f21 = f21*fCos-f11*fSin;
  572. f11 = fTemp;
  573. fTemp = f12*fCos+f22*fSin;
  574. f22 = f22*fCos-f12*fSin;
  575. f12 = fTemp;
  576. fTemp = f13*fCos+f23*fSin;
  577. f23 = f23*fCos-f13*fSin;
  578. f13 = fTemp;
  579. }
  580. void RotateMatrix(const CVector &v, const float f)
  581. {
  582. // 15 muls, 10 adds, 2 trig function calls
  583. float fCos = cosf(f);
  584. CVector vCos = v * (1 - fCos);
  585. CVector vSin = v * sinf(f);
  587. f14 = f24 = f34 = f41 = f42 = f43 = 0;
  588. f44 = 1;
  590. f11 = (v.x * vCos.x) + fCos;
  591. f21 = (v.x * vCos.y) - (vSin.z);
  592. f31 = (v.x * vCos.z) + (vSin.y);
  593. f12 = (v.y * vCos.x) + (vSin.z);
  594. f22 = (v.y * vCos.y) + fCos;
  595. f32 = (v.y * vCos.z) - (vSin.x);
  596. f13 = (v.z * vCos.x) - (vSin.y);
  597. f32 = (v.z * vCos.y) + (vSin.x);
  598. f33 = (v.z * vCos.z) + fCos;
  599. }
  600. void Rotate(const CVector &v, const float f)
  601. {
  602. // 51 muls, 37 adds, 2 trig function calls
  603. CMatrix mat;
  604. mat.RotateMatrix(v, f);
  605. *this *= mat;
  606. }
  608. void ModelMatrix(const CQuaternion &q, const CVector &vFrom)
  609. {
  610. *this = q;
  611. f41 = vFrom.x;
  612. f42 = vFrom.y;
  613. f43 = vFrom.z;
  614. }
  615. void ModelMatrix(const CVector &vFrom, const CVector &vView, const CVector &vUp, const CVector &vRight)
  616. {
  617. f11 = vRight.x; f21 = vUp.x; f31 = -vView.x; f41 = vFrom.x;
  618. f12 = vRight.y; f22 = vUp.y; f32 = -vView.y; f42 = vFrom.y;
  619. f13 = vRight.z; f23 = vUp.z; f33 = -vView.z; f43 = vFrom.z;
  620. f14 = 0; f24 = 0; f34 = 0; f44 = 1;
  621. }
  622. void ModelMatrix(const CVector &vFrom, const CVector &vAt, const CVector &vUp)
  623. {
  624. CVector vView = vAt - vFrom;
  625. vView.Normalize();
  626. CVector vRight = vView ^ vUp;
  627. vRight.Normalize();
  628. CVector vTrueUp = vRight ^ vView;
  629. vTrueUp.Normalize();
  630. ModelMatrix(vFrom, vView, vTrueUp, vRight);
  631. }
  633. void ViewMatrix(const CQuaternion &q, const CVector &vFrom)
  634. {
  635. *this = q;
  636. Transpose();
  637. f41 = -(vFrom.x*f11 + vFrom.y*f21 + vFrom.z*f31);
  638. f42 = -(vFrom.x*f12 + vFrom.y*f22 + vFrom.z*f32);
  639. f43 = -(vFrom.x*f13 + vFrom.y*f23 + vFrom.z*f33);
  640. }
  641. void ViewMatrix(const CVector &vFrom, const CVector &vView, const CVector &vUp, const CVector &vRight)
  642. {
  643. // 9 muls, 9 adds
  644. f11 = vRight.x; f21 = vRight.y; f31 = vRight.z; f41 = -(vFrom | vRight);
  645. f12 = vUp.x; f22 = vUp.y; f32 = vUp.z; f42 = -(vFrom | vUp);
  646. f13 = -vView.x; f23 = -vView.y; f33 = -vView.z; f43 = -(vFrom | -vView);
  647. f14 = 0; f24 = 0; f34 = 0; f44 = 1;
  648. }
  649. void ViewMatrix(const CVector &vFrom, const CVector &vAt, const CVector &vUp)
  650. {
  651. CVector vView = vAt - vFrom;
  652. vView.Normalize();
  653. CVector vRight = vView ^ vUp;
  654. vRight.Normalize();
  655. CVector vTrueUp = vRight ^ vView;
  656. vTrueUp.Normalize();
  657. ViewMatrix(vFrom, vView, vTrueUp, vRight);
  658. }
  660. void ProjectionMatrix(const float fNear, const float fFar, const float fFOV, const float fAspect)
  661. {
  662. // 2 muls, 3 divs, 2 adds, 1 trig function call
  663. float h = 1.0f / tanf(DEGTORAD(fFOV * 0.5f));
  664. float Q = fFar / (fFar - fNear);
  665. f12 = f13 = f14 = f21 = f23 = f24 = f31 = f32 = f41 = f42 = f44 = 0;
  666. f11 = h / fAspect;
  667. f22 = h;
  668. f33 = Q;
  669. f34 = 1;
  670. f43 = -Q*fNear;
  671. }
  673. // For orthogonal matrices, I belive this also gives you the inverse.
  674. void Transpose()
  675. {
  676. float f;
  677. SWAP(f12, f21, f);
  678. SWAP(f13, f31, f);
  679. SWAP(f14, f41, f);
  680. SWAP(f23, f32, f);
  681. SWAP(f24, f42, f);
  682. SWAP(f34, f43, f);
  683. }
  684. };
  687. class CRay
  688. {
  689. public:
  690. CDoubleVector m_vOrigin;
  691. CDoubleVector m_vDirection;
  693. CRay() {}
  694. CRay(CDoubleVector p1, CDoubleVector p2) { Init(p1, p2); }
  695. void Init(CDoubleVector p1, CDoubleVector p2)
  696. {
  697. m_vOrigin = p1;
  698. m_vDirection = p2 - p1;
  699. m_vDirection.Normalize();
  700. }
  702. bool Intersect(CDoubleVector vCenter, double dRadius)
  703. {
  704. CDoubleVector vDir = vCenter - m_vOrigin;
  705. double v = m_vDirection | vDir;
  706. double b2 = (vDir|vDir) - v*v;
  707. double r2 = dRadius * dRadius;
  708. if(b2 > r2)
  709. return false;
  710. //vIntersection = m_vOrigin + m_vDirection * (v - sqrtf(r2 - b2));
  711. return true;
  712. }
  713. };
  715. /*******************************************************************************
  716. * Class: CLine
  717. ********************************************************************************
  718. * This class implements a 3-dimensional line. It is initialized with two points
  719. * on the line. It can be used to find the shortest distance between two lines or
  720. * between a point and a line, which can be useful for things like collision
  721. * detection.
  722. *******************************************************************************/
  723. class CLine
  724. {
  725. public:
  726. CVector m_vStart;
  727. CVector m_vDir;
  729. CLine() {}
  730. CLine(CVector &p1, CVector &p2) { Init(p1, p2); }
  731. void Init(CVector &p1, CVector &p2)
  732. {
  733. m_vStart = p1;
  734. m_vDir = p2 - p1;
  735. m_vDir.Normalize();
  736. }
  738. CVector ClosestPoint(CVector &p) { return m_vStart + (m_vDir * ((m_vDir | p) - (m_vDir | m_vStart))); }
  739. float Distance(CVector &p) { return p.Distance(ClosestPoint(p)); }
  740. float Distance(CLine &l)
  741. {
  742. CVector v = m_vDir ^ l.m_vDir;
  743. v.Normalize();
  744. return Abs((m_vStart - l.m_vStart) | v);
  745. }
  746. /*
  747. // Calculate the shortest distance between a point to a line
  748. (known) point p = p, or (px, py, pz)
  749. (known) point on line = a, or (ax, ay, az)
  750. (known) direction vector of line = n, or (nx, ny, nz)
  751. (unknown) point on line closest to p = P, or (Px, Py, Pz)
  753. // The vector from p to P must be perpendicular to n, which gives us:
  754. (px-Px, py-Py, pz-Pz) . (nx, ny, nz) = 0
  755. // To make sure P is actually on the line, it must also fit this line equation:
  756. (ax, ay, az) + k * (nx, ny, nz) = (Px, Py, Pz)
  758. // Expanding those equations gives us this:
  759. nx * (px - Px) + ny * (py - Py) + nz * (pz - Pz) = 0
  760. // and these:
  761. Px = ax + k * nx
  762. Py = ay + k * ny
  763. Pz = az + k * nz
  765. // Substituting and solving for k gives us:
  766. nx * (px - (ax + k * nx)) + ny * (py - (ay + k * ny)) + nz * (pz - (az + k * nz)) = 0
  767. nx*px - nx*ax - k*nx2 + ny*py - ny*ay - k*ny2 + nz*pz - nz*az - k*nz2 = 0
  768. k * (nx2 + ny2 + nz2) = nx*px - nx*ax + ny*py - ny*ay + nz*pz - nz*az
  769. k = (nx*px + ny*py + nz*pz - nx*ax - ny*ay - nz*az) / (nx2 + ny2 + nz2)
  770. k = (n.p - n.a) / (n.n)
  772. // If n is normalized then n.n will always equal 1, so...
  773. P = a + (n.p - n.a) * n
  774. distance = | P - p |
  775. */
  777. /*
  778. // Calculate the shortest distance between two lines (call them line A and line B)
  779. (known) point on A = AP, or (APx, APy, APz)
  780. (known) direction vector of A = AN, or (ANx, ANy, ANz)
  781. (known) point on B = BP, or (BPx, BPy, BPz)
  782. (known) direction vector of B = BN, or (BNx, BNy, BNz)
  783. (unknown) point on A closest to B = P1, or (P1x, P1y, P1z)
  784. (unknown) point on B closest to A = P2, or (P2x, P2y, P2z)
  786. // The vector from P1 to P2 is perpendicular to both lines:
  787. (P2x - P1x, P2y - P1y, P2z - P1z) . (ANx, ANy, ANz) = 0
  788. (P2x - P1x, P2y - P1y, P2z - P1z) . (BNx, BNy, BNz) = 0
  789. // To find P1 and P2, we need to find values k and l for the line equations:
  790. (APx, APy, APz) + k * (ANx, ANy, ANz) = (P1x, P1y, P1z)
  791. (BPx, BPy, BPz) + l * (BNx, BNy, BNz) = (P2x, P2y, P2z)
  793. // Expanding these equations gives us these:
  794. ANx * (P2x - P1x) + ANy * (P2y - P1y) + ANz * (P2z - P1z) = 0
  795. BNx * (P2x - P1x) + BNy * (P2y - P1y) + BNz * (P2z - P1z) = 0
  796. // And these:
  797. P1x = APx + k * ANx
  798. P1y = APy + k * ANy
  799. P1z = APz + k * ANz
  800. P2x = BPx + l * BNx
  801. P2y = BPy + l * BNy
  802. P2z = BPz + l * BNz
  804. // Substituting and solving for k and l gives us:
  805. ANx * ((BPx + l * BNx) - (APx + k * ANx)) + ANy * ((BPy + l * BNy) - (APy + k * ANy)) + ANz * ((BPz + l * BNz) - (APz + k * ANz)) = 0
  806. BNx * ((BPx + l * BNx) - (APx + k * ANx)) + BNy * ((BPy + l * BNy) - (APy + k * ANy)) + BNz * ((BPz + l * BNz) - (APz + k * ANz)) = 0
  808. (ANx*BPx + l*ANx*BNx - ANx*APx - k*ANx2) + (ANy*BPy + l*ANy*BNy - ANy*APy - k*ANy2) + (ANz*BPz + l*ANz*BNz - ANz*APz - k*ANz2) = 0
  809. (BNx*BPx + l*BNx2 - BNx*APx - k*ANx*BNx) + (BNy*BPy + l*BNy2 - BNy*APy - k*ANy*BNy) + (BNz*BPz + l*BNz2 - BNz*APz - k*ANz*BNz) = 0
  811. k = (ANx*BPx + l*ANx*BNx - ANx*APx + ANy*BPy + l*ANy*BNy - ANy*APy + ANz*BPz + l*ANz*BNz - ANz*APz) / (ANx2 + ANy2 + ANz2)
  812. k = (BNx*BPx + l*BNx2 - BNx*APx + BNy*BPy + l*BNy2 - BNy*APy + BNz*BPz + l*BNz2 - BNz*APz) / (ANx*BNx + ANy*BNy + ANz*BNz)
  814. (ANx*BNx + ANy*BNy + ANz*BNz) * (ANx*BPx + l*ANx*BNx - ANx*APx + ANy*BPy + l*ANy*BNy - ANy*APy + ANz*BPz + l*ANz*BNz - ANz*APz)  = (ANx2 + ANy2 + ANz2) * (BNx*BPx + l*BNx2 - BNx*APx + BNy*BPy + l*BNy2 - BNy*APy + BNz*BPz + l*BNz2 - BNz*APz)
  816. (ANx*BNx*ANy*BPy + ANx*BNx*l*ANy*BNy - ANx*BNx*ANy*APy + ANx*BNx*ANz*BPz + ANx*BNx*l*ANz*BNz - ANx*BNx*ANz*APz) + 
  817. (ANy*BNy*ANx*BPx + ANy*BNy*l*ANx*BNx - ANy*BNy*ANx*APx + ANy*BNy*ANz*BPz + ANy*BNy*l*ANz*BNz - ANy*BNy*ANz*APz) +
  818. (ANz*BNz*ANx*BPx + ANz*BNz*l*ANx*BNx - ANz*BNz*ANx*APx + ANz*BNz*ANy*BPy + ANz*BNz*l*ANy*BNy - ANz*BNz*ANy*APy) =
  819. (ANx2*BNy*BPy + ANx2*l*BNy2 - ANx2*BNy*APy + ANx2*BNz*BPz + ANx2*l*BNz2 - ANx2*BNz*APz) +
  820. (ANy2*BNx*BPx + ANy2*l*BNx2 - ANy2*BNx*APx + ANy2*BNz*BPz + ANy2*l*BNz2 - ANy2*BNz*APz) +
  821. (ANz2*BNx*BPx + ANz2*l*BNx2 - ANz2*BNx*APx + ANz2*BNy*BPy + ANz2*l*BNy2 - ANz2*BNy*APy)
  823. l * (2*ANx*BNx*ANy*BNy + 2*ANz*BNz*ANx*BNx + 2*ANy*BNy*ANz*BNz - ANx2*BNy2 - ANy2*BNx2 - ANz2*BNx2 - ANx2*BNz2 - ANy2*BNz2 - ANz2*BNy2) = 
  824. (ANx2*BNy*BPy - ANx2*BNy*APy + ANx2*BNz*BPz - ANx2*BNz*APz) +
  825. (ANy2*BNx*BPx - ANy2*BNx*APx + ANy2*BNz*BPz - ANy2*BNz*APz) +
  826. (ANz2*BNx*BPx - ANz2*BNx*APx + ANz2*BNy*BPy - ANz2*BNy*APy) +
  827. (-ANx*BNx*ANy*BPy + ANx*BNx*ANy*APy - ANx*BNx*ANz*BPz + ANx*BNx*ANz*APz) +
  828. (-ANy*BNy*ANx*BPx + ANy*BNy*ANx*APx - ANy*BNy*ANz*BPz + ANy*BNy*ANz*APz) +
  829. (-ANz*BNz*ANx*BPx + ANz*BNz*ANx*APx - ANz*BNz*ANy*BPy + ANz*BNz*ANy*APy)
  831. // Next think about using AN ^ BN to get the direction vector between P1 and P2
  832. // Normalize that vector and call it n
  833. // The distance between the two lines might be the absolute value of (P2-P1).n
  834. // That still doesn't tell us where the closest points on the line are, but it might help find them
  835. */
  836. };
  839. /*******************************************************************************
  840. * Class: CPlane
  841. ********************************************************************************
  842. * This class implements a 3-dimensional plane equation. It can be initialized
  843. * with 3 points on the plane or a normal and a point on the plane, and it can
  844. * be used to find the distance from a point to a plane. I plan to add more to
  845. * this class later to make it more useful.
  846. *******************************************************************************/
  847. class CPlane
  848. {
  849. public:
  850. CVector m_vNormal;
  851. float D;
  853. CPlane() {}
  854. void Init(CVector &p1, CVector &p2, CVector &p3)
  855. { // Initializes the plane based on three points in the plane
  856. Init(NormalVector(p1, p2, p3), p1);
  857. }
  858. void Init(CVector &vNormal, CVector &p)
  859. { // Initializes the plane based on a normal and a point in the plane
  860. m_vNormal = vNormal;
  861. D = -(p | m_vNormal);
  862. }
  864. bool operator==(CPlane &p) { return (Abs(D - p.D) <= DELTA && m_vNormal == p.m_vNormal); }
  865. bool operator!=(CPlane &p) { return !(*this == p); }
  867. float Distance(CVector &p)
  868. { // Returns the distance between the plane and point p
  869. return (m_vNormal | p) + D; // A positive, 0, or negative result indicates the point is in front of, on, or behind the plane
  870. }
  872. bool Intersection(CVector &vPos, CVector &vDir)
  873. { // Returns true if the line intersects the plane and changes vPos to the location of the intersection
  874. float f = m_vNormal | vDir;
  875. if(ABS(f) < DELTA)
  876. return false;
  877. vPos -= vDir * (Distance(vPos) / f);
  878. return true;
  879. }
  880. };
  882. /****************************************************************************
  883. * Class: C3DObject
  884. *****************************************************************************
  885. * This class represents a basic 3D object in the scene. It has a 3D position,
  886. * orientation, velocity, and a parent which provides its frame of reference
  887. * in the scene.
  888. * Note: This class is derived from CQuaternion so it will inherit useful
  889. *       functions like Rotate(), GetViewAxis(), GetUpAxis(), and GetRightAxis().
  890. ****************************************************************************/
  891. #define MIN_DISTANCE 0.01
  892. #define MAX_DISTANCE 1000.0 // Distance to desired far clipping plane
  893. #define MAX_DISCERNABLE 1000000.0 // Beyond this distance, everything is rendered at MAX_DISTANCE
  894. #define HALF_MAX (MAX_DISTANCE*0.5) // Everything between HALF_MAX and MAX_DISCERNABLE is scaled exponentially between HALF_MAX and MAX_DISTANCE
  895. class C3DObject : public CQuaternion
  896. {
  897. protected:
  898. C3DObject *m_pParent; // The object's parent
  899. float m_fBoundingRadius; // The object's bounding radius
  900. float m_fMass; // The object's mass (kg)
  901. CDoubleVector m_vPosition; // The object's position (km)
  902. CVector m_vVelocity; // The object's velocity (km/s)
  904. public:
  905. C3DObject() : CQuaternion(0.0f, 0.0f, 0.0f, 1.0f), m_vPosition(0.0f), m_vVelocity(0.0f)
  906. {
  907. m_fMass = 0.0f;
  908. }
  909. C3DObject(const CMatrix &m) : CQuaternion(m), m_vPosition(m.f41, m.f42, m.f43), m_vVelocity(0.0f)
  910. {
  911. m_fMass = 0.0f;
  912. }
  914. void operator=(const CQuaternion &q) { CQuaternion::operator=(q); }
  915. void operator=(const CMatrix &m)
  916. {
  917. CQuaternion::operator=(m);
  918. SetPosition(CDoubleVector(m.f41, m.f42, m.f43));
  919. }
  921. void SetParent(C3DObject *p) { m_pParent = p; }
  922. C3DObject *GetParent() { return m_pParent; }
  923. void SetMass(float f) { m_fMass = f; }
  924. float GetMass() { return m_fMass; }
  925. void SetPosition(CDoubleVector &v) { m_vPosition = v; }
  926. CDoubleVector GetPosition() { return m_vPosition; }
  927. void SetVelocity(CVector &v) { m_vVelocity = v; }
  928. CVector GetVelocity() { return m_vVelocity; }
  930. CMatrix GetViewMatrix()
  931. {
  932. // Don't use the normal view matrix because it causes precision problems if the camera is too far away from the origin.
  933. // Instead, pretend the camera is at the origin and offset all model matrices by subtracting the camera's position.
  934. CMatrix m = *this;
  935. m.Transpose();
  936. return m;
  937. }
  938. CMatrix GetModelMatrix(C3DObject *pCamera)
  939. {
  940. // Don't use the normal model matrix because it causes precision problems if the camera and model are too far away from the origin.
  941. // Instead, pretend the camera is at the origin and offset all model matrices by subtracting the camera's position.
  942. CMatrix m;
  943. m.ModelMatrix(*this, m_vPosition-pCamera->m_vPosition);
  944. return m;
  945. }
  947. static float GetScalingFactor(double dDistance, double dFactor=1.0)
  948. {
  949. if(dDistance > HALF_MAX)
  950. {
  951. dFactor *= (dDistance >= MAX_DISCERNABLE) ? MAX_DISTANCE : HALF_MAX + HALF_MAX * (1.0 - exp(-2.5 * dDistance / MAX_DISCERNABLE));
  952. dFactor /= dDistance;
  953. }
  954. return (float)dFactor;
  955. }
  957. float ScaleModelMatrix(CMatrix &m, double dDistance, double dFactor=1.0)
  958. {
  959. // This code scales the object's size and distance to the camera down when it's too far away.
  960. // This solves a problem with many video card drivers where objects too far away aren't rendering properly.
  961. // It also alleviates the Z-buffer precision problem caused by having your near and far clipping planes too far apart.
  962. float fFactor = GetScalingFactor(dDistance, dFactor);
  963. if(fFactor <= 1.0f)
  964. {
  965. m.f41 *= fFactor;
  966. m.f42 *= fFactor;
  967. m.f43 *= fFactor;
  968. m.Scale(fFactor, fFactor, fFactor);
  969. }
  970. return fFactor;
  971. }
  973. float GetScaledModelMatrix(CMatrix &m, C3DObject *pCamera, double dFactor=1.0)
  974. {
  975. CDoubleVector vPos = m_vPosition - pCamera->m_vPosition;
  976. double dDistance = vPos.Magnitude();
  978. m.ModelMatrix(*this, vPos);
  979. return ScaleModelMatrix(m, dDistance, dFactor);
  980. }
  982. void GetBillboardMatrix(CMatrix &m, C3DObject *pCamera, float fSize)
  983. {
  984. CDoubleVector vPos = m_vPosition - pCamera->m_vPosition;
  985. double dDistance = vPos.Magnitude();
  987. CVector vView = vPos / dDistance;
  988. CVector vRight = vView ^ CVector(0, 1, 0);
  989. vRight.Normalize();
  990. CVector vUp = vRight ^ vView;
  991. vUp.Normalize();
  993. m.ModelMatrix(vPos, vView, vUp, vRight);
  994. m.Scale(fSize, fSize, fSize);
  995. }
  997. float GetScaledBillboardMatrix(CMatrix &m, C3DObject *pCamera, float fSize, double dFactor=1.0)
  998. {
  999. CDoubleVector vPos = m_vPosition - pCamera->m_vPosition;
  1000. double dDistance = vPos.Magnitude();
  1002. CVector vView = vPos / dDistance;
  1003. CVector vRight = vView ^ CVector(0, 1, 0);
  1004. vRight.Normalize();
  1005. CVector vUp = vRight ^ vView;
  1006. vUp.Normalize();
  1008. m.ModelMatrix(vPos, vView, vUp, vRight);
  1009. float fFactor = ScaleModelMatrix(m, dDistance, dFactor);
  1010. m.Scale(fSize, fSize, fSize);
  1011. return fFactor;
  1012. }
  1014. float DistanceTo(C3DObject &obj) { return (float)m_vPosition.Distance(obj.m_vPosition); }
  1015. CVector VectorTo(C3DObject &obj) { return obj.m_vPosition - m_vPosition; }
  1016. float GravityPull(float fDistSquared) { return (GRAVCONST * m_fMass) / fDistSquared; }
  1017. CVector GravityVector(C3DObject &obj)
  1018. {
  1019. CVector vGravity = obj.VectorTo(*this);
  1020. float fDistSquared = vGravity.MagnitudeSquared();
  1021. vGravity *= GravityPull(fDistSquared) / sqrtf(fDistSquared);
  1022. return vGravity;
  1023. }
  1025. void Accelerate(CVector &vAccel, float fSeconds, float fResistance=0)
  1026. {
  1027. m_vVelocity += vAccel * fSeconds;
  1028. if(fResistance > DELTA)
  1029. m_vVelocity *= 1.0f - fResistance * fSeconds;
  1030. m_vPosition += m_vVelocity * fSeconds;
  1031. }
  1033. // Kinetic energy (Joules) = 1/2 * mass * velocity^2 (mass in kg, velocity in m/s)
  1034. // Kinetic energy (kilotons) = (KE in Joules) / (4.185e12 joules/KT)
  1035. //float GetKEJoules(C3DObject &obj) { return 500000.0f * m_fMass * (m_vVelocity-obj.m_vVelocity).MagnitudeSquared(); }
  1036. //float GetKEKilotons(C3DObject &obj) { return 1.19474e-7f * m_fMass * (m_vVelocity-obj.m_vVelocity).MagnitudeSquared(); }
  1037. };
  1039. #define COLOR_CTOF(x) (x/256.0f)
  1040. #define COLOR_FTOC(x) (ColorClamp(x*256))
  1042. inline unsigned char ColorClamp(int n) { return (unsigned char)(n < 0 ? 0 : n > 255 ? 255 : n); }
  1043. inline unsigned char ColorClamp(float f) { return (unsigned char)(f < 0 ? 0 : f > 255 ? 255 : f); }
  1045. class CColor
  1046. {
  1047. public:
  1048. unsigned char r, g, b, a;
  1050. CColor() {}
  1051. CColor(int r, int g, int b, int a=255)
  1052. {
  1053. this->r = r;
  1054. this->g = g;
  1055. this->b = b;
  1056. this->a = a;
  1057. }
  1058. CColor(float r, float g, float b, float a=1.0f)
  1059. {
  1060. this->r = COLOR_FTOC(r);
  1061. this->g = COLOR_FTOC(g);
  1062. this->b = COLOR_FTOC(b);
  1063. this->a = COLOR_FTOC(a);
  1064. }
  1066. CColor operator*(const float f) const { return CColor(ColorClamp(r*f), ColorClamp(g*f), ColorClamp(b*f), ColorClamp(a*f)); }
  1067. CColor operator+(const CColor c) const { return CColor(ColorClamp(r+c.r), ColorClamp(g+c.g), ColorClamp(b+c.b), ColorClamp(a+c.a)); }
  1068. operator unsigned char*() { return &r; }
  1069. };
  1071. #endif //__Matrix_h__