TAPsTransformationSupport.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsTransformationSupport.cpp
******************************************************************************/
/******************************************************************************
SUKITTI PUNAK   (03/03/2006)
UPDATE          (09/12/2010)
******************************************************************************/
#include "TAPsTransformationSupport.hpp"
// Using Inclusion Model (i.e. definitions are included in declarations)
//                       (this name.cpp is included in name.hpp)
// Each friend is defined directly inside its declaration.

BEGIN_NAMESPACE_TAPs
//=============================================================================
//-----------------------------------------------------------------------------
// Default Constructor
template <typename T>
TransformationSupport<T>::TransformationSupport ( TransformationSupport<T> * pParent )
    //: m_pParent( pParent )
{
    MakeIdentity();

    #ifdef  TAPs_DEBUG_MODE
    std::cout   << "TransformationSupport<" << typeid(T).name() << "> constructor\n";
    #endif//TAPs_DEBUG_MODE
}
//-----------------------------------------------------------------------------
// Copy Constructor
template <typename T>
TransformationSupport<T>::TransformationSupport ( const TransformationSupport<T> & orig )
    : m_TransformationMatrix( orig.m_TransformationMatrix )
      //,m_pParent( orig.m_pParent )
{
    #ifdef  TAPs_DEBUG_MODE
    std::cout   << "TransformationSupport<" << typeid(T).name() << "> copy constructor\n";
    #endif//TAPs_DEBUG_MODE
}
//-----------------------------------------------------------------------------
// Destructor
template <typename T>
TransformationSupport<T>::~TransformationSupport ()
{
    #ifdef  TAPs_DEBUG_MODE
    std::cout   << "TransformationSupport<" << typeid(T).name() << "> destructor\n";
    #endif//TAPs_DEBUG_MODE
}
//-----------------------------------------------------------------------------
// Return this object info as a string
template <typename T>
std::string TransformationSupport<T>::StrInfo () const
{
    std::ostringstream ss;
    ss << "TransformationSupport<" << typeid(T).name() << ">";
    ss << "\n  Trx Matrix: ";
    ss << m_TransformationMatrix;
    return ss.str();
}
//-----------------------------------------------------------------------------
// Assignment Operator
template <typename T>
inline TAPs::TransformationSupport<T> & TAPs::TransformationSupport<T>::operator= ( 
    TAPs::TransformationSupport<T> const & orig )
{   
    m_TransformationMatrix  =   orig.m_TransformationMatrix;
    //m_pParent             =   orig.m_pParent;
    return *this;
}
//-----------------------------------------------------------------------------
// Reset Fn
//template <typename T>
//void TransformationSupport<T>::Reset ()
//{
//  m_TransformationMatrix.MakeIdentity();
//}
//-----------------------------------------------------------------------------
//=============================================================================
// Transformations
//-----------------------------------------------------------------------------
// PRE APPLY TRANSLATION
template <typename T>
void TransformationSupport<T>::PreApplyTranslation ( Vector3<T> const & C )
{
    m_TransformationMatrix = 
        Matrix4x4<T>( 
            1, 0, 0, C[0],
            0, 1, 0, C[1],
            0, 0, 1, C[2],
            0, 0, 0, 1
        )   *   m_TransformationMatrix;
}
//-----------------------------------------------------------------------------
// PRE APPLY TRANSLATION
template <typename T>
void TransformationSupport<T>::PreApplyTranslation ( T x, T y, T z )
{
    m_TransformationMatrix = 
        Matrix4x4<T>( 
            1, 0, 0, x,
            0, 1, 0, y,
            0, 0, 1, z,
            0, 0, 0, 1
        )   *   m_TransformationMatrix;
}
//-----------------------------------------------------------------------------
// APPLY TRANSLATION
template <typename T>
void TransformationSupport<T>::ApplyTranslation ( Vector3<T> const & C )
{
    m_TransformationMatrix *= 
        Matrix4x4<T>( 
            1, 0, 0, C[0],
            0, 1, 0, C[1],
            0, 0, 1, C[2],
            0, 0, 0, 1
        );
}
//-----------------------------------------------------------------------------
// APPLY TRANSLATION
template <typename T>
void TransformationSupport<T>::ApplyTranslation ( T x, T y, T z )
{
    m_TransformationMatrix *= 
        Matrix4x4<T>( 
            1, 0, 0, x,
            0, 1, 0, y,
            0, 0, 1, z,
            0, 0, 0, 1
        );
}
//-----------------------------------------------------------------------------
// GET TRANSLATION
template <typename T>
Vector3<T> TransformationSupport<T>::GetTranslation () const
{
    return Vector3<T>( 
        m_TransformationMatrix[ 3], 
        m_TransformationMatrix[ 7], 
        m_TransformationMatrix[11]
    );
}
//-----------------------------------------------------------------------------
// GET TRANSLATION
template <typename T>
void TransformationSupport<T>::GetTranslation ( Vector3<T> & C ) const
{
    C[0] = m_TransformationMatrix[ 3];
    C[1] = m_TransformationMatrix[ 7];
    C[2] = m_TransformationMatrix[11];
}
//-----------------------------------------------------------------------------
// GET TRANSLATION
template <typename T>
void TransformationSupport<T>::GetTranslation ( T & x, T & y, T & z ) const
{
    x = m_TransformationMatrix[ 3];
    y = m_TransformationMatrix[ 7];
    z = m_TransformationMatrix[11];
}
//-----------------------------------------------------------------------------
// SET TRANSLATION
template <typename T>
void TransformationSupport<T>::SetTranslation ( Vector3<T> const & C )
{
    m_TransformationMatrix[ 3] = C[0];
    m_TransformationMatrix[ 7] = C[1];
    m_TransformationMatrix[11] = C[2];
}
//-----------------------------------------------------------------------------
// SET TRANSLATION
template <typename T>
void TransformationSupport<T>::SetTranslation ( T x, T y, T z )
{
    m_TransformationMatrix[ 3] = x;
    m_TransformationMatrix[ 7] = y;
    m_TransformationMatrix[11] = z;
}
//-----------------------------------------------------------------------------
// RETURN TRANSLATION
template <typename T>
T & TransformationSupport<T>::ReturnTranslation ( int i )
{
    assert( 0 <= i && i <= 2 );
    return m_TransformationMatrix[i*4 + 3];
}
//-----------------------------------------------------------------------------
// SET ROTATION
template <typename T>
void TransformationSupport<T>::SetRotation ( Matrix3x3<T> const & MR )
{
    m_TransformationMatrix[ 0] = MR[0];
    m_TransformationMatrix[ 1] = MR[1];
    m_TransformationMatrix[ 2] = MR[2];
    m_TransformationMatrix[ 4] = MR[3];
    m_TransformationMatrix[ 5] = MR[4];
    m_TransformationMatrix[ 6] = MR[5];
    m_TransformationMatrix[ 8] = MR[6];
    m_TransformationMatrix[ 9] = MR[7];
    m_TransformationMatrix[10] = MR[8];
}
//-----------------------------------------------------------------------------
//=============================================================================
//-----------------------------------------------------------------------------
// PRE APPLY ROTATION
template <typename T>
void TransformationSupport<T>::PreApplyRotationAxisAndAngle ( 
        Vector3<T> const & vAxis, T tAngle )
{
    m_TransformationMatrix = 
        Matrix4x4<T>( CGMath<T>::CreateRotationMatrix3x3( vAxis, tAngle ) )
      * m_TransformationMatrix;
}
//-----------------------------------------------------------------------------
// PRE APPLY ROTATION
template <typename T>
void TransformationSupport<T>::PreApplyRotationAxisAndAngle ( 
        T x, T y, T z, T angle )
{
    PreApplyRotationAxisAndAngle( Vector3<T>( x, y, z ), angle );
}
//-----------------------------------------------------------------------------
// PRE APPLY ROTATION
template <typename T>
void TransformationSupport<T>::PreApplyRotationFromVectorAtoVectorB ( 
        Vector3<T> const & A, Vector3<T> const & B )
{
    m_TransformationMatrix = 
        Matrix4x4<T>( CGMath<T>::CreateRotationMatrix3x3FromVectorAtoVectorB( A, B ) );
      * m_TransformationMatrix;
}
//-----------------------------------------------------------------------------
// APPLY ROTATION
template <typename T>
void TransformationSupport<T>::ApplyRotationAxisAndAngle ( 
        Vector3<T> const & vAxis, T tAngle )
{
    m_TransformationMatrix *= 
        Matrix4x4<T>( CGMath<T>::CreateRotationMatrix3x3( vAxis, tAngle ) );
}
//-----------------------------------------------------------------------------
// APPLY ROTATION
template <typename T>
void TransformationSupport<T>::ApplyRotationAxisAndAngle ( 
        T x, T y, T z, T angle )
{
    ApplyRotationAxisAndAngle( Vector3<T>( x, y, z ), angle );
}
//-----------------------------------------------------------------------------
// APPLY ROTATION
template <typename T>
void TransformationSupport<T>::ApplyRotationFromVectorAtoVectorB ( 
        Vector3<T> const & A, Vector3<T> const & B )
{
    m_TransformationMatrix *= 
        Matrix4x4<T>( CGMath<T>::CreateRotationMatrix3x3FromVectorAtoVectorB( A, B ) );
}
//-----------------------------------------------------------------------------
//=============================================================================
//-----------------------------------------------------------------------------
// PRE APPLY SCALE
template <typename T>
void TransformationSupport<T>::PreApplyScale ( Vector3<T> const & vScale )
{
    m_TransformationMatrix = Matrix4x4<T>( vScale ) * m_TransformationMatrix;
}
//-----------------------------------------------------------------------------
// PRE APPLY SCALE
template <typename T>
void TransformationSupport<T>::PreApplyScale ( T x, T y, T z )
{
    PreApplyScale( Vector3<T>( x, y, z ) );
}
//-----------------------------------------------------------------------------
// PRE APPLY SCALE
template <typename T>
void TransformationSupport<T>::PreApplyUniformScale ( T s )
{
    PreApplyScale( Vector3<T>( s, s, s ) );
}
//-----------------------------------------------------------------------------
// APPLY SCALE
template <typename T>
void TransformationSupport<T>::ApplyScale ( Vector3<T> const & vScale )
{
    m_TransformationMatrix *= Matrix4x4<T>( vScale );
}
//-----------------------------------------------------------------------------
// APPLY SCALE
template <typename T>
void TransformationSupport<T>::ApplyScale ( T x, T y, T z )
{
    ApplyScale( Vector3<T>( x, y, z ) );
}
//-----------------------------------------------------------------------------
// APPLY SCALE
template <typename T>
void TransformationSupport<T>::ApplyUniformScale ( T s )
{
    ApplyScale( Vector3<T>( s, s, s ) );
}
//-----------------------------------------------------------------------------
//=============================================================================
// Static Member Functions for Data Conversions
//-----------------------------------------------------------------------------
template <typename T>
const float * TransformationSupport<T>::GetMatrixTransformFloat () const
{   return GetMatrixTransform().GetDataFloat(); }
//-----------------------------------------------------------------------------
template <typename T>
const double * TransformationSupport<T>::GetMatrixTransformDouble () const
{   return GetMatrixTransform().GetDataDouble();    }
//-----------------------------------------------------------------------------
template <typename T>
const long double * TransformationSupport<T>::GetMatrixTransformLongDouble () const
{   return GetMatrixTransform().GetDataLongDouble();    }
//-----------------------------------------------------------------------------
template <typename T>
const float * TransformationSupport<T>::GetTransposeMatrixTransformFloat () const
{   return GetMatrixTransform().GetTransposeDataFloat();    }
//-----------------------------------------------------------------------------
template <typename T>
const double * TransformationSupport<T>::GetTransposeMatrixTransformDouble () const
{   return GetMatrixTransform().GetTransposeDataDouble();   }
//-----------------------------------------------------------------------------
template <typename T>
const long double * TransformationSupport<T>::GetTransposeMatrixTransformLongDouble () const
{   return GetMatrixTransform().GetTransposeDataLongDouble();   }
//-----------------------------------------------------------------------------

//=============================================================================
#if defined(__gl_h_) || defined(__GL_H__)
//-----------------------------------------------------------------------------
template <typename T>
void TransformationSupport<T>::TransformByOpenGLForDrawing () const
{
    glMultMatrixf( GetTransposeMatrixTransformFloat() );
}
//-----------------------------------------------------------------------------
#endif
//=============================================================================
END_NAMESPACE_TAPs
//-----------------------------------------------------------------------------
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----