class TGLMatrix


TGLMatrix

16 component (4x4) transform matrix - column MAJOR as per GL.
Provides limited support for adjusting the translation, scale and
rotation components.

This is part of collection of simple utility classes for GL only in
TGLUtil.h/cxx. These provide const and non-const accessors Arr() &
CArr() to a GL compatible internal field - so can be used directly
with OpenGL C API calls - which TVector3 etc cannot (easily).
They are not intended to be fully featured just provide minimum
required.

Function Members (Methods)

public:
TGLMatrix()
TGLMatrix(const TGLVertex3& translation)
TGLMatrix(const Double_t* vals)
TGLMatrix(const TGLMatrix& other)
TGLMatrix(const TGLVertex3& origin, const TGLVector3& zAxis)
TGLMatrix(Double_t x, Double_t y, Double_t z)
TGLMatrix(const TGLVertex3& origin, const TGLVector3& zAxis, const TGLVector3& xAxis)
virtual~TGLMatrix()
Double_t*Arr()
const Double_t*CArr() const
static TClass*Class()
voidDump() const
TGLVector3GetBaseVec(Int_t b) const
voidGetBaseVec(Int_t b, TGLVector3& v) const
voidGetBaseVec(Int_t b, Double_t* x) const
TGLVector3GetScale() const
TGLVector3GetTranslation() const
Double_tInvert()
virtual TClass*IsA() const
voidMoveLF(Int_t ai, Double_t amount)
voidMultiplyIP(TGLVector3& v, Double_t w = 1) const
voidMultLeft(const TGLMatrix& lhs)
voidMultRight(const TGLMatrix& rhs)
TGLMatrix&operator*=(const TGLMatrix& rhs)
TGLMatrix&operator=(const TGLMatrix& rhs)
Double_t&operator[](Int_t index)
Double_toperator[](Int_t index) const
voidRotate(const TGLVertex3& pivot, const TGLVector3& axis, Double_t angle)
voidRotateIP(TGLVector3& v) const
voidRotateLF(Int_t i1, Int_t i2, Double_t amount)
voidRotatePF(Int_t i1, Int_t i2, Double_t amount)
voidScale(const TGLVector3& scale)
voidSet(const Double_t* vals)
voidSet(const TGLVertex3& origin, const TGLVector3& zAxis, const TGLVector3& xAxis = 0)
voidSetBaseVec(Int_t b, const TGLVector3& v)
voidSetBaseVec(Int_t b, Double_t* x)
voidSetBaseVec(Int_t b, Double_t x, Double_t y, Double_t z)
voidSetIdentity()
voidSetTranslation(const TGLVertex3& translation)
voidSetTranslation(Double_t x, Double_t y, Double_t z)
virtual voidShowMembers(TMemberInspector& insp, char* parent)
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
voidTransformVertex(TGLVertex3& vertex) const
voidTranslate(const TGLVector3& vect)
voidTranspose3x3()
private:
Bool_tValidIndex(UInt_t index) const

Data Members

private:
Double_tfVals[16]Column MAJOR as per OGL

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

TGLMatrix()
 Construct default identity matrix:

 1 0 0 0
 0 1 0 0
 0 0 1 0
 0 0 0 1
TGLMatrix(Double_t x, Double_t y, Double_t z)
 Construct matrix with translation components x,y,z:

 1 0 0 x
 0 1 0 y
 0 0 1 z
 0 0 0 1
TGLMatrix(const TGLVertex3 & translation)
 Construct matrix with translation components x,y,z:

 1 0 0 translation.X()
 0 1 0 translation.Y()
 0 0 1 translation.Z()
 0 0 0 1
TGLMatrix(const TGLVertex3& origin, const TGLVector3& zAxis)
 Construct matrix which when applied puts local origin at
 'origin' and the local Z axis in direction 'z'. Both
 'origin' and 'zAxisVec' are expressed in the parent frame
TGLMatrix(const TGLVertex3 & origin, const TGLVector3 & zAxis, const TGLVector3 & xAxis)
 Construct matrix which when applied puts local origin at
 'origin' and the local Z axis in direction 'z'. Both
 'origin' and 'zAxisVec' are expressed in the parent frame
TGLMatrix(const Double_t vals[16])
 Construct matrix using the 16 Double_t 'vals' passed,
 ordering is maintained - i.e. should be column major
 as we are
TGLMatrix(const TGLMatrix & other)
 Construct matrix from 'other'
~TGLMatrix()
 Destroy matirx object
void MultRight(const TGLMatrix& rhs)
 Multiply with matrix rhs on right.
void MultLeft(const TGLMatrix& lhs)
 Multiply with matrix lhs on left.
void Set(const TGLVertex3& origin, const TGLVector3& zAxis, const TGLVector3& xAxis = 0)
 Set matrix which when applied puts local origin at
 'origin' and the local Z axis in direction 'z'. Both
 'origin' and 'z' are expressed in the parent frame
void Set(const Double_t* vals)
 Set matrix using the 16 Double_t 'vals' passed,
 ordering is maintained - i.e. should be column major
 as we are
void SetIdentity()
 Set matrix to identity:

 1 0 0 0
 0 1 0 0
 0 0 1 0
 0 0 0 1
void SetTranslation(Double_t x, Double_t y, Double_t z)
 Set matrix translation components x,y,z:

 . . . x
 . . . y
 . . . z
 . . . .

 The other components are NOT modified
void SetTranslation(const TGLVertex3& translation)
 Set matrix translation components x,y,z:

 . . . translation.X()
 . . . translation.Y()
 . . . translation.Z()
 . . . .

 . = Exisiting component value - NOT modified
TGLVector3 GetTranslation()
 Return the translation component of matrix

 . . . X()
 . . . Y()
 . . . Z()
 . . . .
void Translate(const TGLVector3& vect)
 Offset (shift) matrix translation components by 'vect'

 . . . . + vect.X()
 . . . . + vect.Y()
 . . . . + vect.Z()
 . . . .

 . = Exisiting component value - NOT modified
void MoveLF(Int_t ai, Double_t amount)
 Translate in local frame.
 i1, i2 are axes indices: 1 ~ x, 2 ~ y, 3 ~ z.
void Scale(const TGLVector3& scale)
 Set matrix axis scales to 'scale'. Note - this really sets
 the overall (total) scaling for each axis - it does NOT
 apply compounded scale on top of existing one
void Rotate(const TGLVertex3& pivot, const TGLVector3& axis, Double_t angle)
 Update martix so resulting transform has been rotated about 'pivot'
 (in parent frame), round vector 'axis', through 'angle' (radians)
 Equivalent to glRotate function, but with addition of translation
 and compounded on top of existing.
void RotateLF(Int_t i1, Int_t i2, Double_t amount)
 Rotate in local frame. Does optimised version of MultRight.
 i1, i2 are axes indices: 1 ~ x, 2 ~ y, 3 ~ z.
void RotatePF(Int_t i1, Int_t i2, Double_t amount)
 Rotate in parent frame. Does optimised version of MultLeft.
void TransformVertex(TGLVertex3& vertex) const
 Transform passed 'vertex' by this matrix - converts local frame to parent
void Transpose3x3()
 Transpose the top left 3x3 matrix component along major diagonal
 Supported as currently incompatability between TGeo and GL matrix
 layouts for this 3x3 only. To be resolved.
Double_t Invert()
 Invert the matrix, returns determinant.
 Copied from TMatrixFCramerInv.
void MultiplyIP(TGLVector3& v, Double_t w = 1) const
 Multiply vector in-place.
void RotateIP(TGLVector3& v) const
 Rotate vector in-place. Translation is not applied.
TGLVector3 GetScale()
 Get local axis scaling factors
void Dump()
 Output 16 matrix components to std::cout

 0  4   8  12
 1  5   9  13
 2  6  10  14
 3  7  11  15
void SetBaseVec(Int_t b, Double_t x, Double_t y, Double_t z)




void SetBaseVec(Int_t b, const TGLVector3& v)






void SetBaseVec(Int_t b, Double_t* x)






TGLVector3 GetBaseVec(Int_t b) const






void GetBaseVec(Int_t b, TGLVector3& v)






void GetBaseVec(Int_t b, Double_t* x)






Bool_t ValidIndex(UInt_t index) const


 Fields




{ return (index < 3); }






const Double_t * CArr()



{ return fVals; }






Double_t * Arr()



{ return fVals; }






TGLMatrix & operator*=(const TGLMatrix& rhs)



{ MultRight(rhs); return *this; }






TGLUtil& operator=(const TGLMatrix& rhs)







Author:   Richard Maunder  25/05/2005

Last update: root/gl:$Id: TGLUtil.h 21653 2008-01-11 20:23:15Z matevz $

Copyright   (C) 1995-2004, Rene Brun and Fons Rademakers.               *




This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.