C:/development/RenderTools/src/factory/rendernode/Rendernode.h

Go to the documentation of this file.

#pragma once
#ifndef RENDERNODE_H
#define RENDERNODE_H

#include "Types.h"
#include "AbstractPropertyContainer.h"
#include "PropertyProxyContainer.h"
#include "BindingInterface.h"
#include "RenderInterface.h"
#include "RelationalNode.h"

using namespace std;

namespace RenderTools {

class Rendernode : public BindingInterface, public RenderInterface, public RelationalNode {
public:
        typedef unsigned int ComponentMask;
        enum RenderComponents{
                NONE    = 0x0000,
                BOUNDS  = 0x0001,
                AXES    = 0x0002,
                NORMALS = 0x0040,
                ALL             = 0xFFFF
        };

        Rendernode( void );
        virtual ~Rendernode( void );

        static PropertyPtr                                      create( const XMLNodePtr & xml = XMLNodePtr() );
        virtual void                                            createProperties( void );
        virtual const string                            getTypeName( bool ofComponent = false ) const;

        void                                                            removeVertexBuffers( bool send = true );
        void                                                            addVertexBuffer( const string buffer, bool send = true );
        void                                                            addVertexBuffer( const VertexbufferPtr buffer, bool send = true );
        const VertexbufferProxyContainerPtr     getVertexbufferProxies( void ) const;
        const Vec3 &                                            getColor( void ) const;
        void                                                            setColor( const Vec3 & color, bool send = true );
        virtual void                                            onInitialize( void );
        virtual void                                            onRender( void );
        virtual void                                            onBind( int unit = -1 );
        virtual void                                            onUnbind( int unit = -1 );

#ifndef RT_GLES1
        void                                                            setProgram( string name, bool send = true );
        const ProgramProxyPtr                           getProgramProxy( void ) const;
#endif
        void                                                            setSampler( string name, bool send = true );
        const SamplerProxyPtr                           getSamplerProxy( void ) const;
        void                                                            setStateset( string name, bool send = true );
        const StatesetProxyPtr                          getStatesetProxy( void ) const;

        void                                                            setComponentMask( ComponentMask mask, bool send = true ); 
        void                                                            setComponentMask( int mask, bool send = true ); 
        ComponentMask                                           getComponentMask( void ) const;
        void                                                            setIndex( int index, bool send = true );
        bool                                                            getVisible( void ) const;
        void                                                            setVisible( bool state, bool send = true );

protected:
        Vec3                                                            m_color;
#ifndef RT_GLES1
        ProgramProxyPtr                                         m_program;
#endif
        StatesetProxyPtr                                        m_stateset;
        SamplerProxyPtr                                         m_sampler;
        VertexbufferProxyContainerPtr           m_buffers;
        ComponentMask                                           m_componentMask; 
        int                                                                     m_index; // if set ( ie > -1 ) the 'nodeIndex' uniform is set to this value
        bool                                                            m_visible;
};

struct RenderComponentMaskStruct {
        RenderComponentMaskStruct( Rendernode::ComponentMask * e = 0 ):
                m_value( e ){
        }

        bool operator == ( const RenderComponentMaskStruct & v2 ) const{
                return( m_value == v2.m_value );
        }

        Rendernode::ComponentMask * m_value;
};

inline EnumList getRenderComponentsEnums( void ){
        EnumList r;
        r.push_back("NONE");
        r.push_back("BOUNDS");
        r.push_back("AXES");
        r.push_back("NORMALS");
        r.push_back("ALL");
        return( r );
}

inline ostream & operator << ( ostream & s, const RenderComponentMaskStruct & v ){
        if( ( * v.m_value ) == Rendernode::NONE ){
                s << string( "NONE" );
        }
        else{
                if( ( * v.m_value ) & Rendernode::BOUNDS ) s << string( "BOUNDS " );
                if( ( * v.m_value ) & Rendernode::AXES ) s << string( "AXES " );
                if( ( * v.m_value ) & Rendernode::NORMALS ) s << string( "NORMALS " );
        }
        return( s );
}

inline istream & operator >> ( istream & s, RenderComponentMaskStruct & v ){
        ( * v.m_value ) = Rendernode::NONE;
        string value;
        while( ! s.fail() ){
                s >> value;
                if( value == "BOUNDS" ){
                        ( * v.m_value ) |= Rendernode::BOUNDS;
                }
                else if( value == "AXES" ){
                        ( * v.m_value ) |= Rendernode::AXES;
                }
                else if( value == "NORMALS" ){
                        ( * v.m_value ) |= Rendernode::NORMALS;
                }
                else if( value == "ALL" ){
                        ( * v.m_value ) |= Rendernode::ALL;
                }
        }
        return( s );
}

}; // namespace RenderTools


#endif

---