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

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

游戏引擎

开发平台：

C++ Builder

m4math.cpp：源码内容
  1. /** 
  2.  * @file m4math.cpp
  3.  * @brief LLMatrix4 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 "v4math.h"
  38. #include "m4math.h"
  39. #include "m3math.h"
  40. #include "llquaternion.h"
  45. // LLMatrix4
  47. // Constructors
  50. LLMatrix4::LLMatrix4(const F32 *mat)
  51. {
  52. mMatrix[0][0] = mat[0];
  53. mMatrix[0][1] = mat[1];
  54. mMatrix[0][2] = mat[2];
  55. mMatrix[0][3] = mat[3];
  57. mMatrix[1][0] = mat[4];
  58. mMatrix[1][1] = mat[5];
  59. mMatrix[1][2] = mat[6];
  60. mMatrix[1][3] = mat[7];
  62. mMatrix[2][0] = mat[8];
  63. mMatrix[2][1] = mat[9];
  64. mMatrix[2][2] = mat[10];
  65. mMatrix[2][3] = mat[11];
  67. mMatrix[3][0] = mat[12];
  68. mMatrix[3][1] = mat[13];
  69. mMatrix[3][2] = mat[14];
  70. mMatrix[3][3] = mat[15];
  71. }
  73. LLMatrix4::LLMatrix4(const LLMatrix3 &mat, const LLVector4 &vec)
  74. {
  75. mMatrix[0][0] = mat.mMatrix[0][0];
  76. mMatrix[0][1] = mat.mMatrix[0][1];
  77. mMatrix[0][2] = mat.mMatrix[0][2];
  78. mMatrix[0][3] = 0.f;
  80. mMatrix[1][0] = mat.mMatrix[1][0];
  81. mMatrix[1][1] = mat.mMatrix[1][1];
  82. mMatrix[1][2] = mat.mMatrix[1][2];
  83. mMatrix[1][3] = 0.f;
  85. mMatrix[2][0] = mat.mMatrix[2][0];
  86. mMatrix[2][1] = mat.mMatrix[2][1];
  87. mMatrix[2][2] = mat.mMatrix[2][2];
  88. mMatrix[2][3] = 0.f;
  90. mMatrix[3][0] = vec.mV[0];
  91. mMatrix[3][1] = vec.mV[1];
  92. mMatrix[3][2] = vec.mV[2];
  93. mMatrix[3][3] = 1.f;
  94. }
  96. LLMatrix4::LLMatrix4(const LLMatrix3 &mat)
  97. {
  98. mMatrix[0][0] = mat.mMatrix[0][0];
  99. mMatrix[0][1] = mat.mMatrix[0][1];
  100. mMatrix[0][2] = mat.mMatrix[0][2];
  101. mMatrix[0][3] = 0.f;
  103. mMatrix[1][0] = mat.mMatrix[1][0];
  104. mMatrix[1][1] = mat.mMatrix[1][1];
  105. mMatrix[1][2] = mat.mMatrix[1][2];
  106. mMatrix[1][3] = 0.f;
  108. mMatrix[2][0] = mat.mMatrix[2][0];
  109. mMatrix[2][1] = mat.mMatrix[2][1];
  110. mMatrix[2][2] = mat.mMatrix[2][2];
  111. mMatrix[2][3] = 0.f;
  113. mMatrix[3][0] = 0.f;
  114. mMatrix[3][1] = 0.f;
  115. mMatrix[3][2] = 0.f;
  116. mMatrix[3][3] = 1.f;
  117. }
  119. LLMatrix4::LLMatrix4(const LLQuaternion &q)
  120. {
  121. *this = initRotation(q);
  122. }
  124. LLMatrix4::LLMatrix4(const LLQuaternion &q, const LLVector4 &pos)
  125. {
  126. *this = initRotTrans(q, pos);
  127. }
  129. LLMatrix4::LLMatrix4(const F32 angle, const LLVector4 &vec, const LLVector4 &pos)
  130. {
  131. initRotTrans(LLQuaternion(angle, vec), pos);
  132. }
  134. LLMatrix4::LLMatrix4(const F32 angle, const LLVector4 &vec)
  135. {
  136. initRotation(LLQuaternion(angle, vec));
  138. mMatrix[3][0] = 0.f;
  139. mMatrix[3][1] = 0.f;
  140. mMatrix[3][2] = 0.f;
  141. mMatrix[3][3] = 1.f;
  142. }
  144. LLMatrix4::LLMatrix4(const F32 roll, const F32 pitch, const F32 yaw, const LLVector4 &pos)
  145. {
  146. LLMatrix3 mat(roll, pitch, yaw);
  147. initRotTrans(LLQuaternion(mat), pos);
  148. }
  150. LLMatrix4::LLMatrix4(const F32 roll, const F32 pitch, const F32 yaw)
  151. {
  152. LLMatrix3 mat(roll, pitch, yaw);
  153. initRotation(LLQuaternion(mat));
  155. mMatrix[3][0] = 0.f;
  156. mMatrix[3][1] = 0.f;
  157. mMatrix[3][2] = 0.f;
  158. mMatrix[3][3] = 1.f;
  159. }
  161. LLMatrix4::~LLMatrix4(void)
  162. {
  163. }
  165. // Clear and Assignment Functions
  167. const LLMatrix4& LLMatrix4::setZero()
  168. {
  169. mMatrix[0][0] = 0.f;
  170. mMatrix[0][1] = 0.f;
  171. mMatrix[0][2] = 0.f;
  172. mMatrix[0][3] = 0.f;
  174. mMatrix[1][0] = 0.f;
  175. mMatrix[1][1] = 0.f;
  176. mMatrix[1][2] = 0.f;
  177. mMatrix[1][3] = 0.f;
  179. mMatrix[2][0] = 0.f;
  180. mMatrix[2][1] = 0.f;
  181. mMatrix[2][2] = 0.f;
  182. mMatrix[2][3] = 0.f;
  184. mMatrix[3][0] = 0.f;
  185. mMatrix[3][1] = 0.f;
  186. mMatrix[3][2] = 0.f;
  187. mMatrix[3][3] = 0.f;
  188. return *this;
  189. }
  192. // various useful mMatrix functions
  194. const LLMatrix4& LLMatrix4::transpose()
  195. {
  196. LLMatrix4 mat;
  197. mat.mMatrix[0][0] = mMatrix[0][0];
  198. mat.mMatrix[1][0] = mMatrix[0][1];
  199. mat.mMatrix[2][0] = mMatrix[0][2];
  200. mat.mMatrix[3][0] = mMatrix[0][3];
  202. mat.mMatrix[0][1] = mMatrix[1][0];
  203. mat.mMatrix[1][1] = mMatrix[1][1];
  204. mat.mMatrix[2][1] = mMatrix[1][2];
  205. mat.mMatrix[3][1] = mMatrix[1][3];
  207. mat.mMatrix[0][2] = mMatrix[2][0];
  208. mat.mMatrix[1][2] = mMatrix[2][1];
  209. mat.mMatrix[2][2] = mMatrix[2][2];
  210. mat.mMatrix[3][2] = mMatrix[2][3];
  212. mat.mMatrix[0][3] = mMatrix[3][0];
  213. mat.mMatrix[1][3] = mMatrix[3][1];
  214. mat.mMatrix[2][3] = mMatrix[3][2];
  215. mat.mMatrix[3][3] = mMatrix[3][3];
  217. *this = mat;
  218. return *this;
  219. }
  222. F32 LLMatrix4::determinant() const
  223. {
  224. llerrs << "Not implemented!" << llendl;
  225. return 0.f;
  226. }
  228. // Only works for pure orthonormal, homogeneous transform matrices.
  229. const LLMatrix4& LLMatrix4::invert(void) 
  230. {
  231. // transpose the rotation part
  232. F32 temp;
  233. temp = mMatrix[VX][VY]; mMatrix[VX][VY] = mMatrix[VY][VX]; mMatrix[VY][VX] = temp;
  234. temp = mMatrix[VX][VZ]; mMatrix[VX][VZ] = mMatrix[VZ][VX]; mMatrix[VZ][VX] = temp;
  235. temp = mMatrix[VY][VZ]; mMatrix[VY][VZ] = mMatrix[VZ][VY]; mMatrix[VZ][VY] = temp;
  237. // rotate the translation part by the new rotation 
  238. // (temporarily store in empty column of matrix)
  239. U32 j;
  240. for (j=0; j<3; j++)
  241. {
  242. mMatrix[j][VW] =  mMatrix[VW][VX] * mMatrix[VX][j] + 
  243.   mMatrix[VW][VY] * mMatrix[VY][j] +
  244.   mMatrix[VW][VZ] * mMatrix[VZ][j]; 
  245. }
  247. // negate and copy the temporary vector back to the tranlation row
  248. mMatrix[VW][VX] = -mMatrix[VX][VW];
  249. mMatrix[VW][VY] = -mMatrix[VY][VW];
  250. mMatrix[VW][VZ] = -mMatrix[VZ][VW];
  252.     // zero the empty column again
  253. mMatrix[VX][VW] = mMatrix[VY][VW] = mMatrix[VZ][VW] = 0.0f;
  255. return *this;
  256. }
  258. LLVector4 LLMatrix4::getFwdRow4() const
  259. {
  260. return LLVector4(mMatrix[VX][VX], mMatrix[VX][VY], mMatrix[VX][VZ], mMatrix[VX][VW]);
  261. }
  263. LLVector4 LLMatrix4::getLeftRow4() const
  264. {
  265. return LLVector4(mMatrix[VY][VX], mMatrix[VY][VY], mMatrix[VY][VZ], mMatrix[VY][VW]);
  266. }
  268. LLVector4 LLMatrix4::getUpRow4() const
  269. {
  270. return LLVector4(mMatrix[VZ][VX], mMatrix[VZ][VY], mMatrix[VZ][VZ], mMatrix[VZ][VW]);
  271. }
  273. // SJB: This code is correct for a logicly stored (non-transposed) matrix;
  274. // Our matrices are stored transposed, OpenGL style, so this generates the
  275. // INVERSE quaternion (-x, -y, -z, w)!
  276. // Because we use similar logic in LLQuaternion::getMatrix3,
  277. // we are internally consistant so everything works OK :)
  278. LLQuaternion LLMatrix4::quaternion() const
  279. {
  280. LLQuaternion quat;
  281. F32 tr, s, q[4];
  282. U32 i, j, k;
  283. U32 nxt[3] = {1, 2, 0};
  285. tr = mMatrix[0][0] + mMatrix[1][1] + mMatrix[2][2];
  287. // check the diagonal
  288. if (tr > 0.f) 
  289. {
  290. s = (F32)sqrt (tr + 1.f);
  291. quat.mQ[VS] = s / 2.f;
  292. s = 0.5f / s;
  293. quat.mQ[VX] = (mMatrix[1][2] - mMatrix[2][1]) * s;
  294. quat.mQ[VY] = (mMatrix[2][0] - mMatrix[0][2]) * s;
  295. quat.mQ[VZ] = (mMatrix[0][1] - mMatrix[1][0]) * s;
  296. } 
  297. else
  298. {
  299. // diagonal is negative
  300. i = 0;
  301. if (mMatrix[1][1] > mMatrix[0][0]) 
  302. i = 1;
  303. if (mMatrix[2][2] > mMatrix[i][i]) 
  304. i = 2;
  306. j = nxt[i];
  307. k = nxt[j];
  310. s = (F32)sqrt ((mMatrix[i][i] - (mMatrix[j][j] + mMatrix[k][k])) + 1.f);
  312. q[i] = s * 0.5f;
  314. if (s != 0.f) 
  315. s = 0.5f / s;
  317. q[3] = (mMatrix[j][k] - mMatrix[k][j]) * s;
  318. q[j] = (mMatrix[i][j] + mMatrix[j][i]) * s;
  319. q[k] = (mMatrix[i][k] + mMatrix[k][i]) * s;
  321. quat.setQuat(q);
  322. }
  323. return quat;
  324. }
  328. void LLMatrix4::initRows(const LLVector4 &row0,
  329.  const LLVector4 &row1,
  330.  const LLVector4 &row2,
  331.  const LLVector4 &row3)
  332. {
  333. mMatrix[0][0] = row0.mV[0];
  334. mMatrix[0][1] = row0.mV[1];
  335. mMatrix[0][2] = row0.mV[2];
  336. mMatrix[0][3] = row0.mV[3];
  338. mMatrix[1][0] = row1.mV[0];
  339. mMatrix[1][1] = row1.mV[1];
  340. mMatrix[1][2] = row1.mV[2];
  341. mMatrix[1][3] = row1.mV[3];
  343. mMatrix[2][0] = row2.mV[0];
  344. mMatrix[2][1] = row2.mV[1];
  345. mMatrix[2][2] = row2.mV[2];
  346. mMatrix[2][3] = row2.mV[3];
  348. mMatrix[3][0] = row3.mV[0];
  349. mMatrix[3][1] = row3.mV[1];
  350. mMatrix[3][2] = row3.mV[2];
  351. mMatrix[3][3] = row3.mV[3];
  352. }
  355. const LLMatrix4&  LLMatrix4::initRotation(const F32 angle, const F32 x, const F32 y, const F32 z)
  356. {
  357. LLMatrix3 mat(angle, x, y, z);
  358. return initMatrix(mat);
  359. }
  362. const LLMatrix4&  LLMatrix4::initRotation(F32 angle, const LLVector4 &vec)
  363. {
  364. LLMatrix3 mat(angle, vec);
  365. return initMatrix(mat);
  366. }
  369. const LLMatrix4&  LLMatrix4::initRotation(const F32 roll, const F32 pitch, const F32 yaw)
  370. {
  371. LLMatrix3 mat(roll, pitch, yaw);
  372. return initMatrix(mat);
  373. }
  376. const LLMatrix4&   LLMatrix4::initRotation(const LLQuaternion &q)
  377. {
  378. LLMatrix3 mat(q);
  379. return initMatrix(mat);
  380. }
  383. // Position and Rotation
  384. const LLMatrix4&   LLMatrix4::initRotTrans(const F32 angle, const F32 rx, const F32 ry, const F32 rz,
  385. const F32 tx, const F32 ty, const F32 tz)
  386. {
  387. LLMatrix3 mat(angle, rx, ry, rz);
  388. LLVector3 translation(tx, ty, tz);
  389. initMatrix(mat);
  390. setTranslation(translation);
  391. return (*this);
  392. }
  394. const LLMatrix4&   LLMatrix4::initRotTrans(const F32 angle, const LLVector3 &axis, const LLVector3&translation)
  395. {
  396. LLMatrix3 mat(angle, axis);
  397. initMatrix(mat);
  398. setTranslation(translation);
  399. return (*this);
  400. }
  402. const LLMatrix4&   LLMatrix4::initRotTrans(const F32 roll, const F32 pitch, const F32 yaw, const LLVector4 &translation)
  403. {
  404. LLMatrix3 mat(roll, pitch, yaw);
  405. initMatrix(mat);
  406. setTranslation(translation);
  407. return (*this);
  408. }
  410. /*
  411. const LLMatrix4&   LLMatrix4::initRotTrans(const LLVector4 &fwd, 
  412. const LLVector4 &left, 
  413. const LLVector4 &up, 
  414. const LLVector4 &translation)
  415. {
  416. LLMatrix3 mat(fwd, left, up);
  417. initMatrix(mat);
  418. setTranslation(translation);
  419. return (*this);
  420. }
  421. */
  423. const LLMatrix4&   LLMatrix4::initRotTrans(const LLQuaternion &q, const LLVector4 &translation)
  424. {
  425. LLMatrix3 mat(q);
  426. initMatrix(mat);
  427. setTranslation(translation);
  428. return (*this);
  429. }
  431. const LLMatrix4& LLMatrix4::initAll(const LLVector3 &scale, const LLQuaternion &q, const LLVector3 &pos)
  432. {
  433. F32 sx, sy, sz;
  434. F32 xx, xy, xz, xw, yy, yz, yw, zz, zw;
  436. sx      = scale.mV[0];
  437. sy      = scale.mV[1];
  438. sz      = scale.mV[2];
  440.     xx      = q.mQ[VX] * q.mQ[VX];
  441.     xy      = q.mQ[VX] * q.mQ[VY];
  442.     xz      = q.mQ[VX] * q.mQ[VZ];
  443.     xw      = q.mQ[VX] * q.mQ[VW];
  445.     yy      = q.mQ[VY] * q.mQ[VY];
  446.     yz      = q.mQ[VY] * q.mQ[VZ];
  447.     yw      = q.mQ[VY] * q.mQ[VW];
  449.     zz      = q.mQ[VZ] * q.mQ[VZ];
  450.     zw      = q.mQ[VZ] * q.mQ[VW];
  452.     mMatrix[0][0]  = (1.f - 2.f * ( yy + zz )) *sx;
  453.     mMatrix[0][1]  = (     2.f * ( xy + zw )) *sx;
  454.     mMatrix[0][2]  = (     2.f * ( xz - yw )) *sx;
  456.     mMatrix[1][0]  = (      2.f * ( xy - zw )) *sy;
  457.     mMatrix[1][1]  = (1.f - 2.f * ( xx + zz )) *sy;
  458.     mMatrix[1][2]  = (      2.f * ( yz + xw )) *sy;
  460.     mMatrix[2][0]  = (     2.f * ( xz + yw )) *sz;
  461.     mMatrix[2][1]  = (      2.f * ( yz - xw )) *sz;
  462.     mMatrix[2][2]  = (1.f - 2.f * ( xx + yy )) *sz;
  464. mMatrix[3][0]  = pos.mV[0];
  465. mMatrix[3][1]  = pos.mV[1];
  466. mMatrix[3][2]  = pos.mV[2];
  467. mMatrix[3][3]  = 1.0;
  469. // TODO -- should we set the translation portion to zero?
  470. return (*this);
  471. }
  473. // Rotate exisitng mMatrix
  474. const LLMatrix4&   LLMatrix4::rotate(const F32 angle, const F32 x, const F32 y, const F32 z)
  475. {
  476. LLVector4 vec4(x, y, z);
  477. LLMatrix4 mat(angle, vec4);
  478. *this *= mat;
  479. return *this;
  480. }
  482. const LLMatrix4&   LLMatrix4::rotate(const F32 angle, const LLVector4 &vec)
  483. {
  484. LLMatrix4 mat(angle, vec);
  485. *this *= mat;
  486. return *this;
  487. }
  489. const LLMatrix4&   LLMatrix4::rotate(const F32 roll, const F32 pitch, const F32 yaw)
  490. {
  491. LLMatrix4 mat(roll, pitch, yaw);
  492. *this *= mat;
  493. return *this;
  494. }
  496. const LLMatrix4&   LLMatrix4::rotate(const LLQuaternion &q)
  497. {
  498. LLMatrix4 mat(q);
  499. *this *= mat;
  500. return *this;
  501. }
  504. const LLMatrix4&   LLMatrix4::translate(const LLVector3 &vec)
  505. {
  506. mMatrix[3][0] += vec.mV[0];
  507. mMatrix[3][1] += vec.mV[1];
  508. mMatrix[3][2] += vec.mV[2];
  509. return (*this);
  510. }
  513. void LLMatrix4::setFwdRow(const LLVector3 &row)
  514. {
  515. mMatrix[VX][VX] = row.mV[VX];
  516. mMatrix[VX][VY] = row.mV[VY];
  517. mMatrix[VX][VZ] = row.mV[VZ];
  518. }
  520. void LLMatrix4::setLeftRow(const LLVector3 &row)
  521. {
  522. mMatrix[VY][VX] = row.mV[VX];
  523. mMatrix[VY][VY] = row.mV[VY];
  524. mMatrix[VY][VZ] = row.mV[VZ];
  525. }
  527. void LLMatrix4::setUpRow(const LLVector3 &row)
  528. {
  529. mMatrix[VZ][VX] = row.mV[VX];
  530. mMatrix[VZ][VY] = row.mV[VY];
  531. mMatrix[VZ][VZ] = row.mV[VZ];
  532. }
  535. void LLMatrix4::setFwdCol(const LLVector3 &col)
  536. {
  537. mMatrix[VX][VX] = col.mV[VX];
  538. mMatrix[VY][VX] = col.mV[VY];
  539. mMatrix[VZ][VX] = col.mV[VZ];
  540. }
  542. void LLMatrix4::setLeftCol(const LLVector3 &col)
  543. {
  544. mMatrix[VX][VY] = col.mV[VX];
  545. mMatrix[VY][VY] = col.mV[VY];
  546. mMatrix[VZ][VY] = col.mV[VZ];
  547. }
  549. void LLMatrix4::setUpCol(const LLVector3 &col)
  550. {
  551. mMatrix[VX][VZ] = col.mV[VX];
  552. mMatrix[VY][VZ] = col.mV[VY];
  553. mMatrix[VZ][VZ] = col.mV[VZ];
  554. }
  557. const LLMatrix4&   LLMatrix4::setTranslation(const F32 tx, const F32 ty, const F32 tz)
  558. {
  559. mMatrix[VW][VX] = tx;
  560. mMatrix[VW][VY] = ty;
  561. mMatrix[VW][VZ] = tz;
  562. return (*this);
  563. }
  565. const LLMatrix4&   LLMatrix4::setTranslation(const LLVector3 &translation)
  566. {
  567. mMatrix[VW][VX] = translation.mV[VX];
  568. mMatrix[VW][VY] = translation.mV[VY];
  569. mMatrix[VW][VZ] = translation.mV[VZ];
  570. return (*this);
  571. }
  573. const LLMatrix4&   LLMatrix4::setTranslation(const LLVector4 &translation)
  574. {
  575. mMatrix[VW][VX] = translation.mV[VX];
  576. mMatrix[VW][VY] = translation.mV[VY];
  577. mMatrix[VW][VZ] = translation.mV[VZ];
  578. return (*this);
  579. }
  581. // LLMatrix3 Extraction and Setting
  582. LLMatrix3   LLMatrix4::getMat3() const
  583. {
  584. LLMatrix3 retmat;
  586. retmat.mMatrix[0][0] = mMatrix[0][0];
  587. retmat.mMatrix[0][1] = mMatrix[0][1];
  588. retmat.mMatrix[0][2] = mMatrix[0][2];
  590. retmat.mMatrix[1][0] = mMatrix[1][0];
  591. retmat.mMatrix[1][1] = mMatrix[1][1];
  592. retmat.mMatrix[1][2] = mMatrix[1][2];
  594. retmat.mMatrix[2][0] = mMatrix[2][0];
  595. retmat.mMatrix[2][1] = mMatrix[2][1];
  596. retmat.mMatrix[2][2] = mMatrix[2][2];
  598. return retmat;
  599. }
  601. const LLMatrix4&   LLMatrix4::initMatrix(const LLMatrix3 &mat)
  602. {
  603. mMatrix[0][0] = mat.mMatrix[0][0];
  604. mMatrix[0][1] = mat.mMatrix[0][1];
  605. mMatrix[0][2] = mat.mMatrix[0][2];
  606. mMatrix[0][3] = 0.f;
  608. mMatrix[1][0] = mat.mMatrix[1][0];
  609. mMatrix[1][1] = mat.mMatrix[1][1];
  610. mMatrix[1][2] = mat.mMatrix[1][2];
  611. mMatrix[1][3] = 0.f;
  613. mMatrix[2][0] = mat.mMatrix[2][0];
  614. mMatrix[2][1] = mat.mMatrix[2][1];
  615. mMatrix[2][2] = mat.mMatrix[2][2];
  616. mMatrix[2][3] = 0.f;
  618. mMatrix[3][0] = 0.f;
  619. mMatrix[3][1] = 0.f;
  620. mMatrix[3][2] = 0.f;
  621. mMatrix[3][3] = 1.f;
  622. return (*this);
  623. }
  625. const LLMatrix4&   LLMatrix4::initMatrix(const LLMatrix3 &mat, const LLVector4 &translation)
  626. {
  627. mMatrix[0][0] = mat.mMatrix[0][0];
  628. mMatrix[0][1] = mat.mMatrix[0][1];
  629. mMatrix[0][2] = mat.mMatrix[0][2];
  630. mMatrix[0][3] = 0.f;
  632. mMatrix[1][0] = mat.mMatrix[1][0];
  633. mMatrix[1][1] = mat.mMatrix[1][1];
  634. mMatrix[1][2] = mat.mMatrix[1][2];
  635. mMatrix[1][3] = 0.f;
  637. mMatrix[2][0] = mat.mMatrix[2][0];
  638. mMatrix[2][1] = mat.mMatrix[2][1];
  639. mMatrix[2][2] = mat.mMatrix[2][2];
  640. mMatrix[2][3] = 0.f;
  642. mMatrix[3][0] = translation.mV[0];
  643. mMatrix[3][1] = translation.mV[1];
  644. mMatrix[3][2] = translation.mV[2];
  645. mMatrix[3][3] = 1.f;
  646. return (*this);
  647. }
  649. // LLMatrix4 Operators
  652. /* Not implemented to help enforce code consistency with the syntax of
  653.    row-major notation.  This is a Good Thing.
  654. LLVector4 operator*(const LLMatrix4 &a, const LLVector4 &b)
  655. {
  656. // Operate "to the right" on column-vector b
  657. LLVector4 vec;
  658. vec.mV[VX] = a.mMatrix[VX][VX] * b.mV[VX] + 
  659.  a.mMatrix[VY][VX] * b.mV[VY] + 
  660.    a.mMatrix[VZ][VX] * b.mV[VZ] +
  661.  a.mMatrix[VW][VX] * b.mV[VW];
  663. vec.mV[VY] = a.mMatrix[VX][VY] * b.mV[VX] + 
  664.  a.mMatrix[VY][VY] * b.mV[VY] + 
  665.  a.mMatrix[VZ][VY] * b.mV[VZ] +
  666.  a.mMatrix[VW][VY] * b.mV[VW];
  668. vec.mV[VZ] = a.mMatrix[VX][VZ] * b.mV[VX] + 
  669.     a.mMatrix[VY][VZ] * b.mV[VY] + 
  670.  a.mMatrix[VZ][VZ] * b.mV[VZ] +
  671.  a.mMatrix[VW][VZ] * b.mV[VW];
  673. vec.mV[VW] = a.mMatrix[VX][VW] * b.mV[VX] + 
  674.  a.mMatrix[VY][VW] * b.mV[VY] + 
  675.  a.mMatrix[VZ][VW] * b.mV[VZ] +
  676.  a.mMatrix[VW][VW] * b.mV[VW];
  677. return vec;
  678. }
  679. */
  682. LLVector4 operator*(const LLVector4 &a, const LLMatrix4 &b)
  683. {
  684. // Operate "to the left" on row-vector a
  685. return LLVector4(a.mV[VX] * b.mMatrix[VX][VX] + 
  686.  a.mV[VY] * b.mMatrix[VY][VX] + 
  687.  a.mV[VZ] * b.mMatrix[VZ][VX] +
  688.  a.mV[VW] * b.mMatrix[VW][VX],
  690.  a.mV[VX] * b.mMatrix[VX][VY] + 
  691.  a.mV[VY] * b.mMatrix[VY][VY] + 
  692.  a.mV[VZ] * b.mMatrix[VZ][VY] +
  693.  a.mV[VW] * b.mMatrix[VW][VY],
  695.  a.mV[VX] * b.mMatrix[VX][VZ] + 
  696.  a.mV[VY] * b.mMatrix[VY][VZ] + 
  697.  a.mV[VZ] * b.mMatrix[VZ][VZ] +
  698.  a.mV[VW] * b.mMatrix[VW][VZ],
  700.  a.mV[VX] * b.mMatrix[VX][VW] + 
  701.  a.mV[VY] * b.mMatrix[VY][VW] + 
  702.  a.mV[VZ] * b.mMatrix[VZ][VW] +
  703.  a.mV[VW] * b.mMatrix[VW][VW]);
  704. }
  706. LLVector4 rotate_vector(const LLVector4 &a, const LLMatrix4 &b)
  707. {
  708. // Rotates but does not translate
  709. // Operate "to the left" on row-vector a
  710. LLVector4 vec;
  711. vec.mV[VX] = a.mV[VX] * b.mMatrix[VX][VX] + 
  712.  a.mV[VY] * b.mMatrix[VY][VX] + 
  713.  a.mV[VZ] * b.mMatrix[VZ][VX];
  715. vec.mV[VY] = a.mV[VX] * b.mMatrix[VX][VY] + 
  716.  a.mV[VY] * b.mMatrix[VY][VY] + 
  717.  a.mV[VZ] * b.mMatrix[VZ][VY];
  719. vec.mV[VZ] = a.mV[VX] * b.mMatrix[VX][VZ] + 
  720.  a.mV[VY] * b.mMatrix[VY][VZ] + 
  721.  a.mV[VZ] * b.mMatrix[VZ][VZ];
  723. // vec.mV[VW] = a.mV[VX] * b.mMatrix[VX][VW] + 
  724. //  a.mV[VY] * b.mMatrix[VY][VW] + 
  725. //  a.mV[VZ] * b.mMatrix[VZ][VW] +
  726. vec.mV[VW] = a.mV[VW];
  727. return vec;
  728. }
  730. LLVector3 rotate_vector(const LLVector3 &a, const LLMatrix4 &b)
  731. {
  732. // Rotates but does not translate
  733. // Operate "to the left" on row-vector a
  734. LLVector3 vec;
  735. vec.mV[VX] = a.mV[VX] * b.mMatrix[VX][VX] + 
  736.  a.mV[VY] * b.mMatrix[VY][VX] + 
  737.  a.mV[VZ] * b.mMatrix[VZ][VX];
  739. vec.mV[VY] = a.mV[VX] * b.mMatrix[VX][VY] + 
  740.  a.mV[VY] * b.mMatrix[VY][VY] + 
  741.  a.mV[VZ] * b.mMatrix[VZ][VY];
  743. vec.mV[VZ] = a.mV[VX] * b.mMatrix[VX][VZ] + 
  744.  a.mV[VY] * b.mMatrix[VY][VZ] + 
  745.  a.mV[VZ] * b.mMatrix[VZ][VZ];
  746. return vec;
  747. }
  749. bool operator==(const LLMatrix4 &a, const LLMatrix4 &b)
  750. {
  751. U32 i, j;
  752. for (i = 0; i < NUM_VALUES_IN_MAT4; i++)
  753. {
  754. for (j = 0; j < NUM_VALUES_IN_MAT4; j++)
  755. {
  756. if (a.mMatrix[j][i] != b.mMatrix[j][i])
  757. return FALSE;
  758. }
  759. }
  760. return TRUE;
  761. }
  763. bool operator!=(const LLMatrix4 &a, const LLMatrix4 &b)
  764. {
  765. U32 i, j;
  766. for (i = 0; i < NUM_VALUES_IN_MAT4; i++)
  767. {
  768. for (j = 0; j < NUM_VALUES_IN_MAT4; j++)
  769. {
  770. if (a.mMatrix[j][i] != b.mMatrix[j][i])
  771. return TRUE;
  772. }
  773. }
  774. return FALSE;
  775. }
  777. const LLMatrix4& operator*=(LLMatrix4 &a, F32 k)
  778. {
  779. U32 i, j;
  780. for (i = 0; i < NUM_VALUES_IN_MAT4; i++)
  781. {
  782. for (j = 0; j < NUM_VALUES_IN_MAT4; j++)
  783. {
  784. a.mMatrix[j][i] *= k;
  785. }
  786. }
  787. return a;
  788. }
  790. std::ostream& operator<<(std::ostream& s, const LLMatrix4 &a) 
  791. {
  792. s << "{ " 
  793. << a.mMatrix[VX][VX] << ", " 
  794. << a.mMatrix[VX][VY] << ", " 
  795. << a.mMatrix[VX][VZ] << ", " 
  796. << a.mMatrix[VX][VW] 
  797. << "; "
  798. << a.mMatrix[VY][VX] << ", " 
  799. << a.mMatrix[VY][VY] << ", " 
  800. << a.mMatrix[VY][VZ] << ", " 
  801. << a.mMatrix[VY][VW] 
  802. << "; "
  803. << a.mMatrix[VZ][VX] << ", " 
  804. << a.mMatrix[VZ][VY] << ", " 
  805. << a.mMatrix[VZ][VZ] << ", " 
  806. << a.mMatrix[VZ][VW] 
  807. << "; "
  808. << a.mMatrix[VW][VX] << ", " 
  809. << a.mMatrix[VW][VY] << ", " 
  810. << a.mMatrix[VW][VZ] << ", " 
  811. << a.mMatrix[VW][VW] 
  812.   << " }";
  813. return s;
  814. }