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

Go to the documentation of this file.

#include "RelationalNode.h"
#include "ViewController.h"
#include "Factory.h"
#include "XMLNode.h"

namespace RenderTools {

RelationalNode::RelationalNode( void ):
        TransformNode(){

}

PropertyPtr RelationalNode::create( const XMLNodePtr & xml ){
        RelationalNodePtr p( new RelationalNode() );
        p->setName( xml );
        p->createProperties();
        p->setProperties( xml, false );
        return( dynamic_pointer_cast< AbstractProperty, RelationalNode >( p ) );
}

void RelationalNode::createProperties( void ){
        createProperty( this, "parents", & m_parents );
        createProperty( this, "children", & m_children );
}

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

#ifdef RT_PROFILER

void RelationalNode::beginProfiler( const string name, string file, int line ){
        string decoratedName = m_name + "[" + name + "]";

        map<string, Profiler *>::iterator i;
        Profiler * p = 0;
        if( ( i = m_profilers.find( decoratedName ) ) == m_profilers.end() ){
                p = new Profiler( decoratedName, file, line );
                m_profilers[ decoratedName ] = p;
        }
        else{
                p = i->second;
        }
        if( p ){
                p->begin();
        }
        else{
                Error::error( Error::NULL_POINTER, __FILE__, __LINE__ );
        }
}

void RelationalNode::endProfiler( const string name ){
        map<string, Profiler *>::iterator i;
        if( ( i = m_profilers.find( m_name + "[" + name + "]" ) ) == m_profilers.end() ){
                Error::error( Error::NULL_POINTER, __FILE__, __LINE__ );
        }
        else{
                i->second->end();
        }
}

const map<string, Profiler *> & RelationalNode::getProfilers( void ){
        return( m_profilers );
}

#endif

RelationalNode::~RelationalNode( void ){
        if( m_parents ){
                for( unsigned int i = 0; i < m_parents->size(); i++ ){
                        m_parents->getItem( i )->removeChild( getSharedPtr< RelationalNode >(), true );
                }
        }
        if( m_children ){
                for( unsigned int i = 0; i < m_children->size(); i++ ){
                        m_children->getItem( i )->removeParent( getSharedPtr< RelationalNode >(), true );
                }
        }
#ifdef RT_PROFILER
        map<string, Profiler *>::iterator i = m_profilers.begin();
        for( ; i != m_profilers.end(); i++ ){
                delete i->second;
        }
        m_profilers.clear();
#endif

}

void RelationalNode::onPropertyEvent( const PropertyEvent & e ){

}

void RelationalNode::onInitialize( void ){

}

void RelationalNode::onTransform( const Mat4 & global ){
        TransformNode::onTransform( global );
        // update the children
        for( unsigned int i = 0; i < m_children->size(); i++ ){
                m_children->getItem( i )->transform( m_global );
        }
}

void RelationalNode::gatherUniqueChildren( const RelationalNodePtr model, RelationalNodeList & unique ) const {
        if( std::find( unique.begin(), unique.end(), model ) == unique.end() ){
                unique.push_back( model );
        }
        for( unsigned int i = 0; i < model->getChildren()->size(); i++ ){
                gatherUniqueChildren( model->getChildren()->getItem( i ), unique );
        }
}

bool  RelationalNode::addParent( const RelationalNodePtr ptr, bool send ){ 
        // if already a parent
        if( hasParent( ptr ) ){
                return( false );
        }
        // else add
        m_parents->addProperty( ptr, send );
        // if this is not already a child
        if( ! ptr->hasChild( getSharedPtr< RelationalNode >() ) ){
                ptr->addChild( getSharedPtr< RelationalNode >(), send );
        }
        return( true ); 
}

bool  RelationalNode::addChild( const RelationalNodePtr ptr, bool send ){ 
        // if already a child
        if( hasChild( ptr ) ){
                return( false );
        }
        // else add
        m_children->addProperty( ptr, send );

        // if the child is not already parented
        if( ! ptr->hasParent( getSharedPtr< RelationalNode >() ) ){
                ptr->addParent( getSharedPtr< RelationalNode >(), send );
        }
        return( true ); 
}

const RelationalNodeContainerPtr RelationalNode::getChildren( void ) const {
        return( m_children );
}

const RelationalNodeContainerPtr RelationalNode::getParents( void ) const {
        return( m_parents );
}

const RelationalNodePtr RelationalNode::getParent( int i ) const {
        if( i >= 0 && i < (int)m_parents->size() ){
                return( m_parents->getItem( i ) );
        }
        else{
                Error::warning( Error::INDEX_OUT_OF_BOUNDS, __FILE__, __LINE__ );
                return( RelationalNodePtr() );
        }
}

const RelationalNodePtr RelationalNode::getChild( unsigned int index ) const {
        if( index >= 0 && index < (int)m_children->size() ){
                return( m_children->getItem( index ) );
        }
        else{
                Error::warning( Error::INDEX_OUT_OF_BOUNDS, __FILE__, __LINE__ );
                return( RelationalNodePtr() );
        }
}

const RelationalNodePtr RelationalNode::getChild( const string name ) const {
        if( m_name == name ){
                return( getSharedPtr< RelationalNode >() );
        }
        else{
                for( unsigned int i = 0; i < m_children->size(); i++ ){
                        RelationalNodePtr ptr = m_children->getItem( i )->getChild( name );
                        if( ptr ){
                                return( ptr );
                        }
                }
                return( RelationalNodePtr() );
        }
}

const RelationalNodePtr RelationalNode::getChild( string name, RelationalNodeList & path ) const {
        path.push_back( getSharedPtr< RelationalNode >() );

        if( m_name == name ){
                return( getSharedPtr< RelationalNode >() );
        }
        else{
                for( unsigned int i = 0; i < m_children->size(); i++ ){
                        RelationalNodePtr child = m_children->getItem( i )->getChild( name, path );
                        if( child ){
                                return( child );
                        }
                }
                path.pop_back();
                return( RelationalNodePtr() );
        }
}

const RelationalNodePtr RelationalNode::getChild( const RelationalNodePtr model, RelationalNodeList & path ) const {
        path.push_back( getSharedPtr< RelationalNode >() );

        if( getSharedPtr< RelationalNode >() == model ){
                return( model );
        }
        else{
                for( unsigned int i = 0; i < m_children->size(); i++ ){
                        RelationalNodePtr child = m_children->getItem( i )->getChild( model, path );
                        if( child ){
                                return( child );
                        }
                }
                path.pop_back();
                return( RelationalNodePtr() );
        }
}

bool RelationalNode::hasParent( const RelationalNodePtr model ) const {
        unsigned int i;
        for( i = 0; i < m_parents->size(); i++ ){
                if( m_parents->getItem( i ) == model ){
                        return( true );
                }
        }
        return( false );
}

bool RelationalNode::hasChild( const RelationalNodePtr model ) const {
        unsigned int i;
        for( i = 0; i < m_children->size(); i++ ){
                if( m_children->getItem( i ) == model ){
                        return( true );
                }
        }
        return( false );
}

bool RelationalNode::removeParent( const RelationalNodePtr model, bool send ){
        unsigned int i;
        for( i = 0; i < m_parents->size(); i++ ){
                if( m_parents->getItem( i ) == model ){
                        m_parents->removeProperty( i, send );
                        if( model->hasChild( getSharedPtr< RelationalNode >() ) ){
                                model->removeChild( getSharedPtr< RelationalNode >(), send );
                        }
                        return( true );
                }
        }
        return( false );
}

bool RelationalNode::removeChild( const RelationalNodePtr model, bool send ){
        unsigned int i;
        for( i = 0; i < m_children->size(); i++ ){
                if( m_children->getItem( i ) == model ){
                        m_children->removeProperty( i, send );
                        if( model->hasParent( getSharedPtr< RelationalNode >() ) ){
                                model->removeParent( getSharedPtr< RelationalNode >(), send );
                        }
                        
                        return( true );
                }
        }
        return( false );
}

bool RelationalNode::removeChild( int i, bool send ){
        if( i >= 0 && i < (int)m_children->size() ){
                return( removeChild( m_children->getItem( i ), send ) );
        }
        else{
                Error::warning( Error::INDEX_OUT_OF_BOUNDS, __FILE__, __LINE__ );
                return( false );
        }
}

bool RelationalNode::removeParent( int i, bool send ){
        if( i >= 0 && i < (int)m_parents->size() ){
                RelationalNodePtr model = m_parents->getItem( i );
                m_parents->removeProperty( i, send );
                if( model->hasChild( getSharedPtr< RelationalNode >() ) ){
                        model->removeChild( getSharedPtr< RelationalNode >(), send );
                }
                return( true );
        }
        else{
                Error::warning( Error::INDEX_OUT_OF_BOUNDS, __FILE__, __LINE__ );
                return( false );
        }
}


};

---