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

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

游戏引擎

开发平台：

C++ Builder

llcoordframe.cpp：源码内容
  1. /** 
  2.  * @file llcoordframe.cpp
  3.  * @brief LLCoordFrame 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 "m3math.h"
  38. #include "v4math.h"
  39. #include "m4math.h"
  40. #include "llquaternion.h"
  41. #include "llcoordframe.h"
  43. #ifndef X_AXIS
  44. #define X_AXIS 1.0f,0.0f,0.0f
  45. #define Y_AXIS 0.0f,1.0f,0.0f
  46. #define Z_AXIS 0.0f,0.0f,1.0f
  47. #endif
  49. // Constructors
  51. LLCoordFrame::LLCoordFrame() :
  52. mOrigin(0.f, 0.f, 0.f),
  53. mXAxis(X_AXIS),
  54. mYAxis(Y_AXIS),
  55. mZAxis(Z_AXIS)
  56. {
  57. }
  59. LLCoordFrame::LLCoordFrame(const LLVector3 &origin) :
  60. mOrigin(origin), 
  61. mXAxis(X_AXIS),
  62. mYAxis(Y_AXIS),
  63. mZAxis(Z_AXIS)
  64. {
  65. if( !mOrigin.isFinite() )
  66. {
  67. reset();
  68. llwarns << "Non Finite in LLCoordFrame::LLCoordFrame()" << llendl;
  69. }
  70. }
  72. LLCoordFrame::LLCoordFrame(const LLVector3 &origin, const LLVector3 &direction) :
  73. mOrigin(origin)
  74. {
  75. lookDir(direction);
  77. if( !isFinite() )
  78. {
  79. reset();
  80. llwarns << "Non Finite in LLCoordFrame::LLCoordFrame()" << llendl;
  81. }
  82. }
  84. LLCoordFrame::LLCoordFrame(const LLVector3 &x_axis,
  85.    const LLVector3 &y_axis,
  86.    const LLVector3 &z_axis) : 
  87. mOrigin(0.f, 0.f, 0.f), 
  88. mXAxis(x_axis), 
  89. mYAxis(y_axis), 
  90. mZAxis(z_axis)
  91. {
  92. if( !isFinite() )
  93. {
  94. reset();
  95. llwarns << "Non Finite in LLCoordFrame::LLCoordFrame()" << llendl;
  96. }
  97. }
  99. LLCoordFrame::LLCoordFrame(const LLVector3 &origin,
  100.    const LLVector3 &x_axis,
  101.    const LLVector3 &y_axis,
  102.    const LLVector3 &z_axis) : 
  103. mOrigin(origin), 
  104. mXAxis(x_axis), 
  105. mYAxis(y_axis), 
  106. mZAxis(z_axis)
  107. {
  108. if( !isFinite() )
  109. {
  110. reset();
  111. llwarns << "Non Finite in LLCoordFrame::LLCoordFrame()" << llendl;
  112. }
  113. }
  116. LLCoordFrame::LLCoordFrame(const LLVector3 &origin, 
  117.    const LLMatrix3 &rotation) :
  118. mOrigin(origin),
  119. mXAxis(rotation.mMatrix[VX]),
  120. mYAxis(rotation.mMatrix[VY]),
  121. mZAxis(rotation.mMatrix[VZ])
  122. {
  123. if( !isFinite() )
  124. {
  125. reset();
  126. llwarns << "Non Finite in LLCoordFrame::LLCoordFrame()" << llendl;
  127. }
  128. }
  130. LLCoordFrame::LLCoordFrame(const LLQuaternion &q) :
  131. mOrigin(0.f, 0.f, 0.f)
  132. {
  133. LLMatrix3 rotation_matrix(q);
  134. mXAxis.setVec(rotation_matrix.mMatrix[VX]);
  135. mYAxis.setVec(rotation_matrix.mMatrix[VY]);
  136. mZAxis.setVec(rotation_matrix.mMatrix[VZ]);
  138. if( !isFinite() )
  139. {
  140. reset();
  141. llwarns << "Non Finite in LLCoordFrame::LLCoordFrame()" << llendl;
  142. }
  143. }
  145. LLCoordFrame::LLCoordFrame(const LLVector3 &origin, const LLQuaternion &q) :
  146. mOrigin(origin)
  147. {
  148. LLMatrix3 rotation_matrix(q);
  149. mXAxis.setVec(rotation_matrix.mMatrix[VX]);
  150. mYAxis.setVec(rotation_matrix.mMatrix[VY]);
  151. mZAxis.setVec(rotation_matrix.mMatrix[VZ]);
  153. if( !isFinite() )
  154. {
  155. reset();
  156. llwarns << "Non Finite in LLCoordFrame::LLCoordFrame()" << llendl;
  157. }
  158. }
  160. LLCoordFrame::LLCoordFrame(const LLMatrix4 &mat) :
  161. mOrigin(mat.mMatrix[VW]),
  162. mXAxis(mat.mMatrix[VX]),
  163. mYAxis(mat.mMatrix[VY]),
  164. mZAxis(mat.mMatrix[VZ])
  165. {
  166. if( !isFinite() )
  167. {
  168. reset();
  169. llwarns << "Non Finite in LLCoordFrame::LLCoordFrame()" << llendl;
  170. }
  171. }
  174. // The folowing two constructors are dangerous due to implicit casting and have been disabled - SJB
  175. /*
  176. LLCoordFrame::LLCoordFrame(const F32 *origin, const F32 *rotation) :
  177. mOrigin(origin),
  178. mXAxis(rotation+3*VX),
  179. mYAxis(rotation+3*VY),
  180. mZAxis(rotation+3*VZ)
  181. {
  182. if( !isFinite() )
  183. {
  184. reset();
  185. llwarns << "Non Finite in LLCoordFrame::LLCoordFrame()" << llendl;
  186. }
  187. }
  188. */
  190. /*
  191. LLCoordFrame::LLCoordFrame(const F32 *origin_and_rotation) :
  192. mOrigin(origin_and_rotation),
  193. mXAxis(origin_and_rotation + 3*(VX+1)),
  194. mYAxis(origin_and_rotation + 3*(VY+1)),
  195. mZAxis(origin_and_rotation + 3*(VZ+1))
  196. {
  197. if( !isFinite() )
  198. {
  199. reset();
  200. llwarns << "Non Finite in LLCoordFrame::LLCoordFrame()" << llendl;
  201. }
  202. }
  203. */
  206. void LLCoordFrame::reset() 
  207. {
  208. mOrigin.setVec(0.0f, 0.0f, 0.0f);
  209. resetAxes();
  210. }
  213. void LLCoordFrame::resetAxes()
  214. {
  215. mXAxis.setVec(1.0f, 0.0f, 0.0f);
  216. mYAxis.setVec(0.0f, 1.0f, 0.0f);
  217. mZAxis.setVec(0.0f, 0.0f, 1.0f);
  218. }
  220. // setOrigin() member functions set mOrigin
  222. void LLCoordFrame::setOrigin(F32 x, F32 y, F32 z) 
  223. {
  224. mOrigin.setVec(x, y, z); 
  226. if( !mOrigin.isFinite() )
  227. {
  228. reset();
  229. llwarns << "Non Finite in LLCoordFrame::setOrigin()" << llendl;
  230. }
  231. }
  233. void LLCoordFrame::setOrigin(const LLVector3 &new_origin)
  234. {
  235. mOrigin = new_origin; 
  236. if( !mOrigin.isFinite() )
  237. {
  238. reset();
  239. llwarns << "Non Finite in LLCoordFrame::setOrigin()" << llendl;
  240. }
  241. }
  243. void LLCoordFrame::setOrigin(const F32 *origin)
  244. {
  245. mOrigin.mV[VX] = *(origin + VX);
  246. mOrigin.mV[VY] = *(origin + VY);
  247. mOrigin.mV[VZ] = *(origin + VZ);
  249. if( !mOrigin.isFinite() )
  250. {
  251. reset();
  252. llwarns << "Non Finite in LLCoordFrame::setOrigin()" << llendl;
  253. }
  254. }
  256. void LLCoordFrame::setOrigin(const LLCoordFrame &frame)
  257. {
  258. mOrigin = frame.getOrigin();
  260. if( !mOrigin.isFinite() )
  261. {
  262. reset();
  263. llwarns << "Non Finite in LLCoordFrame::setOrigin()" << llendl;
  264. }
  265. }
  267. // setAxes()  member functions set the axes, and assume that
  268. // the arguments are orthogonal and normalized.
  270. void LLCoordFrame::setAxes(const LLVector3 &x_axis,
  271.   const LLVector3 &y_axis,
  272.   const LLVector3 &z_axis)
  273. {
  274. mXAxis = x_axis;
  275. mYAxis = y_axis;
  276. mZAxis = z_axis;
  277. if( !isFinite() )
  278. {
  279. reset();
  280. llwarns << "Non Finite in LLCoordFrame::setAxes()" << llendl;
  281. }
  282. }
  285. void LLCoordFrame::setAxes(const LLMatrix3 &rotation_matrix)
  286. {
  287. mXAxis.setVec(rotation_matrix.mMatrix[VX]);
  288. mYAxis.setVec(rotation_matrix.mMatrix[VY]);
  289. mZAxis.setVec(rotation_matrix.mMatrix[VZ]);
  290. if( !isFinite() )
  291. {
  292. reset();
  293. llwarns << "Non Finite in LLCoordFrame::setAxes()" << llendl;
  294. }
  295. }
  298. void LLCoordFrame::setAxes(const LLQuaternion &q )
  299. {
  300. LLMatrix3 rotation_matrix(q);
  301. setAxes(rotation_matrix);
  302. if( !isFinite() )
  303. {
  304. reset();
  305. llwarns << "Non Finite in LLCoordFrame::setAxes()" << llendl;
  306. }
  307. }
  310. void LLCoordFrame::setAxes(  const F32 *rotation_matrix ) 
  311. {
  312. mXAxis.mV[VX] = *(rotation_matrix + 3*VX + VX);
  313. mXAxis.mV[VY] = *(rotation_matrix + 3*VX + VY);
  314. mXAxis.mV[VZ] = *(rotation_matrix + 3*VX + VZ);
  315. mYAxis.mV[VX] = *(rotation_matrix + 3*VY + VX);
  316. mYAxis.mV[VY] = *(rotation_matrix + 3*VY + VY);
  317. mYAxis.mV[VZ] = *(rotation_matrix + 3*VY + VZ);
  318. mZAxis.mV[VX] = *(rotation_matrix + 3*VZ + VX);
  319. mZAxis.mV[VY] = *(rotation_matrix + 3*VZ + VY);
  320. mZAxis.mV[VZ] = *(rotation_matrix + 3*VZ + VZ);
  322. if( !isFinite() )
  323. {
  324. reset();
  325. llwarns << "Non Finite in LLCoordFrame::setAxes()" << llendl;
  326. }
  327. }
  330. void LLCoordFrame::setAxes(const LLCoordFrame &frame)
  331. {
  332. mXAxis = frame.getXAxis();
  333. mYAxis = frame.getYAxis();
  334. mZAxis = frame.getZAxis();
  336. if( !isFinite() )
  337. {
  338. reset();
  339. llwarns << "Non Finite in LLCoordFrame::setAxes()" << llendl;
  340. }
  341. }
  344. // translate() member functions move mOrigin to a relative position
  346. void LLCoordFrame::translate(F32 x, F32 y, F32 z)
  347. {
  348. mOrigin.mV[VX] += x;
  349. mOrigin.mV[VY] += y;
  350. mOrigin.mV[VZ] += z;
  352. if( !mOrigin.isFinite() )
  353. {
  354. reset();
  355. llwarns << "Non Finite in LLCoordFrame::translate()" << llendl;
  356. }
  357. }
  360. void LLCoordFrame::translate(const LLVector3 &v)
  361. {
  362. mOrigin += v;
  364. if( !mOrigin.isFinite() )
  365. {
  366. reset();
  367. llwarns << "Non Finite in LLCoordFrame::translate()" << llendl;
  368. }
  369. }
  372. void LLCoordFrame::translate(const F32 *origin)
  373. {
  374. mOrigin.mV[VX] += *(origin + VX);
  375. mOrigin.mV[VY] += *(origin + VY);
  376. mOrigin.mV[VZ] += *(origin + VZ);
  378. if( !mOrigin.isFinite() )
  379. {
  380. reset();
  381. llwarns << "Non Finite in LLCoordFrame::translate()" << llendl;
  382. }
  383. }
  386. // Rotate move the axes to a relative rotation
  388. void LLCoordFrame::rotate(F32 angle, F32 x, F32 y, F32 z)
  389. {
  390. LLQuaternion q(angle, LLVector3(x,y,z));
  391. rotate(q);
  392. }
  395. void LLCoordFrame::rotate(F32 angle, const LLVector3 &rotation_axis)
  396. {
  397. LLQuaternion q(angle, rotation_axis);
  398. rotate(q);
  399. }
  402. void LLCoordFrame::rotate(const LLQuaternion &q)
  403. {
  404. LLMatrix3 rotation_matrix(q);
  405. rotate(rotation_matrix);
  406. }
  409. void LLCoordFrame::rotate(const LLMatrix3 &rotation_matrix)
  410. {
  411. mXAxis.rotVec(rotation_matrix);
  412. mYAxis.rotVec(rotation_matrix);
  413. orthonormalize();
  415. if( !isFinite() )
  416. {
  417. reset();
  418. llwarns << "Non Finite in LLCoordFrame::rotate()" << llendl;
  419. }
  420. }
  423. void LLCoordFrame::roll(F32 angle)
  424. {
  425. LLQuaternion q(angle, mXAxis);
  426. LLMatrix3 rotation_matrix(q);
  427. rotate(rotation_matrix);
  429. if( !mYAxis.isFinite() || !mZAxis.isFinite() )
  430. {
  431. reset();
  432. llwarns << "Non Finite in LLCoordFrame::roll()" << llendl;
  433. }
  434. }
  436. void LLCoordFrame::pitch(F32 angle)
  437. {
  438. LLQuaternion q(angle, mYAxis);
  439. LLMatrix3 rotation_matrix(q);
  440. rotate(rotation_matrix);
  442. if( !mXAxis.isFinite() || !mZAxis.isFinite() )
  443. {
  444. reset();
  445. llwarns << "Non Finite in LLCoordFrame::pitch()" << llendl;
  446. }
  447. }
  449. void LLCoordFrame::yaw(F32 angle)
  450. {
  451. LLQuaternion q(angle, mZAxis);
  452. LLMatrix3 rotation_matrix(q);
  453. rotate(rotation_matrix);
  455. if( !mXAxis.isFinite() || !mYAxis.isFinite() )
  456. {
  457. reset();
  458. llwarns << "Non Finite in LLCoordFrame::yaw()" << llendl;
  459. }
  460. }
  462. // get*() routines
  465. LLQuaternion LLCoordFrame::getQuaternion() const
  466. {
  467. LLQuaternion quat(mXAxis, mYAxis, mZAxis);
  468. return quat;
  469. }
  472. void LLCoordFrame::getMatrixToLocal(LLMatrix4& mat) const
  473. {
  474. mat.setFwdCol(mXAxis);
  475. mat.setLeftCol(mYAxis);
  476. mat.setUpCol(mZAxis);
  478. mat.mMatrix[3][0] = -(mOrigin * LLVector3(mat.mMatrix[0][0], mat.mMatrix[1][0], mat.mMatrix[2][0]));
  479. mat.mMatrix[3][1] = -(mOrigin * LLVector3(mat.mMatrix[0][1], mat.mMatrix[1][1], mat.mMatrix[2][1]));
  480. mat.mMatrix[3][2] = -(mOrigin * LLVector3(mat.mMatrix[0][2], mat.mMatrix[1][2], mat.mMatrix[2][2]));
  481. }
  484. void LLCoordFrame::getRotMatrixToParent(LLMatrix4& mat) const
  485. {
  486. // Note: moves into CFR
  487. mat.setFwdRow( -mYAxis );
  488. mat.setLeftRow(  mZAxis );
  489. mat.setUpRow( -mXAxis );
  490. }
  492. size_t LLCoordFrame::writeOrientation(char *buffer) const
  493. {
  494. memcpy(buffer, mOrigin.mV, 3*sizeof(F32)); /*Flawfinder: ignore */
  495. buffer += 3*sizeof(F32);
  496. memcpy(buffer, mXAxis.mV, 3*sizeof(F32)); /*Flawfinder: ignore */
  497. buffer += 3*sizeof(F32);
  498. memcpy(buffer, mYAxis.mV, 3*sizeof(F32));/*Flawfinder: ignore */
  499. buffer += 3*sizeof(F32);
  500. memcpy(buffer, mZAxis.mV, 3*sizeof(F32)); /*Flawfinder: ignore */
  501. return 12*sizeof(F32);
  502. }
  505. size_t LLCoordFrame::readOrientation(const char *buffer)
  506. {
  507. memcpy(mOrigin.mV, buffer, 3*sizeof(F32)); /*Flawfinder: ignore */
  508. buffer += 3*sizeof(F32);
  509. memcpy(mXAxis.mV, buffer, 3*sizeof(F32)); /*Flawfinder: ignore */
  510. buffer += 3*sizeof(F32);
  511. memcpy(mYAxis.mV, buffer, 3*sizeof(F32)); /*Flawfinder: ignore */
  512. buffer += 3*sizeof(F32);
  513. memcpy(mZAxis.mV, buffer, 3*sizeof(F32)); /*Flawfinder: ignore */
  515. if( !isFinite() )
  516. {
  517. reset();
  518. llwarns << "Non Finite in LLCoordFrame::readOrientation()" << llendl;
  519. }
  521. return 12*sizeof(F32);
  522. }
  525. // rotation and transform vectors between reference frames
  527. LLVector3 LLCoordFrame::rotateToLocal(const LLVector3 &absolute_vector) const
  528. {
  529. LLVector3 local_vector(mXAxis * absolute_vector,
  530.    mYAxis * absolute_vector,
  531.    mZAxis * absolute_vector);
  532. return local_vector;
  533. }
  536. LLVector4 LLCoordFrame::rotateToLocal(const LLVector4 &absolute_vector) const
  537. {
  538. LLVector4 local_vector;
  539. local_vector.mV[VX] = mXAxis.mV[VX] * absolute_vector.mV[VX] +
  540.   mXAxis.mV[VY] * absolute_vector.mV[VY] +
  541.   mXAxis.mV[VZ] * absolute_vector.mV[VZ];
  542. local_vector.mV[VY] = mYAxis.mV[VX] * absolute_vector.mV[VX] +
  543.   mYAxis.mV[VY] * absolute_vector.mV[VY] +
  544.   mYAxis.mV[VZ] * absolute_vector.mV[VZ];
  545. local_vector.mV[VZ] = mZAxis.mV[VX] * absolute_vector.mV[VX] +
  546.   mZAxis.mV[VY] * absolute_vector.mV[VY] +
  547.   mZAxis.mV[VZ] * absolute_vector.mV[VZ];
  548. local_vector.mV[VW] = absolute_vector.mV[VW];
  549. return local_vector;
  550. }
  553. LLVector3 LLCoordFrame::rotateToAbsolute(const LLVector3 &local_vector) const
  554. {
  555. LLVector3 absolute_vector;
  556. absolute_vector.mV[VX] = mXAxis.mV[VX] * local_vector.mV[VX] +
  557.  mYAxis.mV[VX] * local_vector.mV[VY] +
  558.  mZAxis.mV[VX] * local_vector.mV[VZ];
  559. absolute_vector.mV[VY] = mXAxis.mV[VY] * local_vector.mV[VX] +
  560.  mYAxis.mV[VY] * local_vector.mV[VY] +
  561.  mZAxis.mV[VY] * local_vector.mV[VZ];
  562. absolute_vector.mV[VZ] = mXAxis.mV[VZ] * local_vector.mV[VX] +
  563.  mYAxis.mV[VZ] * local_vector.mV[VY] +
  564.  mZAxis.mV[VZ] * local_vector.mV[VZ];
  565. return absolute_vector;
  566. }
  569. LLVector4 LLCoordFrame::rotateToAbsolute(const LLVector4 &local_vector) const
  570. {
  571. LLVector4 absolute_vector;
  572. absolute_vector.mV[VX] = mXAxis.mV[VX] * local_vector.mV[VX] +
  573.  mYAxis.mV[VX] * local_vector.mV[VY] +
  574.  mZAxis.mV[VX] * local_vector.mV[VZ];
  575. absolute_vector.mV[VY] = mXAxis.mV[VY] * local_vector.mV[VX] +
  576.  mYAxis.mV[VY] * local_vector.mV[VY] +
  577.  mZAxis.mV[VY] * local_vector.mV[VZ];
  578. absolute_vector.mV[VZ] = mXAxis.mV[VZ] * local_vector.mV[VX] +
  579.  mYAxis.mV[VZ] * local_vector.mV[VY] +
  580.  mZAxis.mV[VZ] * local_vector.mV[VZ];
  581. absolute_vector.mV[VW] = local_vector[VW];
  582. return absolute_vector;
  583. }
  586. void LLCoordFrame::orthonormalize()
  587. // Makes sure the axes are orthogonal and normalized.
  588. {
  589. mXAxis.normVec(); // X is renormalized
  590. mYAxis -= mXAxis * (mXAxis * mYAxis); // Y remains in X-Y plane
  591. mYAxis.normVec(); // Y is normalized
  592. mZAxis = mXAxis % mYAxis; // Z = X cross Y
  593. }
  596. LLVector3 LLCoordFrame::transformToLocal(const LLVector3 &absolute_vector) const
  597. {
  598. return rotateToLocal(absolute_vector - mOrigin);
  599. }
  602. LLVector4 LLCoordFrame::transformToLocal(const LLVector4 &absolute_vector) const
  603. {
  604. LLVector4 local_vector(absolute_vector);
  605. local_vector.mV[VX] -= mOrigin.mV[VX];
  606. local_vector.mV[VY] -= mOrigin.mV[VY];
  607. local_vector.mV[VZ] -= mOrigin.mV[VZ];
  608. return rotateToLocal(local_vector);
  609. }
  612. LLVector3 LLCoordFrame::transformToAbsolute(const LLVector3 &local_vector) const
  613. {
  614. return (rotateToAbsolute(local_vector) + mOrigin);
  615. }
  618. LLVector4 LLCoordFrame::transformToAbsolute(const LLVector4 &local_vector) const
  619. {
  620. LLVector4 absolute_vector;
  621. absolute_vector = rotateToAbsolute(local_vector);
  622. absolute_vector.mV[VX] += mOrigin.mV[VX];
  623. absolute_vector.mV[VY] += mOrigin.mV[VY];
  624. absolute_vector.mV[VZ] += mOrigin.mV[VZ];
  625. return absolute_vector;
  626. }
  629. // This is how you combine a translation and rotation of a 
  630. // coordinate frame to get an OpenGL transformation matrix:
  631. //
  632. //     translation   *   rotation      =          transformation matrix
  633. //
  634. //     (i)->
  635. // (j)| 1  0  0  0 |   | a  d  g  0 |     |     a            d            g          0 |
  636. //  | | 0  1  0  0 | * | b  e  h  0 |  =  |     b            e            h          0 |
  637. //  V | 0  0  1  0 |   | c  f  i  0 |     |     c            f            i          0 |
  638. //    |-x -y -z  1 |   | 0  0  0  1 |     |-(ax+by+cz)  -(dx+ey+fz)  -(gx+hy+iz)     1 |
  639. //
  640. // where {a,b,c} = x-axis 
  641. //       {d,e,f} = y-axis 
  642. //       {g,h,i} = z-axis 
  643. //       {x,y,z} = origin
  645. void LLCoordFrame::getOpenGLTranslation(F32 *ogl_matrix) const
  646. {
  647. *(ogl_matrix + 0)  = 1.0f;
  648. *(ogl_matrix + 1)  = 0.0f;
  649. *(ogl_matrix + 2)  = 0.0f;
  650. *(ogl_matrix + 3)  = 0.0f;
  652. *(ogl_matrix + 4)  = 0.0f;
  653. *(ogl_matrix + 5)  = 1.0f;
  654. *(ogl_matrix + 6)  = 0.0f;
  655. *(ogl_matrix + 7)  = 0.0f;
  657. *(ogl_matrix + 8)  = 0.0f;
  658. *(ogl_matrix + 9)  = 0.0f;
  659. *(ogl_matrix + 10) = 1.0f;
  660. *(ogl_matrix + 11) = 0.0f;
  662. *(ogl_matrix + 12) = -mOrigin.mV[VX];
  663. *(ogl_matrix + 13) = -mOrigin.mV[VY];
  664. *(ogl_matrix + 14) = -mOrigin.mV[VZ];
  665. *(ogl_matrix + 15) = 1.0f;
  666. }
  669. void LLCoordFrame::getOpenGLRotation(F32 *ogl_matrix) const
  670. {
  671. *(ogl_matrix + 0)  = mXAxis.mV[VX];
  672. *(ogl_matrix + 4)  = mXAxis.mV[VY];
  673. *(ogl_matrix + 8)  = mXAxis.mV[VZ];
  675. *(ogl_matrix + 1)  = mYAxis.mV[VX];
  676. *(ogl_matrix + 5)  = mYAxis.mV[VY];
  677. *(ogl_matrix + 9)  = mYAxis.mV[VZ];
  679. *(ogl_matrix + 2)  = mZAxis.mV[VX];
  680. *(ogl_matrix + 6)  = mZAxis.mV[VY];
  681. *(ogl_matrix + 10) = mZAxis.mV[VZ];
  683. *(ogl_matrix + 3)  = 0.0f;
  684. *(ogl_matrix + 7)  = 0.0f;
  685. *(ogl_matrix + 11) = 0.0f;
  687. *(ogl_matrix + 12) = 0.0f;
  688. *(ogl_matrix + 13) = 0.0f;
  689. *(ogl_matrix + 14) = 0.0f;
  690. *(ogl_matrix + 15) = 1.0f;
  691. }
  694. void LLCoordFrame::getOpenGLTransform(F32 *ogl_matrix) const
  695. {
  696. *(ogl_matrix + 0)  = mXAxis.mV[VX];
  697. *(ogl_matrix + 4)  = mXAxis.mV[VY];
  698. *(ogl_matrix + 8)  = mXAxis.mV[VZ];
  699. *(ogl_matrix + 12) = -mOrigin * mXAxis;
  701. *(ogl_matrix + 1)  = mYAxis.mV[VX];
  702. *(ogl_matrix + 5)  = mYAxis.mV[VY];
  703. *(ogl_matrix + 9)  = mYAxis.mV[VZ];
  704. *(ogl_matrix + 13) = -mOrigin * mYAxis;
  706. *(ogl_matrix + 2)  = mZAxis.mV[VX];
  707. *(ogl_matrix + 6)  = mZAxis.mV[VY];
  708. *(ogl_matrix + 10) = mZAxis.mV[VZ];
  709. *(ogl_matrix + 14) = -mOrigin * mZAxis;
  711. *(ogl_matrix + 3)  = 0.0f;
  712. *(ogl_matrix + 7)  = 0.0f;
  713. *(ogl_matrix + 11) = 0.0f;
  714. *(ogl_matrix + 15) = 1.0f;
  715. }
  718. // at and up_direction are presumed to be normalized
  719. void LLCoordFrame::lookDir(const LLVector3 &at, const LLVector3 &up_direction)
  720. {
  721. // Make sure 'at' and 'up_direction' are not parallel
  722. // and that neither are zero-length vectors
  723. LLVector3 left(up_direction % at);
  724. if (left.isNull()) 
  725. {
  726. //tweak lookat pos so we don't get a degenerate matrix
  727. LLVector3 tempat(at[VX] + 0.01f, at[VY], at[VZ]);
  728. tempat.normVec();
  729. left = (up_direction % tempat);
  730. }
  731. left.normVec();
  733. LLVector3 up = at % left;
  735. if (at.isFinite() && left.isFinite() && up.isFinite())
  736. {
  737. setAxes(at, left, up);
  738. }
  739. }
  741. void LLCoordFrame::lookDir(const LLVector3 &xuv)
  742. {
  743. static LLVector3 up_direction(0.0f, 0.0f, 1.0f);
  744. lookDir(xuv, up_direction);
  745. }
  747. void LLCoordFrame::lookAt(const LLVector3 &origin, const LLVector3 &point_of_interest, const LLVector3 &up_direction)
  748. {
  749. setOrigin(origin);
  750. LLVector3 at(point_of_interest - origin);
  751. at.normVec();
  752. lookDir(at, up_direction);
  753. }
  755. void LLCoordFrame::lookAt(const LLVector3 &origin, const LLVector3 &point_of_interest)
  756. {
  757. static LLVector3 up_direction(0.0f, 0.0f, 1.0f);
  759. setOrigin(origin);
  760. LLVector3 at(point_of_interest - origin);
  761. at.normVec();
  762. lookDir(at, up_direction);
  763. }
  766. // Operators and friends
  768. std::ostream& operator<<(std::ostream &s, const LLCoordFrame &C)
  769. {
  770. s << "{ "
  771.   << " origin = " << C.mOrigin
  772.   << " x_axis = " << C.mXAxis
  773.   << " y_axis = " << C.mYAxis
  774.   << " z_axis = " << C.mZAxis
  775. << " }";
  776. return s;
  777. }
  781. // Private member functions
  784. //EOF