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

Go to the documentation of this file.

#include "Renderpass.h"
#include "Rendergroup.h"
#include "Error.h"
#include "StopWatch.h"
#include "Profiler.h"
#include "Program.h"
#include "Stateset.h"
#include "Factory.h"
#include "Property.h"
#include "Framebuffer.h"
#include "Rendernode.h"
#include "PropertyProxy.h"

namespace RenderTools{

Renderpass::Renderpass( void ):
        AbstractPropertyContainer(){

}

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

void Renderpass::createProperties( void ){
        AbstractPropertyContainer::createProperties();
        createProperty( this, "rendernodes", & m_rendernodes );
        createProperty( this, "camera", & m_camera );
        createProperty( this, "drawbuffer", & m_drawbuffer );
        createProperty( this, "copybuffer", & m_copybuffer );
}

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


Renderpass::~Renderpass( void ){
}

void Renderpass::addRendernode( const RendernodePtr p ){ 
        if( Rendergroup::getActiveRendergroup() && ! Rendergroup::getActiveRendergroup()->isPointer( p ) ){
                Rendergroup::getActiveRendergroup()->addRendernode( p );
        }
        addRendernode( p->getName() );
}

void Renderpass::addRendernode( const string name ){ 
        RendernodeProxyPtr item( createProperty( m_rendernodes, name ) );
        if( isInitialized() ){
                item->initialize();
        }
}

void Renderpass::removeRendernode( const RendernodePtr ptr ){
        for( unsigned int i = 0; i < m_rendernodes->size(); i++ ){
                if( m_rendernodes->getItem( i )->getPointer() == ptr ){
                        m_rendernodes->removeProperty( i, true );
                        i = 0;
                }
        }
}

void Renderpass::removeRendernodes( void ){
        m_rendernodes->removeProperties();
}

void Renderpass::setDrawbuffer( const string name ){ 
        m_drawbuffer->setName( name ); 
}

void Renderpass::setCopybuffer( const string name ){ 
        m_copybuffer->setName( name ); 
}

void Renderpass::setCamera( const string name ){ 
        m_camera->setName( name ); 
}

const RendernodeProxyPtr Renderpass::getRendernodeProxy( unsigned int which ) const {
        return( m_rendernodes->getItem( which ) ); 
}

const CameraProxyPtr Renderpass::getCameraProxy( void ) const {
        return( m_camera );
}

const FramebufferProxyPtr Renderpass::getDrawbufferProxy( void ) const {
        return( m_drawbuffer );
}

const FramebufferProxyPtr Renderpass::getCopybufferProxy( void ) const {
        return( m_copybuffer );
}

const RendernodeProxyContainerPtr Renderpass::getRendernodeProxies( void ) const {
        return( m_rendernodes );
}

void Renderpass::onInitialize( void ){
        for( unsigned int i = 0; i < m_rendernodes->size(); i++ ){
                m_rendernodes->getItem( i )->initialize();
        }
        m_drawbuffer->initialize();
        m_copybuffer->initialize();
        m_camera->initialize();
}

void Renderpass::onBind( int unit ){
        m_drawbuffer->bind();
        m_camera->bind();
}

void Renderpass::onUnbind( int unit ){
        if( m_drawbuffer->getPointer() && m_copybuffer->getPointer() ){
                Framebuffer::copy( const_pointer_cast< Framebuffer >( m_drawbuffer->getPointer() ), const_pointer_cast< Framebuffer >( m_copybuffer->getPointer() ) );
                m_drawbuffer->getPointer()->unbind();
        }
}

RenderpassPtr   Renderpass::operator << ( const CameraPtr p ){
        if( Rendergroup::getActiveRendergroup() ){
                if( ! Rendergroup::getActiveRendergroup()->isPointer( p ) ){
                        Rendergroup::getActiveRendergroup()->addCamera( p );
                }
        }
        else{
                Error::warning( Error::NO_ACTIVE_GROUP, __FILE__, __LINE__ );
        }
        if( m_camera->getName() == "" ){
                setCamera( p->getName() );
        }
        else{
                Error::warning( Error::ITEM_ALREADY_EXISTS, __FILE__, __LINE__ );
                return( RenderpassPtr() );
        }
        return( dynamic_pointer_cast< Renderpass, AbstractProperty >( getSharedPtr< AbstractProperty >() ) );
}

RenderpassPtr   Renderpass::operator << ( const RendernodePtr p ){
        if( Rendergroup::getActiveRendergroup() ){
                if( ! Rendergroup::getActiveRendergroup()->isPointer( p ) ){
                        Rendergroup::getActiveRendergroup()->addRendernode( p );
                }
        }
        else{
                Error::warning( Error::NO_ACTIVE_GROUP, __FILE__, __LINE__ );
        }
        addRendernode( p->getName() );
        return( dynamic_pointer_cast< Renderpass, AbstractProperty >( getSharedPtr< AbstractProperty >() ) );
}

RenderpassPtr   Renderpass::operator << ( const FramebufferPtr p ){
        if( Rendergroup::getActiveRendergroup() ){
                if( ! Rendergroup::getActiveRendergroup()->isPointer( p ) ){
                        Rendergroup::getActiveRendergroup()->addFramebuffer( p );
                }
        }
        else{
                Error::warning( Error::NO_ACTIVE_GROUP, __FILE__, __LINE__ );
        }
        if( m_drawbuffer->getName() == "" ){
                setDrawbuffer( p->getName() );
        }
        else if( m_copybuffer->getName() == "" ){
                setCopybuffer( p->getName() );
        }
        else{
                Error::warning( Error::ITEM_ALREADY_EXISTS, __FILE__, __LINE__ );
                return( RenderpassPtr() );
        }
        return( dynamic_pointer_cast< Renderpass, AbstractProperty >( getSharedPtr< AbstractProperty >() ) );
}

RenderpassPtr Renderpass::operator << ( const XMLNodePtr xml ){

        if( Rendergroup::getActiveRendergroup() ){
                if( xml->getTagName() == "Camera" ){
                        CameraPtr p = dynamic_pointer_cast< Camera, AbstractProperty >( Factory::create( xml ) );
                        if( ! Rendergroup::getActiveRendergroup()->findCamera( p->getName() ) ){
                                Rendergroup::getActiveRendergroup()->addCamera( p );
                                setCamera( p->getName() );
                        }
                        else{
                                setCamera( p->getName() );
                                Error::warning( Error::ITEM_ALREADY_EXISTS, __FILE__, __LINE__ );
                                return( RenderpassPtr() );
                        }
                }
                else if( xml->getTagName() == "Rendernode" ){
                        RendernodePtr p = dynamic_pointer_cast< Rendernode, AbstractProperty >( Factory::create( xml ) );
                        if( ! Rendergroup::getActiveRendergroup()->findRendernode( p->getName() ) ){
                                Rendergroup::getActiveRendergroup()->addRendernode( p );
                                addRendernode( p->getName() );
                        }
                        else{
                                addRendernode( p->getName() );
                                Error::warning( Error::ITEM_ALREADY_EXISTS, __FILE__, __LINE__ );
                                return( RenderpassPtr() );
                        }
                }
                else if( xml->getTagName() == "Framebuffer" ){
                        FramebufferPtr p = dynamic_pointer_cast< Framebuffer, AbstractProperty >( Factory::create( xml ) );
                        if( ! Rendergroup::getActiveRendergroup()->findFramebuffer( p->getName() ) ){
                                Rendergroup::getActiveRendergroup()->addFramebuffer( p );
                                if( m_drawbuffer->getName() == "" ){
                                        setDrawbuffer( p->getName() );
                                }
                                else if( m_copybuffer->getName() == "" ){
                                        setCopybuffer( p->getName() );
                                }
                                else{
                                        Error::warning( Error::ITEM_ALREADY_EXISTS, __FILE__, __LINE__ );
                                }
                        }
                        else{
                                setDrawbuffer( p->getName() );
                                Error::warning( Error::ITEM_ALREADY_EXISTS, __FILE__, __LINE__ );
                                return( RenderpassPtr() );
                        }
                }
        }
        else{
                Error::warning( Error::NO_ACTIVE_GROUP, __FILE__, __LINE__ );
        }
        return( dynamic_pointer_cast< Renderpass, AbstractProperty >( getSharedPtr< AbstractProperty >() ) );
}


};

---