summaryrefslogtreecommitdiff
path: root/indra/llmath/llcoordframe.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'indra/llmath/llcoordframe.cpp')
-rw-r--r--indra/llmath/llcoordframe.cpp626
1 files changed, 313 insertions, 313 deletions
diff --git a/indra/llmath/llcoordframe.cpp b/indra/llmath/llcoordframe.cpp
index b25fd948f5..4d6276b2cd 100644
--- a/indra/llmath/llcoordframe.cpp
+++ b/indra/llmath/llcoordframe.cpp
@@ -1,25 +1,25 @@
-/**
+/**
* @file llcoordframe.cpp
* @brief LLCoordFrame class implementation.
*
* $LicenseInfo:firstyear=2000&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, Linden Research, Inc.
- *
+ *
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
- *
+ *
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
- *
+ *
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- *
+ *
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
@@ -49,168 +49,168 @@
}
#ifndef X_AXIS
- #define X_AXIS 1.0f,0.0f,0.0f
- #define Y_AXIS 0.0f,1.0f,0.0f
- #define Z_AXIS 0.0f,0.0f,1.0f
+ #define X_AXIS 1.0f,0.0f,0.0f
+ #define Y_AXIS 0.0f,1.0f,0.0f
+ #define Z_AXIS 0.0f,0.0f,1.0f
#endif
// Constructors
LLCoordFrame::LLCoordFrame() :
- mOrigin(0.f, 0.f, 0.f),
- mXAxis(X_AXIS),
- mYAxis(Y_AXIS),
- mZAxis(Z_AXIS)
+ mOrigin(0.f, 0.f, 0.f),
+ mXAxis(X_AXIS),
+ mYAxis(Y_AXIS),
+ mZAxis(Z_AXIS)
{
}
LLCoordFrame::LLCoordFrame(const LLVector3 &origin) :
- mOrigin(origin),
- mXAxis(X_AXIS),
- mYAxis(Y_AXIS),
- mZAxis(Z_AXIS)
+ mOrigin(origin),
+ mXAxis(X_AXIS),
+ mYAxis(Y_AXIS),
+ mZAxis(Z_AXIS)
{
CHECK_FINITE(mOrigin);
}
LLCoordFrame::LLCoordFrame(const LLVector3 &origin, const LLVector3 &direction) :
- mOrigin(origin)
+ mOrigin(origin)
{
- lookDir(direction);
-
+ lookDir(direction);
+
CHECK_FINITE_OBJ();
}
LLCoordFrame::LLCoordFrame(const LLVector3 &x_axis,
- const LLVector3 &y_axis,
- const LLVector3 &z_axis) :
- mOrigin(0.f, 0.f, 0.f),
- mXAxis(x_axis),
- mYAxis(y_axis),
- mZAxis(z_axis)
+ const LLVector3 &y_axis,
+ const LLVector3 &z_axis) :
+ mOrigin(0.f, 0.f, 0.f),
+ mXAxis(x_axis),
+ mYAxis(y_axis),
+ mZAxis(z_axis)
{
- CHECK_FINITE_OBJ();
+ CHECK_FINITE_OBJ();
}
LLCoordFrame::LLCoordFrame(const LLVector3 &origin,
- const LLVector3 &x_axis,
- const LLVector3 &y_axis,
- const LLVector3 &z_axis) :
- mOrigin(origin),
- mXAxis(x_axis),
- mYAxis(y_axis),
- mZAxis(z_axis)
+ const LLVector3 &x_axis,
+ const LLVector3 &y_axis,
+ const LLVector3 &z_axis) :
+ mOrigin(origin),
+ mXAxis(x_axis),
+ mYAxis(y_axis),
+ mZAxis(z_axis)
{
- CHECK_FINITE_OBJ();
+ CHECK_FINITE_OBJ();
}
-LLCoordFrame::LLCoordFrame(const LLVector3 &origin,
- const LLMatrix3 &rotation) :
- mOrigin(origin),
- mXAxis(rotation.mMatrix[VX]),
- mYAxis(rotation.mMatrix[VY]),
- mZAxis(rotation.mMatrix[VZ])
+LLCoordFrame::LLCoordFrame(const LLVector3 &origin,
+ const LLMatrix3 &rotation) :
+ mOrigin(origin),
+ mXAxis(rotation.mMatrix[VX]),
+ mYAxis(rotation.mMatrix[VY]),
+ mZAxis(rotation.mMatrix[VZ])
{
- CHECK_FINITE_OBJ();
+ CHECK_FINITE_OBJ();
}
LLCoordFrame::LLCoordFrame(const LLQuaternion &q) :
- mOrigin(0.f, 0.f, 0.f)
+ mOrigin(0.f, 0.f, 0.f)
{
- LLMatrix3 rotation_matrix(q);
- mXAxis.setVec(rotation_matrix.mMatrix[VX]);
- mYAxis.setVec(rotation_matrix.mMatrix[VY]);
- mZAxis.setVec(rotation_matrix.mMatrix[VZ]);
+ LLMatrix3 rotation_matrix(q);
+ mXAxis.setVec(rotation_matrix.mMatrix[VX]);
+ mYAxis.setVec(rotation_matrix.mMatrix[VY]);
+ mZAxis.setVec(rotation_matrix.mMatrix[VZ]);
- CHECK_FINITE_OBJ();
+ CHECK_FINITE_OBJ();
}
LLCoordFrame::LLCoordFrame(const LLVector3 &origin, const LLQuaternion &q) :
- mOrigin(origin)
+ mOrigin(origin)
{
- LLMatrix3 rotation_matrix(q);
- mXAxis.setVec(rotation_matrix.mMatrix[VX]);
- mYAxis.setVec(rotation_matrix.mMatrix[VY]);
- mZAxis.setVec(rotation_matrix.mMatrix[VZ]);
+ LLMatrix3 rotation_matrix(q);
+ mXAxis.setVec(rotation_matrix.mMatrix[VX]);
+ mYAxis.setVec(rotation_matrix.mMatrix[VY]);
+ mZAxis.setVec(rotation_matrix.mMatrix[VZ]);
- CHECK_FINITE_OBJ();
+ CHECK_FINITE_OBJ();
}
LLCoordFrame::LLCoordFrame(const LLMatrix4 &mat) :
- mOrigin(mat.mMatrix[VW]),
- mXAxis(mat.mMatrix[VX]),
- mYAxis(mat.mMatrix[VY]),
- mZAxis(mat.mMatrix[VZ])
+ mOrigin(mat.mMatrix[VW]),
+ mXAxis(mat.mMatrix[VX]),
+ mYAxis(mat.mMatrix[VY]),
+ mZAxis(mat.mMatrix[VZ])
{
- CHECK_FINITE_OBJ();
+ CHECK_FINITE_OBJ();
}
// The folowing two constructors are dangerous due to implicit casting and have been disabled - SJB
/*
LLCoordFrame::LLCoordFrame(const F32 *origin, const F32 *rotation) :
- mOrigin(origin),
- mXAxis(rotation+3*VX),
- mYAxis(rotation+3*VY),
- mZAxis(rotation+3*VZ)
+ mOrigin(origin),
+ mXAxis(rotation+3*VX),
+ mYAxis(rotation+3*VY),
+ mZAxis(rotation+3*VZ)
{
- CHECK_FINITE_OBJ();
+ CHECK_FINITE_OBJ();
}
*/
/*
LLCoordFrame::LLCoordFrame(const F32 *origin_and_rotation) :
- mOrigin(origin_and_rotation),
- mXAxis(origin_and_rotation + 3*(VX+1)),
- mYAxis(origin_and_rotation + 3*(VY+1)),
- mZAxis(origin_and_rotation + 3*(VZ+1))
+ mOrigin(origin_and_rotation),
+ mXAxis(origin_and_rotation + 3*(VX+1)),
+ mYAxis(origin_and_rotation + 3*(VY+1)),
+ mZAxis(origin_and_rotation + 3*(VZ+1))
{
- CHECK_FINITE_OBJ();
+ CHECK_FINITE_OBJ();
}
*/
-void LLCoordFrame::reset()
+void LLCoordFrame::reset()
{
- mOrigin.setVec(0.0f, 0.0f, 0.0f);
- resetAxes();
+ mOrigin.setVec(0.0f, 0.0f, 0.0f);
+ resetAxes();
}
void LLCoordFrame::resetAxes()
{
- mXAxis.setVec(1.0f, 0.0f, 0.0f);
- mYAxis.setVec(0.0f, 1.0f, 0.0f);
- mZAxis.setVec(0.0f, 0.0f, 1.0f);
+ mXAxis.setVec(1.0f, 0.0f, 0.0f);
+ mYAxis.setVec(0.0f, 1.0f, 0.0f);
+ mZAxis.setVec(0.0f, 0.0f, 1.0f);
}
// setOrigin() member functions set mOrigin
-void LLCoordFrame::setOrigin(F32 x, F32 y, F32 z)
+void LLCoordFrame::setOrigin(F32 x, F32 y, F32 z)
{
- mOrigin.setVec(x, y, z);
+ mOrigin.setVec(x, y, z);
CHECK_FINITE(mOrigin);
}
void LLCoordFrame::setOrigin(const LLVector3 &new_origin)
{
- mOrigin = new_origin;
- CHECK_FINITE(mOrigin);
+ mOrigin = new_origin;
+ CHECK_FINITE(mOrigin);
}
void LLCoordFrame::setOrigin(const F32 *origin)
{
- mOrigin.mV[VX] = *(origin + VX);
- mOrigin.mV[VY] = *(origin + VY);
- mOrigin.mV[VZ] = *(origin + VZ);
+ mOrigin.mV[VX] = *(origin + VX);
+ mOrigin.mV[VY] = *(origin + VY);
+ mOrigin.mV[VZ] = *(origin + VZ);
CHECK_FINITE(mOrigin);
}
void LLCoordFrame::setOrigin(const LLCoordFrame &frame)
{
- mOrigin = frame.getOrigin();
+ mOrigin = frame.getOrigin();
CHECK_FINITE(mOrigin);
}
@@ -218,79 +218,79 @@ void LLCoordFrame::setOrigin(const LLCoordFrame &frame)
// the arguments are orthogonal and normalized.
void LLCoordFrame::setAxes(const LLVector3 &x_axis,
- const LLVector3 &y_axis,
- const LLVector3 &z_axis)
+ const LLVector3 &y_axis,
+ const LLVector3 &z_axis)
{
- mXAxis = x_axis;
- mYAxis = y_axis;
- mZAxis = z_axis;
- CHECK_FINITE_OBJ();
+ mXAxis = x_axis;
+ mYAxis = y_axis;
+ mZAxis = z_axis;
+ CHECK_FINITE_OBJ();
}
void LLCoordFrame::setAxes(const LLMatrix3 &rotation_matrix)
{
- mXAxis.setVec(rotation_matrix.mMatrix[VX]);
- mYAxis.setVec(rotation_matrix.mMatrix[VY]);
- mZAxis.setVec(rotation_matrix.mMatrix[VZ]);
- CHECK_FINITE_OBJ();
+ mXAxis.setVec(rotation_matrix.mMatrix[VX]);
+ mYAxis.setVec(rotation_matrix.mMatrix[VY]);
+ mZAxis.setVec(rotation_matrix.mMatrix[VZ]);
+ CHECK_FINITE_OBJ();
}
void LLCoordFrame::setAxes(const LLQuaternion &q )
{
- LLMatrix3 rotation_matrix(q);
- setAxes(rotation_matrix);
- CHECK_FINITE_OBJ();
+ LLMatrix3 rotation_matrix(q);
+ setAxes(rotation_matrix);
+ CHECK_FINITE_OBJ();
}
-void LLCoordFrame::setAxes( const F32 *rotation_matrix )
+void LLCoordFrame::setAxes( const F32 *rotation_matrix )
{
- mXAxis.mV[VX] = *(rotation_matrix + 3*VX + VX);
- mXAxis.mV[VY] = *(rotation_matrix + 3*VX + VY);
- mXAxis.mV[VZ] = *(rotation_matrix + 3*VX + VZ);
- mYAxis.mV[VX] = *(rotation_matrix + 3*VY + VX);
- mYAxis.mV[VY] = *(rotation_matrix + 3*VY + VY);
- mYAxis.mV[VZ] = *(rotation_matrix + 3*VY + VZ);
- mZAxis.mV[VX] = *(rotation_matrix + 3*VZ + VX);
- mZAxis.mV[VY] = *(rotation_matrix + 3*VZ + VY);
- mZAxis.mV[VZ] = *(rotation_matrix + 3*VZ + VZ);
+ mXAxis.mV[VX] = *(rotation_matrix + 3*VX + VX);
+ mXAxis.mV[VY] = *(rotation_matrix + 3*VX + VY);
+ mXAxis.mV[VZ] = *(rotation_matrix + 3*VX + VZ);
+ mYAxis.mV[VX] = *(rotation_matrix + 3*VY + VX);
+ mYAxis.mV[VY] = *(rotation_matrix + 3*VY + VY);
+ mYAxis.mV[VZ] = *(rotation_matrix + 3*VY + VZ);
+ mZAxis.mV[VX] = *(rotation_matrix + 3*VZ + VX);
+ mZAxis.mV[VY] = *(rotation_matrix + 3*VZ + VY);
+ mZAxis.mV[VZ] = *(rotation_matrix + 3*VZ + VZ);
- CHECK_FINITE_OBJ();
+ CHECK_FINITE_OBJ();
}
void LLCoordFrame::setAxes(const LLCoordFrame &frame)
{
- mXAxis = frame.getXAxis();
- mYAxis = frame.getYAxis();
- mZAxis = frame.getZAxis();
- CHECK_FINITE_OBJ();
+ mXAxis = frame.getXAxis();
+ mYAxis = frame.getYAxis();
+ mZAxis = frame.getZAxis();
+ CHECK_FINITE_OBJ();
}
// translate() member functions move mOrigin to a relative position
void LLCoordFrame::translate(F32 x, F32 y, F32 z)
{
- mOrigin.mV[VX] += x;
- mOrigin.mV[VY] += y;
- mOrigin.mV[VZ] += z;
+ mOrigin.mV[VX] += x;
+ mOrigin.mV[VY] += y;
+ mOrigin.mV[VZ] += z;
CHECK_FINITE(mOrigin);
}
void LLCoordFrame::translate(const LLVector3 &v)
{
- mOrigin += v;
+ mOrigin += v;
CHECK_FINITE(mOrigin);
}
void LLCoordFrame::translate(const F32 *origin)
{
- mOrigin.mV[VX] += *(origin + VX);
- mOrigin.mV[VY] += *(origin + VY);
- mOrigin.mV[VZ] += *(origin + VZ);
- CHECK_FINITE(mOrigin);
+ mOrigin.mV[VX] += *(origin + VX);
+ mOrigin.mV[VY] += *(origin + VY);
+ mOrigin.mV[VZ] += *(origin + VZ);
+ CHECK_FINITE(mOrigin);
}
@@ -298,58 +298,58 @@ void LLCoordFrame::translate(const F32 *origin)
void LLCoordFrame::rotate(F32 angle, F32 x, F32 y, F32 z)
{
- LLQuaternion q(angle, LLVector3(x,y,z));
- rotate(q);
+ LLQuaternion q(angle, LLVector3(x,y,z));
+ rotate(q);
CHECK_FINITE_OBJ();
}
void LLCoordFrame::rotate(F32 angle, const LLVector3 &rotation_axis)
{
- LLQuaternion q(angle, rotation_axis);
- rotate(q);
+ LLQuaternion q(angle, rotation_axis);
+ rotate(q);
CHECK_FINITE_OBJ();
}
void LLCoordFrame::rotate(const LLQuaternion &q)
{
- LLMatrix3 rotation_matrix(q);
- rotate(rotation_matrix);
+ LLMatrix3 rotation_matrix(q);
+ rotate(rotation_matrix);
CHECK_FINITE_OBJ();
}
void LLCoordFrame::rotate(const LLMatrix3 &rotation_matrix)
{
- mXAxis.rotVec(rotation_matrix);
- mYAxis.rotVec(rotation_matrix);
- orthonormalize();
+ mXAxis.rotVec(rotation_matrix);
+ mYAxis.rotVec(rotation_matrix);
+ orthonormalize();
CHECK_FINITE_OBJ();
}
void LLCoordFrame::roll(F32 angle)
{
- LLQuaternion q(angle, mXAxis);
- LLMatrix3 rotation_matrix(q);
- rotate(rotation_matrix);
+ LLQuaternion q(angle, mXAxis);
+ LLMatrix3 rotation_matrix(q);
+ rotate(rotation_matrix);
CHECK_FINITE_OBJ();
}
void LLCoordFrame::pitch(F32 angle)
{
- LLQuaternion q(angle, mYAxis);
- LLMatrix3 rotation_matrix(q);
- rotate(rotation_matrix);
- CHECK_FINITE_OBJ();
+ LLQuaternion q(angle, mYAxis);
+ LLMatrix3 rotation_matrix(q);
+ rotate(rotation_matrix);
+ CHECK_FINITE_OBJ();
}
void LLCoordFrame::yaw(F32 angle)
{
- LLQuaternion q(angle, mZAxis);
- LLMatrix3 rotation_matrix(q);
- rotate(rotation_matrix);
+ LLQuaternion q(angle, mZAxis);
+ LLMatrix3 rotation_matrix(q);
+ rotate(rotation_matrix);
CHECK_FINITE_OBJ();
}
@@ -358,61 +358,61 @@ void LLCoordFrame::yaw(F32 angle)
LLQuaternion LLCoordFrame::getQuaternion() const
{
- LLQuaternion quat(mXAxis, mYAxis, mZAxis);
- return quat;
+ LLQuaternion quat(mXAxis, mYAxis, mZAxis);
+ return quat;
}
void LLCoordFrame::getMatrixToLocal(LLMatrix4& mat) const
{
- mat.setFwdCol(mXAxis);
- mat.setLeftCol(mYAxis);
- mat.setUpCol(mZAxis);
+ mat.setFwdCol(mXAxis);
+ mat.setLeftCol(mYAxis);
+ mat.setUpCol(mZAxis);
- mat.mMatrix[3][0] = -(mOrigin * LLVector3(mat.mMatrix[0][0], mat.mMatrix[1][0], mat.mMatrix[2][0]));
- mat.mMatrix[3][1] = -(mOrigin * LLVector3(mat.mMatrix[0][1], mat.mMatrix[1][1], mat.mMatrix[2][1]));
- mat.mMatrix[3][2] = -(mOrigin * LLVector3(mat.mMatrix[0][2], mat.mMatrix[1][2], mat.mMatrix[2][2]));
+ mat.mMatrix[3][0] = -(mOrigin * LLVector3(mat.mMatrix[0][0], mat.mMatrix[1][0], mat.mMatrix[2][0]));
+ mat.mMatrix[3][1] = -(mOrigin * LLVector3(mat.mMatrix[0][1], mat.mMatrix[1][1], mat.mMatrix[2][1]));
+ mat.mMatrix[3][2] = -(mOrigin * LLVector3(mat.mMatrix[0][2], mat.mMatrix[1][2], mat.mMatrix[2][2]));
}
void LLCoordFrame::getRotMatrixToParent(LLMatrix4& mat) const
{
- // Note: moves into CFR
- mat.setFwdRow( -mYAxis );
- mat.setLeftRow( mZAxis );
- mat.setUpRow( -mXAxis );
+ // Note: moves into CFR
+ mat.setFwdRow( -mYAxis );
+ mat.setLeftRow( mZAxis );
+ mat.setUpRow( -mXAxis );
}
size_t LLCoordFrame::writeOrientation(char *buffer) const
{
- memcpy(buffer, mOrigin.mV, 3*sizeof(F32)); /*Flawfinder: ignore */
- buffer += 3*sizeof(F32);
- memcpy(buffer, mXAxis.mV, 3*sizeof(F32)); /*Flawfinder: ignore */
- buffer += 3*sizeof(F32);
- memcpy(buffer, mYAxis.mV, 3*sizeof(F32));/*Flawfinder: ignore */
- buffer += 3*sizeof(F32);
- memcpy(buffer, mZAxis.mV, 3*sizeof(F32)); /*Flawfinder: ignore */
- return 12*sizeof(F32);
+ memcpy(buffer, mOrigin.mV, 3*sizeof(F32)); /*Flawfinder: ignore */
+ buffer += 3*sizeof(F32);
+ memcpy(buffer, mXAxis.mV, 3*sizeof(F32)); /*Flawfinder: ignore */
+ buffer += 3*sizeof(F32);
+ memcpy(buffer, mYAxis.mV, 3*sizeof(F32));/*Flawfinder: ignore */
+ buffer += 3*sizeof(F32);
+ memcpy(buffer, mZAxis.mV, 3*sizeof(F32)); /*Flawfinder: ignore */
+ return 12*sizeof(F32);
}
size_t LLCoordFrame::readOrientation(const char *buffer)
{
- memcpy(mOrigin.mV, buffer, 3*sizeof(F32)); /*Flawfinder: ignore */
- buffer += 3*sizeof(F32);
- memcpy(mXAxis.mV, buffer, 3*sizeof(F32)); /*Flawfinder: ignore */
- buffer += 3*sizeof(F32);
- memcpy(mYAxis.mV, buffer, 3*sizeof(F32)); /*Flawfinder: ignore */
- buffer += 3*sizeof(F32);
- memcpy(mZAxis.mV, buffer, 3*sizeof(F32)); /*Flawfinder: ignore */
-
- if( !isFinite() )
- {
- reset();
- LL_WARNS() << "Non Finite in LLCoordFrame::readOrientation()" << LL_ENDL;
- }
+ memcpy(mOrigin.mV, buffer, 3*sizeof(F32)); /*Flawfinder: ignore */
+ buffer += 3*sizeof(F32);
+ memcpy(mXAxis.mV, buffer, 3*sizeof(F32)); /*Flawfinder: ignore */
+ buffer += 3*sizeof(F32);
+ memcpy(mYAxis.mV, buffer, 3*sizeof(F32)); /*Flawfinder: ignore */
+ buffer += 3*sizeof(F32);
+ memcpy(mZAxis.mV, buffer, 3*sizeof(F32)); /*Flawfinder: ignore */
+
+ if( !isFinite() )
+ {
+ reset();
+ LL_WARNS() << "Non Finite in LLCoordFrame::readOrientation()" << LL_ENDL;
+ }
- return 12*sizeof(F32);
+ return 12*sizeof(F32);
}
@@ -420,107 +420,107 @@ size_t LLCoordFrame::readOrientation(const char *buffer)
LLVector3 LLCoordFrame::rotateToLocal(const LLVector3 &absolute_vector) const
{
- LLVector3 local_vector(mXAxis * absolute_vector,
- mYAxis * absolute_vector,
- mZAxis * absolute_vector);
- return local_vector;
+ LLVector3 local_vector(mXAxis * absolute_vector,
+ mYAxis * absolute_vector,
+ mZAxis * absolute_vector);
+ return local_vector;
}
LLVector4 LLCoordFrame::rotateToLocal(const LLVector4 &absolute_vector) const
{
- LLVector4 local_vector;
- local_vector.mV[VX] = mXAxis.mV[VX] * absolute_vector.mV[VX] +
- mXAxis.mV[VY] * absolute_vector.mV[VY] +
- mXAxis.mV[VZ] * absolute_vector.mV[VZ];
- local_vector.mV[VY] = mYAxis.mV[VX] * absolute_vector.mV[VX] +
- mYAxis.mV[VY] * absolute_vector.mV[VY] +
- mYAxis.mV[VZ] * absolute_vector.mV[VZ];
- local_vector.mV[VZ] = mZAxis.mV[VX] * absolute_vector.mV[VX] +
- mZAxis.mV[VY] * absolute_vector.mV[VY] +
- mZAxis.mV[VZ] * absolute_vector.mV[VZ];
- local_vector.mV[VW] = absolute_vector.mV[VW];
- return local_vector;
+ LLVector4 local_vector;
+ local_vector.mV[VX] = mXAxis.mV[VX] * absolute_vector.mV[VX] +
+ mXAxis.mV[VY] * absolute_vector.mV[VY] +
+ mXAxis.mV[VZ] * absolute_vector.mV[VZ];
+ local_vector.mV[VY] = mYAxis.mV[VX] * absolute_vector.mV[VX] +
+ mYAxis.mV[VY] * absolute_vector.mV[VY] +
+ mYAxis.mV[VZ] * absolute_vector.mV[VZ];
+ local_vector.mV[VZ] = mZAxis.mV[VX] * absolute_vector.mV[VX] +
+ mZAxis.mV[VY] * absolute_vector.mV[VY] +
+ mZAxis.mV[VZ] * absolute_vector.mV[VZ];
+ local_vector.mV[VW] = absolute_vector.mV[VW];
+ return local_vector;
}
LLVector3 LLCoordFrame::rotateToAbsolute(const LLVector3 &local_vector) const
{
- LLVector3 absolute_vector;
- absolute_vector.mV[VX] = mXAxis.mV[VX] * local_vector.mV[VX] +
- mYAxis.mV[VX] * local_vector.mV[VY] +
- mZAxis.mV[VX] * local_vector.mV[VZ];
- absolute_vector.mV[VY] = mXAxis.mV[VY] * local_vector.mV[VX] +
- mYAxis.mV[VY] * local_vector.mV[VY] +
- mZAxis.mV[VY] * local_vector.mV[VZ];
- absolute_vector.mV[VZ] = mXAxis.mV[VZ] * local_vector.mV[VX] +
- mYAxis.mV[VZ] * local_vector.mV[VY] +
- mZAxis.mV[VZ] * local_vector.mV[VZ];
- return absolute_vector;
+ LLVector3 absolute_vector;
+ absolute_vector.mV[VX] = mXAxis.mV[VX] * local_vector.mV[VX] +
+ mYAxis.mV[VX] * local_vector.mV[VY] +
+ mZAxis.mV[VX] * local_vector.mV[VZ];
+ absolute_vector.mV[VY] = mXAxis.mV[VY] * local_vector.mV[VX] +
+ mYAxis.mV[VY] * local_vector.mV[VY] +
+ mZAxis.mV[VY] * local_vector.mV[VZ];
+ absolute_vector.mV[VZ] = mXAxis.mV[VZ] * local_vector.mV[VX] +
+ mYAxis.mV[VZ] * local_vector.mV[VY] +
+ mZAxis.mV[VZ] * local_vector.mV[VZ];
+ return absolute_vector;
}
LLVector4 LLCoordFrame::rotateToAbsolute(const LLVector4 &local_vector) const
{
- LLVector4 absolute_vector;
- absolute_vector.mV[VX] = mXAxis.mV[VX] * local_vector.mV[VX] +
- mYAxis.mV[VX] * local_vector.mV[VY] +
- mZAxis.mV[VX] * local_vector.mV[VZ];
- absolute_vector.mV[VY] = mXAxis.mV[VY] * local_vector.mV[VX] +
- mYAxis.mV[VY] * local_vector.mV[VY] +
- mZAxis.mV[VY] * local_vector.mV[VZ];
- absolute_vector.mV[VZ] = mXAxis.mV[VZ] * local_vector.mV[VX] +
- mYAxis.mV[VZ] * local_vector.mV[VY] +
- mZAxis.mV[VZ] * local_vector.mV[VZ];
- absolute_vector.mV[VW] = local_vector[VW];
- return absolute_vector;
+ LLVector4 absolute_vector;
+ absolute_vector.mV[VX] = mXAxis.mV[VX] * local_vector.mV[VX] +
+ mYAxis.mV[VX] * local_vector.mV[VY] +
+ mZAxis.mV[VX] * local_vector.mV[VZ];
+ absolute_vector.mV[VY] = mXAxis.mV[VY] * local_vector.mV[VX] +
+ mYAxis.mV[VY] * local_vector.mV[VY] +
+ mZAxis.mV[VY] * local_vector.mV[VZ];
+ absolute_vector.mV[VZ] = mXAxis.mV[VZ] * local_vector.mV[VX] +
+ mYAxis.mV[VZ] * local_vector.mV[VY] +
+ mZAxis.mV[VZ] * local_vector.mV[VZ];
+ absolute_vector.mV[VW] = local_vector[VW];
+ return absolute_vector;
}
void LLCoordFrame::orthonormalize()
// Makes sure the axes are orthogonal and normalized.
{
- mXAxis.normVec(); // X is renormalized
- mYAxis -= mXAxis * (mXAxis * mYAxis); // Y remains in X-Y plane
- mYAxis.normVec(); // Y is normalized
- mZAxis = mXAxis % mYAxis; // Z = X cross Y
+ mXAxis.normVec(); // X is renormalized
+ mYAxis -= mXAxis * (mXAxis * mYAxis); // Y remains in X-Y plane
+ mYAxis.normVec(); // Y is normalized
+ mZAxis = mXAxis % mYAxis; // Z = X cross Y
}
LLVector3 LLCoordFrame::transformToLocal(const LLVector3 &absolute_vector) const
{
- return rotateToLocal(absolute_vector - mOrigin);
+ return rotateToLocal(absolute_vector - mOrigin);
}
LLVector4 LLCoordFrame::transformToLocal(const LLVector4 &absolute_vector) const
{
- LLVector4 local_vector(absolute_vector);
- local_vector.mV[VX] -= mOrigin.mV[VX];
- local_vector.mV[VY] -= mOrigin.mV[VY];
- local_vector.mV[VZ] -= mOrigin.mV[VZ];
- return rotateToLocal(local_vector);
+ LLVector4 local_vector(absolute_vector);
+ local_vector.mV[VX] -= mOrigin.mV[VX];
+ local_vector.mV[VY] -= mOrigin.mV[VY];
+ local_vector.mV[VZ] -= mOrigin.mV[VZ];
+ return rotateToLocal(local_vector);
}
LLVector3 LLCoordFrame::transformToAbsolute(const LLVector3 &local_vector) const
{
- return (rotateToAbsolute(local_vector) + mOrigin);
+ return (rotateToAbsolute(local_vector) + mOrigin);
}
LLVector4 LLCoordFrame::transformToAbsolute(const LLVector4 &local_vector) const
{
- LLVector4 absolute_vector;
- absolute_vector = rotateToAbsolute(local_vector);
- absolute_vector.mV[VX] += mOrigin.mV[VX];
- absolute_vector.mV[VY] += mOrigin.mV[VY];
- absolute_vector.mV[VZ] += mOrigin.mV[VZ];
- return absolute_vector;
+ LLVector4 absolute_vector;
+ absolute_vector = rotateToAbsolute(local_vector);
+ absolute_vector.mV[VX] += mOrigin.mV[VX];
+ absolute_vector.mV[VY] += mOrigin.mV[VY];
+ absolute_vector.mV[VZ] += mOrigin.mV[VZ];
+ return absolute_vector;
}
-// This is how you combine a translation and rotation of a
+// This is how you combine a translation and rotation of a
// coordinate frame to get an OpenGL transformation matrix:
//
// translation * rotation = transformation matrix
@@ -531,129 +531,129 @@ LLVector4 LLCoordFrame::transformToAbsolute(const LLVector4 &local_vector) const
// V | 0 0 1 0 | | c f i 0 | | c f i 0 |
// |-x -y -z 1 | | 0 0 0 1 | |-(ax+by+cz) -(dx+ey+fz) -(gx+hy+iz) 1 |
//
-// where {a,b,c} = x-axis
-// {d,e,f} = y-axis
-// {g,h,i} = z-axis
+// where {a,b,c} = x-axis
+// {d,e,f} = y-axis
+// {g,h,i} = z-axis
// {x,y,z} = origin
void LLCoordFrame::getOpenGLTranslation(F32 *ogl_matrix) const
{
- *(ogl_matrix + 0) = 1.0f;
- *(ogl_matrix + 1) = 0.0f;
- *(ogl_matrix + 2) = 0.0f;
- *(ogl_matrix + 3) = 0.0f;
+ *(ogl_matrix + 0) = 1.0f;
+ *(ogl_matrix + 1) = 0.0f;
+ *(ogl_matrix + 2) = 0.0f;
+ *(ogl_matrix + 3) = 0.0f;
- *(ogl_matrix + 4) = 0.0f;
- *(ogl_matrix + 5) = 1.0f;
- *(ogl_matrix + 6) = 0.0f;
- *(ogl_matrix + 7) = 0.0f;
+ *(ogl_matrix + 4) = 0.0f;
+ *(ogl_matrix + 5) = 1.0f;
+ *(ogl_matrix + 6) = 0.0f;
+ *(ogl_matrix + 7) = 0.0f;
- *(ogl_matrix + 8) = 0.0f;
- *(ogl_matrix + 9) = 0.0f;
- *(ogl_matrix + 10) = 1.0f;
- *(ogl_matrix + 11) = 0.0f;
+ *(ogl_matrix + 8) = 0.0f;
+ *(ogl_matrix + 9) = 0.0f;
+ *(ogl_matrix + 10) = 1.0f;
+ *(ogl_matrix + 11) = 0.0f;
- *(ogl_matrix + 12) = -mOrigin.mV[VX];
- *(ogl_matrix + 13) = -mOrigin.mV[VY];
- *(ogl_matrix + 14) = -mOrigin.mV[VZ];
- *(ogl_matrix + 15) = 1.0f;
+ *(ogl_matrix + 12) = -mOrigin.mV[VX];
+ *(ogl_matrix + 13) = -mOrigin.mV[VY];
+ *(ogl_matrix + 14) = -mOrigin.mV[VZ];
+ *(ogl_matrix + 15) = 1.0f;
}
void LLCoordFrame::getOpenGLRotation(F32 *ogl_matrix) const
{
- *(ogl_matrix + 0) = mXAxis.mV[VX];
- *(ogl_matrix + 4) = mXAxis.mV[VY];
- *(ogl_matrix + 8) = mXAxis.mV[VZ];
+ *(ogl_matrix + 0) = mXAxis.mV[VX];
+ *(ogl_matrix + 4) = mXAxis.mV[VY];
+ *(ogl_matrix + 8) = mXAxis.mV[VZ];
- *(ogl_matrix + 1) = mYAxis.mV[VX];
- *(ogl_matrix + 5) = mYAxis.mV[VY];
- *(ogl_matrix + 9) = mYAxis.mV[VZ];
+ *(ogl_matrix + 1) = mYAxis.mV[VX];
+ *(ogl_matrix + 5) = mYAxis.mV[VY];
+ *(ogl_matrix + 9) = mYAxis.mV[VZ];
- *(ogl_matrix + 2) = mZAxis.mV[VX];
- *(ogl_matrix + 6) = mZAxis.mV[VY];
- *(ogl_matrix + 10) = mZAxis.mV[VZ];
+ *(ogl_matrix + 2) = mZAxis.mV[VX];
+ *(ogl_matrix + 6) = mZAxis.mV[VY];
+ *(ogl_matrix + 10) = mZAxis.mV[VZ];
- *(ogl_matrix + 3) = 0.0f;
- *(ogl_matrix + 7) = 0.0f;
- *(ogl_matrix + 11) = 0.0f;
+ *(ogl_matrix + 3) = 0.0f;
+ *(ogl_matrix + 7) = 0.0f;
+ *(ogl_matrix + 11) = 0.0f;
- *(ogl_matrix + 12) = 0.0f;
- *(ogl_matrix + 13) = 0.0f;
- *(ogl_matrix + 14) = 0.0f;
- *(ogl_matrix + 15) = 1.0f;
+ *(ogl_matrix + 12) = 0.0f;
+ *(ogl_matrix + 13) = 0.0f;
+ *(ogl_matrix + 14) = 0.0f;
+ *(ogl_matrix + 15) = 1.0f;
}
void LLCoordFrame::getOpenGLTransform(F32 *ogl_matrix) const
{
- *(ogl_matrix + 0) = mXAxis.mV[VX];
- *(ogl_matrix + 4) = mXAxis.mV[VY];
- *(ogl_matrix + 8) = mXAxis.mV[VZ];
- *(ogl_matrix + 12) = -mOrigin * mXAxis;
+ *(ogl_matrix + 0) = mXAxis.mV[VX];
+ *(ogl_matrix + 4) = mXAxis.mV[VY];
+ *(ogl_matrix + 8) = mXAxis.mV[VZ];
+ *(ogl_matrix + 12) = -mOrigin * mXAxis;
- *(ogl_matrix + 1) = mYAxis.mV[VX];
- *(ogl_matrix + 5) = mYAxis.mV[VY];
- *(ogl_matrix + 9) = mYAxis.mV[VZ];
- *(ogl_matrix + 13) = -mOrigin * mYAxis;
+ *(ogl_matrix + 1) = mYAxis.mV[VX];
+ *(ogl_matrix + 5) = mYAxis.mV[VY];
+ *(ogl_matrix + 9) = mYAxis.mV[VZ];
+ *(ogl_matrix + 13) = -mOrigin * mYAxis;
- *(ogl_matrix + 2) = mZAxis.mV[VX];
- *(ogl_matrix + 6) = mZAxis.mV[VY];
- *(ogl_matrix + 10) = mZAxis.mV[VZ];
- *(ogl_matrix + 14) = -mOrigin * mZAxis;
+ *(ogl_matrix + 2) = mZAxis.mV[VX];
+ *(ogl_matrix + 6) = mZAxis.mV[VY];
+ *(ogl_matrix + 10) = mZAxis.mV[VZ];
+ *(ogl_matrix + 14) = -mOrigin * mZAxis;
- *(ogl_matrix + 3) = 0.0f;
- *(ogl_matrix + 7) = 0.0f;
- *(ogl_matrix + 11) = 0.0f;
- *(ogl_matrix + 15) = 1.0f;
+ *(ogl_matrix + 3) = 0.0f;
+ *(ogl_matrix + 7) = 0.0f;
+ *(ogl_matrix + 11) = 0.0f;
+ *(ogl_matrix + 15) = 1.0f;
}
// at and up_direction are presumed to be normalized
void LLCoordFrame::lookDir(const LLVector3 &at, const LLVector3 &up_direction)
{
- // Make sure 'at' and 'up_direction' are not parallel
- // and that neither are zero-length vectors
- LLVector3 left(up_direction % at);
- if (left.isNull())
- {
- //tweak lookat pos so we don't get a degenerate matrix
- LLVector3 tempat(at[VX] + 0.01f, at[VY], at[VZ]);
- tempat.normVec();
- left = (up_direction % tempat);
- }
- left.normVec();
+ // Make sure 'at' and 'up_direction' are not parallel
+ // and that neither are zero-length vectors
+ LLVector3 left(up_direction % at);
+ if (left.isNull())
+ {
+ //tweak lookat pos so we don't get a degenerate matrix
+ LLVector3 tempat(at[VX] + 0.01f, at[VY], at[VZ]);
+ tempat.normVec();
+ left = (up_direction % tempat);
+ }
+ left.normVec();
- LLVector3 up = at % left;
+ LLVector3 up = at % left;
- if (at.isFinite() && left.isFinite() && up.isFinite())
- {
- setAxes(at, left, up);
- }
+ if (at.isFinite() && left.isFinite() && up.isFinite())
+ {
+ setAxes(at, left, up);
+ }
}
void LLCoordFrame::lookDir(const LLVector3 &xuv)
{
- static LLVector3 up_direction(0.0f, 0.0f, 1.0f);
- lookDir(xuv, up_direction);
+ static LLVector3 up_direction(0.0f, 0.0f, 1.0f);
+ lookDir(xuv, up_direction);
}
void LLCoordFrame::lookAt(const LLVector3 &origin, const LLVector3 &point_of_interest, const LLVector3 &up_direction)
{
- setOrigin(origin);
- LLVector3 at(point_of_interest - origin);
- at.normVec();
- lookDir(at, up_direction);
+ setOrigin(origin);
+ LLVector3 at(point_of_interest - origin);
+ at.normVec();
+ lookDir(at, up_direction);
}
void LLCoordFrame::lookAt(const LLVector3 &origin, const LLVector3 &point_of_interest)
{
- static LLVector3 up_direction(0.0f, 0.0f, 1.0f);
+ static LLVector3 up_direction(0.0f, 0.0f, 1.0f);
- setOrigin(origin);
- LLVector3 at(point_of_interest - origin);
- at.normVec();
- lookDir(at, up_direction);
+ setOrigin(origin);
+ LLVector3 at(point_of_interest - origin);
+ at.normVec();
+ lookDir(at, up_direction);
}
@@ -661,13 +661,13 @@ void LLCoordFrame::lookAt(const LLVector3 &origin, const LLVector3 &point_of_int
std::ostream& operator<<(std::ostream &s, const LLCoordFrame &C)
{
- s << "{ "
- << " origin = " << C.mOrigin
- << " x_axis = " << C.mXAxis
- << " y_axis = " << C.mYAxis
- << " z_axis = " << C.mZAxis
- << " }";
- return s;
+ s << "{ "
+ << " origin = " << C.mOrigin
+ << " x_axis = " << C.mXAxis
+ << " y_axis = " << C.mYAxis
+ << " z_axis = " << C.mZAxis
+ << " }";
+ return s;
}