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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
m3math.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：15k
源码类别：

游戏引擎

开发平台：

C++ Builder

m3math.cpp：源码内容
  1. /** 
  2.  * @file m3math.cpp
  3.  * @brief LLMatrix3 class implementation.
  4.  *
  5.  * $LicenseInfo:firstyear=2000&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2000-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "linden_common.h"
  35. //#include "vmath.h"
  36. #include "v3math.h"
  37. #include "v3dmath.h"
  38. #include "v4math.h"
  39. #include "m4math.h"
  40. #include "m3math.h"
  41. #include "llquaternion.h"
  43. // LLMatrix3
  45. //              ji  
  46. // LLMatrix3 = |00 01 02 |
  47. //             |10 11 12 |
  48. //             |20 21 22 |
  50. // LLMatrix3 = |fx fy fz |  forward-axis
  51. //             |lx ly lz |  left-axis
  52. //             |ux uy uz |  up-axis
  55. // Constructors
  58. LLMatrix3::LLMatrix3(const LLQuaternion &q)
  59. {
  60. setRot(q);
  61. }
  64. LLMatrix3::LLMatrix3(const F32 angle, const LLVector3 &vec)
  65. {
  66. LLQuaternion quat(angle, vec);
  67. setRot(quat);
  68. }
  70. LLMatrix3::LLMatrix3(const F32 angle, const LLVector3d &vec)
  71. {
  72. LLVector3 vec_f;
  73. vec_f.setVec(vec);
  74. LLQuaternion quat(angle, vec_f);
  75. setRot(quat);
  76. }
  78. LLMatrix3::LLMatrix3(const F32 angle, const LLVector4 &vec)
  79. {
  80. LLQuaternion quat(angle, vec);
  81. setRot(quat);
  82. }
  84. LLMatrix3::LLMatrix3(const F32 angle, const F32 x, const F32 y, const F32 z)
  85. {
  86. LLVector3 vec(x, y, z);
  87. LLQuaternion quat(angle, vec);
  88. setRot(quat);
  89. }
  91. LLMatrix3::LLMatrix3(const F32 roll, const F32 pitch, const F32 yaw)
  92. {
  93. setRot(roll,pitch,yaw);
  94. }
  96. // From Matrix and Quaternion FAQ
  97. void LLMatrix3::getEulerAngles(F32 *roll, F32 *pitch, F32 *yaw) const
  98. {
  99. F64 angle_x, angle_y, angle_z;
  100. F64 cx, cy, cz; // cosine of angle_x, angle_y, angle_z
  101. F64 sx,     sz; // sine of angle_x, angle_y, angle_z
  103. angle_y = asin(llclamp(mMatrix[2][0], -1.f, 1.f));
  104. cy = cos(angle_y);
  106. if (fabs(cy) > 0.005) // non-zero
  107. {
  108. // no gimbal lock
  109. cx = mMatrix[2][2] / cy;
  110. sx = - mMatrix[2][1] / cy;
  112. angle_x = (F32) atan2(sx, cx);
  114. cz = mMatrix[0][0] / cy;
  115. sz = - mMatrix[1][0] / cy;
  117. angle_z = (F32) atan2(sz, cz);
  118. }
  119. else
  120. {
  121. // yup, gimbal lock
  122. angle_x = 0;
  124. // some tricky math thereby avoided, see article
  126. cz = mMatrix[1][1];
  127. sz = mMatrix[0][1];
  129. angle_z = atan2(sz, cz);
  130. }
  132. *roll = (F32)angle_x;
  133. *pitch = (F32)angle_y;
  134. *yaw = (F32)angle_z;
  135. }
  138. // Clear and Assignment Functions
  140. const LLMatrix3& LLMatrix3::setIdentity()
  141. {
  142. mMatrix[0][0] = 1.f;
  143. mMatrix[0][1] = 0.f;
  144. mMatrix[0][2] = 0.f;
  146. mMatrix[1][0] = 0.f;
  147. mMatrix[1][1] = 1.f;
  148. mMatrix[1][2] = 0.f;
  150. mMatrix[2][0] = 0.f;
  151. mMatrix[2][1] = 0.f;
  152. mMatrix[2][2] = 1.f;
  153. return (*this);
  154. }
  156. const LLMatrix3& LLMatrix3::clear()
  157. {
  158. mMatrix[0][0] = 0.f;
  159. mMatrix[0][1] = 0.f;
  160. mMatrix[0][2] = 0.f;
  162. mMatrix[1][0] = 0.f;
  163. mMatrix[1][1] = 0.f;
  164. mMatrix[1][2] = 0.f;
  166. mMatrix[2][0] = 0.f;
  167. mMatrix[2][1] = 0.f;
  168. mMatrix[2][2] = 0.f;
  169. return (*this);
  170. }
  172. const LLMatrix3& LLMatrix3::setZero()
  173. {
  174. mMatrix[0][0] = 0.f;
  175. mMatrix[0][1] = 0.f;
  176. mMatrix[0][2] = 0.f;
  178. mMatrix[1][0] = 0.f;
  179. mMatrix[1][1] = 0.f;
  180. mMatrix[1][2] = 0.f;
  182. mMatrix[2][0] = 0.f;
  183. mMatrix[2][1] = 0.f;
  184. mMatrix[2][2] = 0.f;
  185. return (*this);
  186. }
  188. // various useful mMatrix functions
  190. const LLMatrix3& LLMatrix3::transpose() 
  191. {
  192. // transpose the matrix
  193. F32 temp;
  194. temp = mMatrix[VX][VY]; mMatrix[VX][VY] = mMatrix[VY][VX]; mMatrix[VY][VX] = temp;
  195. temp = mMatrix[VX][VZ]; mMatrix[VX][VZ] = mMatrix[VZ][VX]; mMatrix[VZ][VX] = temp;
  196. temp = mMatrix[VY][VZ]; mMatrix[VY][VZ] = mMatrix[VZ][VY]; mMatrix[VZ][VY] = temp;
  197. return *this;
  198. }
  201. F32 LLMatrix3::determinant() const
  202. {
  203. // Is this a useful method when we assume the matrices are valid rotation
  204. // matrices throughout this implementation?
  205. return mMatrix[0][0] * (mMatrix[1][1] * mMatrix[2][2] - mMatrix[1][2] * mMatrix[2][1]) +
  206.    mMatrix[0][1] * (mMatrix[1][2] * mMatrix[2][0] - mMatrix[1][0] * mMatrix[2][2]) +
  207.    mMatrix[0][2] * (mMatrix[1][0] * mMatrix[2][1] - mMatrix[1][1] * mMatrix[2][0]); 
  208. }
  210. // inverts this matrix
  211. void LLMatrix3::invert()
  212. {
  213. // fails silently if determinant is zero too small
  214. F32 det = determinant();
  215. const F32 VERY_SMALL_DETERMINANT = 0.000001f;
  216. if (fabs(det) > VERY_SMALL_DETERMINANT)
  217. {
  218. // invertiable
  219. LLMatrix3 t(*this);
  220. mMatrix[VX][VX] = ( t.mMatrix[VY][VY] * t.mMatrix[VZ][VZ] - t.mMatrix[VY][VZ] * t.mMatrix[VZ][VY] ) / det;
  221. mMatrix[VY][VX] = ( t.mMatrix[VY][VZ] * t.mMatrix[VZ][VX] - t.mMatrix[VY][VX] * t.mMatrix[VZ][VZ] ) / det;
  222. mMatrix[VZ][VX] = ( t.mMatrix[VY][VX] * t.mMatrix[VZ][VY] - t.mMatrix[VY][VY] * t.mMatrix[VZ][VX] ) / det;
  223. mMatrix[VX][VY] = ( t.mMatrix[VZ][VY] * t.mMatrix[VX][VZ] - t.mMatrix[VZ][VZ] * t.mMatrix[VX][VY] ) / det;
  224. mMatrix[VY][VY] = ( t.mMatrix[VZ][VZ] * t.mMatrix[VX][VX] - t.mMatrix[VZ][VX] * t.mMatrix[VX][VZ] ) / det;
  225. mMatrix[VZ][VY] = ( t.mMatrix[VZ][VX] * t.mMatrix[VX][VY] - t.mMatrix[VZ][VY] * t.mMatrix[VX][VX] ) / det;
  226. mMatrix[VX][VZ] = ( t.mMatrix[VX][VY] * t.mMatrix[VY][VZ] - t.mMatrix[VX][VZ] * t.mMatrix[VY][VY] ) / det;
  227. mMatrix[VY][VZ] = ( t.mMatrix[VX][VZ] * t.mMatrix[VY][VX] - t.mMatrix[VX][VX] * t.mMatrix[VY][VZ] ) / det;
  228. mMatrix[VZ][VZ] = ( t.mMatrix[VX][VX] * t.mMatrix[VY][VY] - t.mMatrix[VX][VY] * t.mMatrix[VY][VX] ) / det;
  229. }
  230. }
  232. // does not assume a rotation matrix, and does not divide by determinant, assuming results will be renormalized
  233. const LLMatrix3& LLMatrix3::adjointTranspose()
  234. {
  235. LLMatrix3 adjoint_transpose;
  236. adjoint_transpose.mMatrix[VX][VX] = mMatrix[VY][VY] * mMatrix[VZ][VZ] - mMatrix[VY][VZ] * mMatrix[VZ][VY] ;
  237. adjoint_transpose.mMatrix[VY][VX] = mMatrix[VY][VZ] * mMatrix[VZ][VX] - mMatrix[VY][VX] * mMatrix[VZ][VZ] ;
  238. adjoint_transpose.mMatrix[VZ][VX] = mMatrix[VY][VX] * mMatrix[VZ][VY] - mMatrix[VY][VY] * mMatrix[VZ][VX] ;
  239. adjoint_transpose.mMatrix[VX][VY] = mMatrix[VZ][VY] * mMatrix[VX][VZ] - mMatrix[VZ][VZ] * mMatrix[VX][VY] ;
  240. adjoint_transpose.mMatrix[VY][VY] = mMatrix[VZ][VZ] * mMatrix[VX][VX] - mMatrix[VZ][VX] * mMatrix[VX][VZ] ;
  241. adjoint_transpose.mMatrix[VZ][VY] = mMatrix[VZ][VX] * mMatrix[VX][VY] - mMatrix[VZ][VY] * mMatrix[VX][VX] ;
  242. adjoint_transpose.mMatrix[VX][VZ] = mMatrix[VX][VY] * mMatrix[VY][VZ] - mMatrix[VX][VZ] * mMatrix[VY][VY] ;
  243. adjoint_transpose.mMatrix[VY][VZ] = mMatrix[VX][VZ] * mMatrix[VY][VX] - mMatrix[VX][VX] * mMatrix[VY][VZ] ;
  244. adjoint_transpose.mMatrix[VZ][VZ] = mMatrix[VX][VX] * mMatrix[VY][VY] - mMatrix[VX][VY] * mMatrix[VY][VX] ;
  246. *this = adjoint_transpose;
  247. return *this;
  248. }
  250. // SJB: This code is correct for a logicly stored (non-transposed) matrix;
  251. // Our matrices are stored transposed, OpenGL style, so this generates the
  252. // INVERSE quaternion (-x, -y, -z, w)!
  253. // Because we use similar logic in LLQuaternion::getMatrix3,
  254. // we are internally consistant so everything works OK :)
  255. LLQuaternion LLMatrix3::quaternion() const
  256. {
  257. LLQuaternion quat;
  258. F32 tr, s, q[4];
  259. U32 i, j, k;
  260. U32 nxt[3] = {1, 2, 0};
  262. tr = mMatrix[0][0] + mMatrix[1][1] + mMatrix[2][2];
  264. // check the diagonal
  265. if (tr > 0.f) 
  266. {
  267. s = (F32)sqrt (tr + 1.f);
  268. quat.mQ[VS] = s / 2.f;
  269. s = 0.5f / s;
  270. quat.mQ[VX] = (mMatrix[1][2] - mMatrix[2][1]) * s;
  271. quat.mQ[VY] = (mMatrix[2][0] - mMatrix[0][2]) * s;
  272. quat.mQ[VZ] = (mMatrix[0][1] - mMatrix[1][0]) * s;
  273. } 
  274. else
  275. {
  276. // diagonal is negative
  277. i = 0;
  278. if (mMatrix[1][1] > mMatrix[0][0]) 
  279. i = 1;
  280. if (mMatrix[2][2] > mMatrix[i][i]) 
  281. i = 2;
  283. j = nxt[i];
  284. k = nxt[j];
  287. s = (F32)sqrt ((mMatrix[i][i] - (mMatrix[j][j] + mMatrix[k][k])) + 1.f);
  289. q[i] = s * 0.5f;
  291. if (s != 0.f) 
  292. s = 0.5f / s;
  294. q[3] = (mMatrix[j][k] - mMatrix[k][j]) * s;
  295. q[j] = (mMatrix[i][j] + mMatrix[j][i]) * s;
  296. q[k] = (mMatrix[i][k] + mMatrix[k][i]) * s;
  298. quat.setQuat(q);
  299. }
  300. return quat;
  301. }
  304. // These functions take Rotation arguments
  305. const LLMatrix3& LLMatrix3::setRot(const F32 angle, const F32 x, const F32 y, const F32 z)
  306. {
  307. setRot(LLQuaternion(angle,x,y,z));
  308. return *this;
  309. }
  311. const LLMatrix3& LLMatrix3::setRot(const F32 angle, const LLVector3 &vec)
  312. {
  313. setRot(LLQuaternion(angle, vec));
  314. return *this;
  315. }
  317. const LLMatrix3& LLMatrix3::setRot(const F32 roll, const F32 pitch, const F32 yaw)
  318. {
  319. // Rotates RH about x-axis by 'roll'  then
  320. // rotates RH about the old y-axis by 'pitch' then
  321. // rotates RH about the original z-axis by 'yaw'.
  322. //                .
  323. //               /| yaw axis
  324. //                |     __.
  325. //   ._        ___|      /| pitch axis
  326. //  _||       \ |-.   /
  327. //  || ________|___/_______
  328. //   | _ _   o o o_o_o_o o   /__  ________ roll axis
  329. //   //  /_______/    /__________>         /   
  330. //  /_,-'       //   /
  331. //             /__,-'
  333. F32 cx, sx, cy, sy, cz, sz;
  334. F32 cxsy, sxsy;
  336.     cx = (F32)cos(roll); //A
  337.     sx = (F32)sin(roll); //B
  338.     cy = (F32)cos(pitch); //C
  339.     sy = (F32)sin(pitch); //D
  340.     cz = (F32)cos(yaw); //E
  341.     sz = (F32)sin(yaw); //F
  343.     cxsy = cx * sy; //AD
  344.     sxsy = sx * sy; //BD 
  346.     mMatrix[0][0] =  cy * cz;
  347.     mMatrix[1][0] = -cy * sz;
  348.     mMatrix[2][0] = sy;
  349.     mMatrix[0][1] = sxsy * cz + cx * sz;
  350.     mMatrix[1][1] = -sxsy * sz + cx * cz;
  351.     mMatrix[2][1] = -sx * cy;
  352.     mMatrix[0][2] =  -cxsy * cz + sx * sz;
  353.     mMatrix[1][2] =  cxsy * sz + sx * cz;
  354.     mMatrix[2][2] =  cx * cy;
  355. return *this;
  356. }
  359. const LLMatrix3& LLMatrix3::setRot(const LLQuaternion &q)
  360. {
  361. *this = q.getMatrix3();
  362. return *this;
  363. }
  365. const LLMatrix3& LLMatrix3::setRows(const LLVector3 &fwd, const LLVector3 &left, const LLVector3 &up)
  366. {
  367. mMatrix[0][0] = fwd.mV[0];
  368. mMatrix[0][1] = fwd.mV[1];
  369. mMatrix[0][2] = fwd.mV[2];
  371. mMatrix[1][0] = left.mV[0];
  372. mMatrix[1][1] = left.mV[1];
  373. mMatrix[1][2] = left.mV[2];
  375. mMatrix[2][0] = up.mV[0];
  376. mMatrix[2][1] = up.mV[1];
  377. mMatrix[2][2] = up.mV[2];
  379. return *this;
  380. }
  382. const LLMatrix3& LLMatrix3::setRow( U32 rowIndex, const LLVector3& row )
  383. {
  384. llassert( rowIndex >= 0 && rowIndex < NUM_VALUES_IN_MAT3 );
  386. mMatrix[rowIndex][0] = row[0];
  387. mMatrix[rowIndex][1] = row[1];
  388. mMatrix[rowIndex][2] = row[2];
  390. return *this;
  391. }
  393. const LLMatrix3& LLMatrix3::setCol( U32 colIndex, const LLVector3& col )
  394. {
  395. llassert( colIndex >= 0 && colIndex < NUM_VALUES_IN_MAT3 );
  397. mMatrix[0][colIndex] = col[0];
  398. mMatrix[1][colIndex] = col[1];
  399. mMatrix[2][colIndex] = col[2];
  401. return *this;
  402. }
  404. // Rotate exisitng mMatrix
  405. const LLMatrix3& LLMatrix3::rotate(const F32 angle, const F32 x, const F32 y, const F32 z)
  406. {
  407. LLMatrix3 mat(angle, x, y, z);
  408. *this *= mat;
  409. return *this;
  410. }
  413. const LLMatrix3& LLMatrix3::rotate(const F32 angle, const LLVector3 &vec)
  414. {
  415. LLMatrix3 mat(angle, vec);
  416. *this *= mat;
  417. return *this;
  418. }
  421. const LLMatrix3& LLMatrix3::rotate(const F32 roll, const F32 pitch, const F32 yaw)
  422. {
  423. LLMatrix3 mat(roll, pitch, yaw); 
  424. *this *= mat;
  425. return *this;
  426. }
  429. const LLMatrix3& LLMatrix3::rotate(const LLQuaternion &q)
  430. {
  431. LLMatrix3 mat(q);
  432. *this *= mat;
  433. return *this;
  434. }
  436. void LLMatrix3::add(const LLMatrix3& other_matrix)
  437. {
  438. for (S32 i = 0; i < 3; ++i)
  439. {
  440. for (S32 j = 0; j < 3; ++j)
  441. {
  442. mMatrix[i][j] += other_matrix.mMatrix[i][j];
  443. }
  444. }
  445. }
  447. LLVector3 LLMatrix3::getFwdRow() const
  448. {
  449. return LLVector3(mMatrix[VX]);
  450. }
  452. LLVector3 LLMatrix3::getLeftRow() const
  453. {
  454. return LLVector3(mMatrix[VY]);
  455. }
  457. LLVector3 LLMatrix3::getUpRow() const
  458. {
  459. return LLVector3(mMatrix[VZ]);
  460. }
  464. const LLMatrix3& LLMatrix3::orthogonalize()
  465. {
  466. LLVector3 x_axis(mMatrix[VX]);
  467. LLVector3 y_axis(mMatrix[VY]);
  468. LLVector3 z_axis(mMatrix[VZ]);
  470. x_axis.normVec();
  471. y_axis -= x_axis * (x_axis * y_axis);
  472. y_axis.normVec();
  473. z_axis = x_axis % y_axis;
  474. setRows(x_axis, y_axis, z_axis);
  475. return (*this);
  476. }
  479. // LLMatrix3 Operators
  481. LLMatrix3 operator*(const LLMatrix3 &a, const LLMatrix3 &b)
  482. {
  483. U32 i, j;
  484. LLMatrix3 mat;
  485. for (i = 0; i < NUM_VALUES_IN_MAT3; i++)
  486. {
  487. for (j = 0; j < NUM_VALUES_IN_MAT3; j++)
  488. {
  489. mat.mMatrix[j][i] = a.mMatrix[j][0] * b.mMatrix[0][i] + 
  490.     a.mMatrix[j][1] * b.mMatrix[1][i] + 
  491.     a.mMatrix[j][2] * b.mMatrix[2][i];
  492. }
  493. }
  494. return mat;
  495. }
  497. /* Not implemented to help enforce code consistency with the syntax of 
  498.    row-major notation.  This is a Good Thing.
  499. LLVector3 operator*(const LLMatrix3 &a, const LLVector3 &b)
  500. {
  501. LLVector3 vec;
  502. // matrix operates "from the left" on column vector
  503. vec.mV[VX] = a.mMatrix[VX][VX] * b.mV[VX] + 
  504.  a.mMatrix[VX][VY] * b.mV[VY] + 
  505.  a.mMatrix[VX][VZ] * b.mV[VZ];
  507. vec.mV[VY] = a.mMatrix[VY][VX] * b.mV[VX] + 
  508.  a.mMatrix[VY][VY] * b.mV[VY] + 
  509.  a.mMatrix[VY][VZ] * b.mV[VZ];
  511. vec.mV[VZ] = a.mMatrix[VZ][VX] * b.mV[VX] + 
  512.  a.mMatrix[VZ][VY] * b.mV[VY] + 
  513.  a.mMatrix[VZ][VZ] * b.mV[VZ];
  514. return vec;
  515. }
  516. */
  519. LLVector3 operator*(const LLVector3 &a, const LLMatrix3 &b)
  520. {
  521. // matrix operates "from the right" on row vector
  522. return LLVector3(
  523. a.mV[VX] * b.mMatrix[VX][VX] + 
  524. a.mV[VY] * b.mMatrix[VY][VX] + 
  525. a.mV[VZ] * b.mMatrix[VZ][VX],
  527. a.mV[VX] * b.mMatrix[VX][VY] + 
  528. a.mV[VY] * b.mMatrix[VY][VY] + 
  529. a.mV[VZ] * b.mMatrix[VZ][VY],
  531. a.mV[VX] * b.mMatrix[VX][VZ] + 
  532. a.mV[VY] * b.mMatrix[VY][VZ] + 
  533. a.mV[VZ] * b.mMatrix[VZ][VZ] );
  534. }
  536. LLVector3d operator*(const LLVector3d &a, const LLMatrix3 &b)
  537. {
  538. // matrix operates "from the right" on row vector
  539. return LLVector3d(
  540. a.mdV[VX] * b.mMatrix[VX][VX] + 
  541. a.mdV[VY] * b.mMatrix[VY][VX] + 
  542. a.mdV[VZ] * b.mMatrix[VZ][VX],
  544. a.mdV[VX] * b.mMatrix[VX][VY] + 
  545. a.mdV[VY] * b.mMatrix[VY][VY] + 
  546. a.mdV[VZ] * b.mMatrix[VZ][VY],
  548. a.mdV[VX] * b.mMatrix[VX][VZ] + 
  549. a.mdV[VY] * b.mMatrix[VY][VZ] + 
  550. a.mdV[VZ] * b.mMatrix[VZ][VZ] );
  551. }
  553. bool operator==(const LLMatrix3 &a, const LLMatrix3 &b)
  554. {
  555. U32 i, j;
  556. for (i = 0; i < NUM_VALUES_IN_MAT3; i++)
  557. {
  558. for (j = 0; j < NUM_VALUES_IN_MAT3; j++)
  559. {
  560. if (a.mMatrix[j][i] != b.mMatrix[j][i])
  561. return FALSE;
  562. }
  563. }
  564. return TRUE;
  565. }
  567. bool operator!=(const LLMatrix3 &a, const LLMatrix3 &b)
  568. {
  569. U32 i, j;
  570. for (i = 0; i < NUM_VALUES_IN_MAT3; i++)
  571. {
  572. for (j = 0; j < NUM_VALUES_IN_MAT3; j++)
  573. {
  574. if (a.mMatrix[j][i] != b.mMatrix[j][i])
  575. return TRUE;
  576. }
  577. }
  578. return FALSE;
  579. }
  581. const LLMatrix3& operator*=(LLMatrix3 &a, const LLMatrix3 &b)
  582. {
  583. U32 i, j;
  584. LLMatrix3 mat;
  585. for (i = 0; i < NUM_VALUES_IN_MAT3; i++)
  586. {
  587. for (j = 0; j < NUM_VALUES_IN_MAT3; j++)
  588. {
  589. mat.mMatrix[j][i] = a.mMatrix[j][0] * b.mMatrix[0][i] + 
  590.     a.mMatrix[j][1] * b.mMatrix[1][i] + 
  591.     a.mMatrix[j][2] * b.mMatrix[2][i];
  592. }
  593. }
  594. a = mat;
  595. return a;
  596. }
  598. const LLMatrix3& operator*=(LLMatrix3 &a, F32 scalar )
  599. {
  600. for( U32 i = 0; i < NUM_VALUES_IN_MAT3; ++i )
  601. {
  602. for( U32 j = 0; j < NUM_VALUES_IN_MAT3; ++j )
  603. {
  604. a.mMatrix[i][j] *= scalar;
  605. }
  606. }
  608. return a;
  609. }
  611. std::ostream& operator<<(std::ostream& s, const LLMatrix3 &a) 
  612. {
  613. s << "{ " 
  614. << a.mMatrix[VX][VX] << ", " << a.mMatrix[VX][VY] << ", " << a.mMatrix[VX][VZ] << "; "
  615. << a.mMatrix[VY][VX] << ", " << a.mMatrix[VY][VY] << ", " << a.mMatrix[VY][VZ] << "; "
  616. << a.mMatrix[VZ][VX] << ", " << a.mMatrix[VZ][VY] << ", " << a.mMatrix[VZ][VZ] 
  617.   << " }";
  618. return s;
  619. }