TAPsSpring.hpp

Go to the documentation of this file.

/******************************************************************************
TAPsSpring.hpp

Spring class is a class for a spring connecting between two particles in 3D.

SUKITTI PUNAK   (09/15/2004)
UPDATE          (09/15/2004)
******************************************************************************/
#ifndef TAPs_SPRING_HPP
#define TAPs_SPRING_HPP

#include "TAPsParticle.hpp"

BEGIN_NAMESPACE_TAPs
//=============================================================================
// Forward Class Declarations
template <typename T>   class DeformMesh;
template <typename T>   class Cloth;
//=============================================================================
template <typename T>
class Spring {
//=============================================================================
    //-------------------------------------------------------------------------
    // Friend Classes
    friend class DeformMesh<T>;
    friend class Cloth<T>;
    //-------------------------------------------------------------------------
    // put it through ostream
    friend std::ostream &operator<< ( std::ostream &output, Spring<T> const &S )
    {
        output  << "Spring<" << typeid(T).name() << "> ==> "
                << "\n  -------START--SPRING--INFO-------"
                << "\n  Particle #1: " << S.m_rcP1
                << "\n  Particle #2: " << S.m_rcP2
                << "\n  K Constant:  " << S.m_tK
                << "\n  D Damping:   " << S.m_tD
                << "\n  L Length:    " << S.m_tL
                << "\n  Current Length: " << S.GetCurrentLength()
                << "\n  Force:       " << S.GetForce()
                << "\n  --------END--SPRING--INFO--------\n";
        return output;
    }
//-----------------------------------------------------------------------------
private:
    // Data Members     ========================================================
    Particle<T> &   m_rcP1; // reference to connected particle #1
    Particle<T> &   m_rcP2; // reference to connected particle #2
    T               m_tK;   // tensile spring constant (K)
    T               m_tD;   // damping factor (D)
    T               m_tL;   // rest length of spring (L)
    //-------------------------------------------------------------------------
public:
    // Member Functions     ====================================================
    Spring ( 
        Particle<T> &P1, 
        Particle<T> &P2, 
        T k, T d, T l );    // constructor
    Spring ( 
        Particle<T> &P1, 
        Particle<T> &P2, 
        T k, T d );         // constructor
    ~Spring ();             // destructor
    //-------------------------------------------------------------------------
    // Calculate and Return the (Internal) Force of a Spring
    Vector3<T> GetForce () const;
    //-------------------------------------------------------------------------
    // Get/Set Functions
    // REMARK: No const for Particle<T> & and const after the get fns
    //         so that the return ref can be modified.
    inline Particle<T> & GetParticleOne ();
    inline Particle<T> & GetParticleTwo ();
    inline T GetConstantK () const;
    inline T GetDampingD () const;
    inline T GetRestLengthL () const;
    inline T GetCurrentLength () const;
    //-------------------------------------------------------------------------
private:
    // Prohibited Functions ====================================================
    // Since a spring refers to two particles, therefore
    // Copy Constructor and Assignment Operator are prohibited.
    Spring<T> const & operator= ( Spring<T> const &S ); // assignment operator
    //-------------------------------------------------------------------------
}; // END CLASS Spring
//=============================================================================
END_NAMESPACE_TAPs
//-----------------------------------------------------------------------------
// Include definition if TAPs_USE_EXPORT is not defined
//#if !defined( TAPs_USE_EXPORT )
    #include "TAPsSpring.cpp"
//#endif
//-----------------------------------------------------------------------------
#endif
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8



//TESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTE
//
//      TAPsSpring    T E S T    P R O G R A M
//
//TESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTE
/*
#include <iostream>
#include <iomanip>
using std::cout;
using std::setw;
#include "../Core/Physics/TAPsSpring.hpp"

int main()
{
    TAPs::Particle<float> P1( 1, TAPs::Vector3<float>( 0,0,0 ), TAPs::Vector3<float>( 1,0,0 ), 
                             TAPs::Vector3<float>( 0,1,0 ), TAPs::Vector3<float>( 0,0,1 ), true );
    TAPs::Particle<float> P2( 1, TAPs::Vector3<float>( 1,1,1 ), TAPs::Vector3<float>( 0.5,0,0 ), 
                             TAPs::Vector3<float>( 0,0.5,0 ), TAPs::Vector3<float>( 0,0,0.5 ) );

    TAPs::Spring<float> S( P1, P2, 180, 2, 1.5 );
    cout <<   "P1 ==> " << P1;
    cout <<   "P2 ==> " << P2;
    cout << "\nS  ==> " << S;
    cout << "P1- P2 ==> " << P1.GetPosition() - P2.GetPosition() << "\n";
    P1.SetPosition( TAPs::Vector3<float>( 2,3,4 ) );
    cout << "\nP1.SetPosition( TAPs:Vector3<float>( 2,2,2 ) ) ==> " << P1;
    cout << "\nS  ==> " << S;
    cout << "P1- P2 ==> " << P1.GetPosition() - P2.GetPosition() << "\n";

    return 0;
}
*/
//TESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTESTTE