TAPsPointMassDynamic.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsPointMassDynamic.cpp

PointMassDynamic class is a class for dynamic particle in 3D.

SUKITTI PUNAK   (07/12/2009)
UPDATE          (09/21/2010)
******************************************************************************/
#include "TAPsPointMassDynamic.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
//=============================================================================
// Constructors and Destructor
//-----------------------------------------------------------------------------
template <typename T>
PointMassDynamic<T>::PointMassDynamic ( bool bRandomValue )
{
    bRandomValue ? RandomValues() : DefaultValues();
    m_Type = TYPE_DYNAMIC;
}
//-----------------------------------------------------------------------------
template <typename T>
PointMassDynamic<T>::PointMassDynamic
( 
    T                   mass,
    T                   size,
    Vector3<T> const &  vPosition,
    Vector3<T> const &  vVelocity, 
    Vector3<T> const &  vAcceleration,
    Vector3<T> const &  vForce,
    DS::SimulationFlags const & flags
)   : PointMass( mass, size, vPosition, flags )
    , m_v3Velocity( vVelocity )
    , m_v3Acceleration( vAcceleration )
    , m_v3Force( vForce )
{
    m_Type = TYPE_DYNAMIC;
}
//-----------------------------------------------------------------------------
template <typename T>
PointMassDynamic<T>::PointMassDynamic ( PointMassDynamic<T> const & P )
    : PointMass( P )
    , m_v3Velocity( P.m_v3Velocity )
    , m_v3Acceleration( P.m_v3Acceleration )
    , m_v3Force( P.m_v3Force )
{
    m_Type = TYPE_DYNAMIC;
}
//-----------------------------------------------------------------------------
template <typename T>
PointMassDynamic<T>::PointMassDynamic ( Vector3<T> const & location )
    : PointMass( location )
    , m_v3Velocity()
    , m_v3Acceleration()
    , m_v3Force()
{
    m_Type = TYPE_DYNAMIC;
}
//-----------------------------------------------------------------------------
template <typename T>
PointMassDynamic<T>::PointMassDynamic ( T const location[3] )
    : PointMass( location )
    , m_v3Velocity()
    , m_v3Acceleration()
    , m_v3Force()
{
    m_Type = TYPE_DYNAMIC;
}
//-----------------------------------------------------------------------------
template <typename T>
PointMassDynamic<T>::PointMassDynamic ( T locX, T locY, T locZ )
    : PointMass( locX, locY, locZ )
    , m_v3Velocity()
    , m_v3Acceleration()
    , m_v3Force()
{
    m_Type = TYPE_DYNAMIC;
}
//-----------------------------------------------------------------------------
// PointMassDynamic Destructor
template <typename T>
PointMassDynamic<T>::~PointMassDynamic ()
{}
//-----------------------------------------------------------------------------
template <typename T>
std::string PointMassDynamic<T>::StrInfo () const
{
    std::stringstream ss;
    ss  << "PointMassDynamic<" << typeid(T).name() << "> ==> "
        << "\n  Mass:         " << GetMass()
        << "\n  Position:     " << GetPosition()
        << "\n  Velocity:     " << GetVelocity()
        << "\n  Acceleration: " << GetAcceleration()
        << "\n  Force:        " << GetForce()
        << "\n  Simulation Flags:   " << GetFlags()
        << "\n";
    return ss.str();
}
//-----------------------------------------------------------------------------
//=============================================================================
// PointMassDynamic Assignment Operator
//-----------------------------------------------------------------------------
template <typename T>
PointMassDynamic<T> const & PointMassDynamic<T>::operator= ( PointMassDynamic<T> const & P )
{
    if ( this != &P )
    {
        *(dynamic_cast< PointMass<T> * >(this)) = *(dynamic_cast< PointMass<T> const * >(&P));
        // Physics Properties ---------------------------------------
        m_v3Velocity     = P.m_v3Velocity;
        m_v3Acceleration = P.m_v3Acceleration;
        m_v3Force        = P.m_v3Force;
    }
    return *this;
}
//-----------------------------------------------------------------------------

//=============================================================================
// Get/Set Functions
//-----------------------------------------------------------------------------

//-------------------------------------------------------------------
// Physics Properties
//-------------------------------------------------------------------

// Velocity
template <typename T>
Vector3<T> const & PointMassDynamic<T>::GetVelocity () const    { return m_v3Velocity; }
template <typename T>
Vector3<T> & PointMassDynamic<T>::GetVelocity ()    { return m_v3Velocity; }
template <typename T>
void PointMassDynamic<T>::SetVelocity ( Vector3<T> const & v3 ) { m_v3Velocity = v3; }
template <typename T>
void PointMassDynamic<T>::SetVelocity ( T x, T y, T z ) { m_v3Velocity.SetXYZ( x, y, z ); }

// Acceleration
template <typename T>
Vector3<T> const & PointMassDynamic<T>::GetAcceleration () const    { return m_v3Acceleration; }
template <typename T>
Vector3<T> & PointMassDynamic<T>::GetAcceleration ()    { return m_v3Acceleration; }
template <typename T>
void PointMassDynamic<T>::SetAcceleration ( Vector3<T> const & v3 ) { m_v3Acceleration = v3; }
template <typename T>
void PointMassDynamic<T>::SetAcceleration ( T x, T y, T z ) { m_v3Acceleration.SetXYZ( x, y, z ); }

// Force
template <typename T>
Vector3<T> const & PointMassDynamic<T>::GetForce () const   { return m_v3Force; }
template <typename T>
Vector3<T> & PointMassDynamic<T>::GetForce ()   { return m_v3Force; }
template <typename T>
void PointMassDynamic<T>::SetForce ( Vector3<T> const & v3 )    { m_v3Force = v3; }
template <typename T>
void PointMassDynamic<T>::SetForce ( T x, T y, T z )    { m_v3Force.SetXYZ( x, y, z ); }


//=============================================================================
// Simulation Functions
//-----------------------------------------------------------------------------
/*
template <typename T>
void PointMassDynamic<T>::Update( 
    T worldTimeDuration,        //!< duration time (sec) in the virtual world after the last update
    T tIntegrationTimeDelta     //!< integration time (sec)
)
{
    static T    tPrecentComplete;
    static T    tGravity = -9.81E1;

    m_tLifeTimeElapsed += worldTimeDuration;
    // Adding 0.000001f for protecting division by zero
    tPrecentComplete = m_tLifeTimeElapsed / (m_tLifeTimeSpan + 0.000001f);

    // Update Rendering Properties
    m_v4CurrentColor = CGMath<T>::LinearInterpolation( m_v4StartColor, m_v4EndColor, tPrecentComplete );
    m_tCurrentSize = CGMath<T>::LinearInterpolation( m_tStartSize, m_tEndSize, tPrecentComplete );

    // Update Physical Properties
    if ( !m_bFixed ) {
        m_v3Acceleration[1] += tGravity * worldTimeDuration * worldTimeDuration * m_tMass;
        m_v3Velocity += m_v3Acceleration * tIntegrationTimeDelta;
        m_v3Position += m_v3Velocity * tIntegrationTimeDelta;
    }
}
//*/
//-----------------------------------------------------------------------------


//=============================================================================
//-----------------------------------------------------------------------------
template <typename T>
void PointMassDynamic<T>::DefaultValues ()
{
    PointMass<T>::DefaultValues();
    // Physics Properties -------------------------------------------
    m_v3Velocity.SetXYZ( 0, 0, 0 );
    m_v3Acceleration.SetXYZ( 0, 0, 0 );
    m_v3Force.SetXYZ( 0, 0, 0 );
}
//-----------------------------------------------------------------------------
template <typename T>
void PointMassDynamic<T>::RandomValues ()
{
    PointMass<T>::DefaultValues();
    // Physics Properties -------------------------------------------
    // between -1.0 to 1.0
    m_v3Velocity.SetXYZ( (rand()%201-100)/100.0, (rand()%201-100)/100.0, (rand()%201-100)/100.0 );
    m_v3Acceleration.SetXYZ( (rand()%201-100)/100.0, (rand()%201-100)/100.0, (rand()%201-100)/100.0 );
    m_v3Force.SetXYZ( (rand()%201-100)/100.0, (rand()%201-100)/100.0, (rand()%201-100)/100.0 );
}
//-----------------------------------------------------------------------------

//=============================================================================
#if defined(__gl_h_) || defined(__GL_H__)
template <typename T>
void PointMassDynamic<T>::Draw () const
{
    glPushMatrix();
    glPushAttrib( GL_ALL_ATTRIB_BITS );
    glTranslatef( static_cast<float>(m_v3Position[0]), static_cast<float>(m_v3Position[1]), static_cast<float>(m_v3Position[2]) );
    glEnable( GL_COLOR_MATERIAL );
    glColor4f( 0.5, 0.5, 0.5, 0.5 );
    glutSolidSphere( m_tSize, 10, 10 );
    glPopAttrib();
    glPopMatrix();
}

template <typename T>
void PointMassDynamic<T>::Draw ( T scale ) const
{
    glPushMatrix();
    glPushAttrib( GL_ALL_ATTRIB_BITS );
    glTranslatef( static_cast<float>(m_v3Position[0]), static_cast<float>(m_v3Position[1]), static_cast<float>(m_v3Position[2]) );
    glEnable( GL_COLOR_MATERIAL );
    glColor4f( 0.5, 0.5, 0.5, 0.5 );
    glutSolidSphere( m_tSize*scale, 10, 10 );
    glPopAttrib();
    glPopMatrix();
}
#endif // #if defined(__gl_h_) || defined(__GL_H__)
//=============================================================================
END_NAMESPACE_TAPs
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----