llcoordframe.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:8k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llcoordframe.h
  3.  * @brief LLCoordFrame class header file.
  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.  */
  32. #ifndef LL_COORDFRAME_H
  33. #define LL_COORDFRAME_H
  34. #include "v3math.h"
  35. #include "v4math.h"
  36. #include "llerror.h"
  37. // XXX : The constructors of the LLCoordFrame class assume that all vectors
  38. //  and quaternion being passed as arguments are normalized, and all matrix 
  39. //   arguments are unitary.  VERY BAD things will happen if these assumptions fail.
  40. //  Also, segfault hazzards exist in methods that accept F32* arguments.
  41. class LLCoordFrame 
  42. {
  43. public:
  44. LLCoordFrame(); // Inits at zero with identity rotation
  45. explicit LLCoordFrame(const LLVector3 &origin); // Sets origin, and inits rotation = Identity
  46. LLCoordFrame(const LLVector3 &x_axis, 
  47.  const LLVector3 &y_axis, 
  48.  const LLVector3 &z_axis); // Sets coordinate axes and inits origin at zero
  49. LLCoordFrame(const LLVector3 &origin, 
  50.  const LLVector3 &x_axis, 
  51.  const LLVector3 &y_axis, 
  52.  const LLVector3 &z_axis); // Sets the origin and coordinate axes
  53. LLCoordFrame(const LLVector3 &origin, 
  54.  const LLMatrix3 &rotation); // Sets axes to 3x3 matrix
  55. LLCoordFrame(const LLVector3 &origin, 
  56.  const LLVector3 &direction); // Sets origin and calls lookDir(direction)
  57. explicit LLCoordFrame(const LLQuaternion &q); // Sets axes using q and inits mOrigin to zero 
  58. LLCoordFrame(const LLVector3 &origin, 
  59.  const LLQuaternion &q); // Uses quaternion to init axes
  60. explicit LLCoordFrame(const LLMatrix4 &mat); // Extracts frame from a 4x4 matrix
  61. // The folowing two constructors are dangerous due to implicit casting and have been disabled - SJB
  62. //LLCoordFrame(const F32 *origin, const F32 *rotation); // Assumes "origin" is 1x3 and "rotation" is 1x9 array
  63. //LLCoordFrame(const F32 *origin_and_rotation); // Assumes "origin_and_rotation" is 1x12 array
  64. BOOL isFinite() { return mOrigin.isFinite() && mXAxis.isFinite() && mYAxis.isFinite() && mZAxis.isFinite(); }
  65. void reset();
  66. void resetAxes();
  67. void setOrigin(F32 x, F32 y, F32 z); // Set mOrigin
  68. void setOrigin(const LLVector3 &origin);
  69. void setOrigin(const F32 *origin);
  70. void setOrigin(const LLCoordFrame &frame);
  71. inline void setOriginX(F32 x) { mOrigin.mV[VX] = x; }
  72. inline void setOriginY(F32 y) { mOrigin.mV[VY] = y; }
  73. inline void setOriginZ(F32 z) { mOrigin.mV[VZ] = z; }
  74. void setAxes(const LLVector3 &x_axis,  // Set axes
  75.  const LLVector3 &y_axis, 
  76.  const LLVector3 &z_axis);
  77. void setAxes(const LLMatrix3 &rotation_matrix);
  78. void setAxes(const LLQuaternion &q);
  79. void setAxes(const F32 *rotation_matrix);
  80. void setAxes(const LLCoordFrame &frame);
  81. void translate(F32 x, F32 y, F32 z); // Move mOrgin
  82. void translate(const LLVector3 &v);
  83. void translate(const F32 *origin);
  84. void rotate(F32 angle, F32 x, F32 y, F32 z); // Move axes
  85. void rotate(F32 angle, const LLVector3 &rotation_axis);
  86. void rotate(const LLQuaternion &q);
  87. void rotate(const LLMatrix3 &m);
  88. void orthonormalize(); // Makes sure axes are unitary and orthogonal.
  89. // These methods allow rotations in the LLCoordFrame's frame
  90. void roll(F32 angle); // RH rotation about mXAxis, radians
  91. void pitch(F32 angle); // RH rotation about mYAxis, radians
  92. void yaw(F32 angle); // RH rotation about mZAxis, radians
  93. inline const LLVector3 &getOrigin() const { return mOrigin; }
  94. inline const LLVector3 &getXAxis() const  { return mXAxis; }
  95. inline const LLVector3 &getYAxis() const  { return mYAxis; }
  96. inline const LLVector3 &getZAxis() const  { return mZAxis; }
  97. inline const LLVector3 &getAtAxis() const   { return mXAxis; }
  98. inline const LLVector3 &getLeftAxis() const { return mYAxis; }
  99. inline const LLVector3 &getUpAxis() const   { return mZAxis; }
  100. // These return representations of the rotation or orientation of the LLFrame
  101. // it its absolute frame.  That is, these rotations acting on the X-axis {1,0,0}
  102. // will produce the mXAxis.
  103. // LLMatrix3 getMatrix3() const; // Returns axes in 3x3 matrix 
  104. LLQuaternion getQuaternion() const; // Returns axes in quaternion form
  105. // Same as above, except it also includes the translation of the LLFrame
  106. // LLMatrix4 getMatrix4() const; // Returns position and axes in 4x4 matrix
  107. // Returns matrix which expresses point in local frame in the parent frame
  108. void getMatrixToParent(LLMatrix4 &mat) const;
  109. // Returns matrix which expresses point in parent frame in the local frame
  110. void getMatrixToLocal(LLMatrix4 &mat) const; // Returns matrix which expresses point in parent frame in the local frame
  111. void getRotMatrixToParent(LLMatrix4 &mat) const;
  112. // Copies mOrigin, then the three axes to buffer, returns number of bytes copied.
  113. size_t writeOrientation(char *buffer) const;
  114. // Copies mOrigin, then the three axes from buffer, returns the number of bytes copied.
  115. // Assumes the data in buffer is correct.
  116. size_t readOrientation(const char *buffer);
  117. LLVector3 rotateToLocal(const LLVector3 &v) const; // Returns v' rotated to local
  118. LLVector4 rotateToLocal(const LLVector4 &v) const; // Returns v' rotated to local
  119. LLVector3 rotateToAbsolute(const LLVector3 &v) const; // Returns v' rotated to absolute
  120. LLVector4 rotateToAbsolute(const LLVector4 &v) const; // Returns v' rotated to absolute
  121. LLVector3 transformToLocal(const LLVector3 &v) const; // Returns v' in local coord
  122. LLVector4 transformToLocal(const LLVector4 &v) const; // Returns v' in local coord
  123. LLVector3 transformToAbsolute(const LLVector3 &v) const; // Returns v' in absolute coord
  124. LLVector4 transformToAbsolute(const LLVector4 &v) const; // Returns v' in absolute coord
  125. // Write coord frame orientation into provided array in OpenGL matrix format.
  126. void getOpenGLTranslation(F32 *ogl_matrix) const;
  127. void getOpenGLRotation(F32 *ogl_matrix) const;
  128. void getOpenGLTransform(F32 *ogl_matrix) const;
  129. // lookDir orients to (xuv, presumed normalized) and does not affect origin
  130. void lookDir(const LLVector3 &xuv, const LLVector3 &up);
  131. void lookDir(const LLVector3 &xuv); // up = 0,0,1
  132. // lookAt orients to (point_of_interest - origin) and sets origin
  133. void lookAt(const LLVector3 &origin, const LLVector3 &point_of_interest, const LLVector3 &up);
  134. void lookAt(const LLVector3 &origin, const LLVector3 &point_of_interest); // up = 0,0,1
  135. // deprecated
  136. void setOriginAndLookAt(const LLVector3 &origin, const LLVector3 &up, const LLVector3 &point_of_interest)
  137. {
  138. lookAt(origin, point_of_interest, up);
  139. }
  140. friend std::ostream& operator<<(std::ostream &s, const LLCoordFrame &C);
  141. // These vectors are in absolute frame
  142. LLVector3 mOrigin;
  143. LLVector3 mXAxis;
  144. LLVector3 mYAxis;
  145. LLVector3 mZAxis;
  146. };
  147. #endif