C:/development/RenderTools/src/factory/TransformNode.cpp

Go to the documentation of this file.

#include "TransformNode.h"
#include "RelationalNode.h"
#include "Property.h"

namespace RenderTools {

TransformNode::TransformNode( void ):
        m_warp( false ){
}

void TransformNode::createProperties( void ) {
        createProperty( this, "currentTransform", & m_local );
        createProperty( this, "previousTransform", & m_previousLocal );
        createProperty( this, "warping", BooleanStruct( & m_warp ) );
        createProperty( this, "warpVector", & m_warpVector );
}

const string TransformNode::getTypeName( bool ofComponent ) const {
        return( "TransformNode" );
}

void TransformNode::transform( const Mat4 & global ){
        onTransform( global );
}

void TransformNode::onTransform( const Mat4 & global ){
        m_previousGlobal = m_global;
        m_global = global * m_local;
        // align the naabb to the global coordinatesystem
        m_naabb.reset();
        for( int i = 0; i < 8; i++ ){
                m_naabb.adjust( ( m_global * Vec4( m_aabb.getCorner( i ), 0.0 ) ).xyz() );
        }
}

const Mat4 TransformNode::getGlobal( const RelationalNodePtr root ) const {
        // if no root is given, the local transform is returned
        if( ! root ){
                return( m_local );
        }
        // do a recursive search from the root and keep the path
        RelationalNodeList path;
        if( ! root->getChild( getSharedPtr< RelationalNode >(), path ) ){
                // if we can't even find it from the root, throw an error.
                Error::error( Error::NODE_NOT_FOUND, __FILE__, __LINE__ );
        }
        // now run from the last entry in the path to the first
        // and multiply the local matrices
        Mat4 global;
        for( int i = (int)path.size() - 1; i >= 0; i-- ){
                global *= ( ( path[ i ] ) )->getLocal();
        }
        return( global );
}

const Mat4 & TransformNode::getGlobal() const{
        return( m_global );
}

Mat4 & TransformNode::getGlobal( void ){
        return( m_global );
}


const Mat4 & TransformNode::getLocal() const{
        return( m_local );
}

Mat4 & TransformNode::getLocal( void ){
        return( m_local );
}

void TransformNode::setLocal( const Mat4 & matrix ){
        m_local = matrix;
}

const Mat4 & TransformNode::getPreviousLocal( void ) const{
        return( m_previousLocal );
}

Mat4 & TransformNode::getPreviousGlobal( void ){
        return( m_previousGlobal );
}

const Mat4 & TransformNode::getPreviousGlobal( void ) const{
        return( m_previousGlobal );
}

Mat4 & TransformNode::getPreviousLocal( void ){
        return( m_previousLocal );
}

void TransformNode::setPreviousLocal( const Mat4 & matrix ){
        m_previousLocal = matrix;
}

void TransformNode::setMovement( const Vec3 & v, const Quat & q, bool relative, bool push ){
        // keep the current transform
        Mat4 previous = m_local;

        if( relative ){
                // translate from the current position 'v', and rotate 'q'
                m_local.getCol(3).xyz() += v;

                Quat q1 = Quat::fromMat3( m_local.rotation() );
                // @TODO
                q1 = q1 + q;
                m_local = Mat4::fromQuaternion( q1 );
        }
        else{
                // just set the current position & rotation 
                m_local = Mat4::fromQuaternion( q );
                m_local.setCol( 3, Vec4( v[0], v[1], v[2], 1.0 ) );
        }

        // if requested and we moved, store the last transform
        if( push && ( ! m_local.equals( previous, 0.05f ) ) ){
                m_previousLocal = previous;
        }
}

void TransformNode::setMovement( const Mat4 & matrix, bool relative, bool push ){
        // keep the current transform
        Mat4 previous = m_local;

        if( relative ){
                m_local *= matrix;
        }
        else{
                m_local = matrix;
        }

        // if requested and we moved, store the last transform
        if( push && ( ! m_local.equals( previous, 0.05f ) ) ){
                m_previousLocal = previous;
        }
}

Vec3 TransformNode::getMovement( const Vec3 & global, bool fromPrevious ) const{
        Mat4 inv;
        Vec3 local;
        Vec3 previous;

        if( ! fromPrevious ){
                inv = m_local.inverse();
                previous = ( m_previousLocal * inv * Vec4( global, 0.0 ) ).xyz();
                return( global - previous );
        }
        else{
                inv = m_previousLocal.inverse();
                local = ( m_local * inv * Vec4( global, 0.0 ) ).xyz();
                return( local - global );
        }
}

Vec3 TransformNode::warpVector( const Vec3 & local ) const{
        if( ! m_warp ){
                return( local );
        }
        Vec3 r = local;
        Vec3 warp = m_warpVector;
        while( r[0] >  warp[0] )r[0] -= 2.0 * warp[0];
        while( r[0] < -warp[0] )r[0] += 2.0 * warp[0];
        while( r[1] >  warp[1] )r[1] -= 2.0 * warp[1];
        while( r[1] < -warp[1] )r[1] += 2.0 * warp[1];
        while( r[2] >  warp[2] )r[2] -= 2.0 * warp[2];
        while( r[2] < -warp[2] )r[2] += 2.0 * warp[2];
        return( r );
}

bool TransformNode::needsWarping( const Vec3 & local ) const{
        if( ! m_warp ){
                return( false );
        }
        Vec3 warp = m_warpVector;
        return( local[0] > warp[0] ||\
                        local[1] > warp[1] ||\
                        local[2] > warp[2] ||\
                        local[0] < -warp[0] ||\
                        local[1] < -warp[1] ||\
                        local[2] < -warp[2] );
}

void TransformNode::warp( const Vec3 & warped ){
        // displace the origin
        m_local[12] += warped[0];
        m_local[13] += warped[1];
        m_local[14] += warped[2];

        // displace the previous origin
        m_previousLocal[12] += warped[0];
        m_previousLocal[13] += warped[1];
        m_previousLocal[14] += warped[2];
}

void TransformNode::warp( void ){
        if( m_warp ){
                // see if we need to warp,
                // get the difference between the current 
                // global position and the warped position
                Mat4 global = get( Matrix::MODELVIEW ) * m_local;
                Vec3 warped = warpVector( global.getCol(3).xyz() ) - global.getCol(3).xyz();

                // if a displacement ocurred, displace the matrices
                if( warped[0] != 0.0 || warped[1] != 0.0 || warped[2] != 0.0 ){
                        warp( warped );
                }
        }
}

void TransformNode::setWarping( bool state, const Vec3 & warp ){
        m_warp = state;
        m_warpVector = warp;
}

const NAABB & TransformNode::getNAABB( void ) const { 
        return( m_naabb ); 
}

const AABB & TransformNode::getAABB( void ) const { 
        return( m_aabb ); 
}

void TransformNode::setNAABB( const NAABB & box, bool send ){ 
        m_naabb = box;
        sendPropertyEvent( PropertyEvent( PropertyEvent::CHANGED, findProperty( & m_naabb ) ) );
}

void TransformNode::setAABB( const AABB & box, bool send ){ 
        m_aabb = box; 
        sendPropertyEvent( PropertyEvent( PropertyEvent::CHANGED, findProperty( & m_aabb ) ) );
}


};

---