// This file has been generated by Py++.

#include "boost/python.hpp"
#include "generators/include/python_CEGUIOpenGLRenderer.h"
#include "OpenGLGeometryBufferBase.pypp.hpp"

namespace bp = boost::python;

struct OpenGLGeometryBufferBase_wrapper : CEGUI::OpenGLGeometryBufferBase, bp::wrapper< CEGUI::OpenGLGeometryBufferBase > {

    OpenGLGeometryBufferBase_wrapper(::CEGUI::OpenGLRendererBase & owner )
    : CEGUI::OpenGLGeometryBufferBase( boost::ref(owner) )
      , bp::wrapper< CEGUI::OpenGLGeometryBufferBase >(){
        // constructor
    
    }

    virtual void appendGeometry( ::CEGUI::Vertex const * const vbuff, ::CEGUI::uint vertex_count ) {
        if( bp::override func_appendGeometry = this->get_override( "appendGeometry" ) )
            func_appendGeometry( vbuff, vertex_count );
        else{
            this->CEGUI::OpenGLGeometryBufferBase::appendGeometry( vbuff, vertex_count );
        }
    }
    
    void default_appendGeometry( ::CEGUI::Vertex const * const vbuff, ::CEGUI::uint vertex_count ) {
        CEGUI::OpenGLGeometryBufferBase::appendGeometry( vbuff, vertex_count );
    }

    virtual void appendVertex( ::CEGUI::Vertex const & vertex ) {
        if( bp::override func_appendVertex = this->get_override( "appendVertex" ) )
            func_appendVertex( boost::ref(vertex) );
        else{
            this->CEGUI::OpenGLGeometryBufferBase::appendVertex( boost::ref(vertex) );
        }
    }
    
    void default_appendVertex( ::CEGUI::Vertex const & vertex ) {
        CEGUI::OpenGLGeometryBufferBase::appendVertex( boost::ref(vertex) );
    }

    virtual ::CEGUI::Texture * getActiveTexture(  ) const  {
        if( bp::override func_getActiveTexture = this->get_override( "getActiveTexture" ) )
            return func_getActiveTexture(  );
        else{
            return this->CEGUI::OpenGLGeometryBufferBase::getActiveTexture(  );
        }
    }
    
    ::CEGUI::Texture * default_getActiveTexture(  ) const  {
        return CEGUI::OpenGLGeometryBufferBase::getActiveTexture( );
    }

    virtual ::CEGUI::uint getBatchCount(  ) const  {
        if( bp::override func_getBatchCount = this->get_override( "getBatchCount" ) )
            return func_getBatchCount(  );
        else{
            return this->CEGUI::OpenGLGeometryBufferBase::getBatchCount(  );
        }
    }
    
    ::CEGUI::uint default_getBatchCount(  ) const  {
        return CEGUI::OpenGLGeometryBufferBase::getBatchCount( );
    }

    virtual ::CEGUI::RenderEffect * getRenderEffect(  ) {
        if( bp::override func_getRenderEffect = this->get_override( "getRenderEffect" ) )
            return func_getRenderEffect(  );
        else{
            return this->CEGUI::OpenGLGeometryBufferBase::getRenderEffect(  );
        }
    }
    
    ::CEGUI::RenderEffect * default_getRenderEffect(  ) {
        return CEGUI::OpenGLGeometryBufferBase::getRenderEffect( );
    }

    virtual ::CEGUI::uint getVertexCount(  ) const  {
        if( bp::override func_getVertexCount = this->get_override( "getVertexCount" ) )
            return func_getVertexCount(  );
        else{
            return this->CEGUI::OpenGLGeometryBufferBase::getVertexCount(  );
        }
    }
    
    ::CEGUI::uint default_getVertexCount(  ) const  {
        return CEGUI::OpenGLGeometryBufferBase::getVertexCount( );
    }

    virtual bool isClippingActive(  ) const  {
        if( bp::override func_isClippingActive = this->get_override( "isClippingActive" ) )
            return func_isClippingActive(  );
        else{
            return this->CEGUI::OpenGLGeometryBufferBase::isClippingActive(  );
        }
    }
    
    bool default_isClippingActive(  ) const  {
        return CEGUI::OpenGLGeometryBufferBase::isClippingActive( );
    }

    void performBatchManagement(  ){
        CEGUI::OpenGLGeometryBufferBase::performBatchManagement(  );
    }

    virtual void reset(  ) {
        if( bp::override func_reset = this->get_override( "reset" ) )
            func_reset(  );
        else{
            this->CEGUI::OpenGLGeometryBufferBase::reset(  );
        }
    }
    
    void default_reset(  ) {
        CEGUI::OpenGLGeometryBufferBase::reset( );
    }

    virtual void setActiveTexture( ::CEGUI::Texture * texture ) {
        if( bp::override func_setActiveTexture = this->get_override( "setActiveTexture" ) )
            func_setActiveTexture( boost::python::ptr(texture) );
        else{
            this->CEGUI::OpenGLGeometryBufferBase::setActiveTexture( boost::python::ptr(texture) );
        }
    }
    
    void default_setActiveTexture( ::CEGUI::Texture * texture ) {
        CEGUI::OpenGLGeometryBufferBase::setActiveTexture( boost::python::ptr(texture) );
    }

    virtual void setClippingActive( bool const active ) {
        if( bp::override func_setClippingActive = this->get_override( "setClippingActive" ) )
            func_setClippingActive( active );
        else{
            this->CEGUI::OpenGLGeometryBufferBase::setClippingActive( active );
        }
    }
    
    void default_setClippingActive( bool const active ) {
        CEGUI::OpenGLGeometryBufferBase::setClippingActive( active );
    }

    virtual void setClippingRegion( ::CEGUI::Rectf const & region ) {
        if( bp::override func_setClippingRegion = this->get_override( "setClippingRegion" ) )
            func_setClippingRegion( boost::ref(region) );
        else{
            this->CEGUI::OpenGLGeometryBufferBase::setClippingRegion( boost::ref(region) );
        }
    }
    
    void default_setClippingRegion( ::CEGUI::Rectf const & region ) {
        CEGUI::OpenGLGeometryBufferBase::setClippingRegion( boost::ref(region) );
    }

    virtual void setPivot( ::CEGUI::Vector3f const & p ) {
        if( bp::override func_setPivot = this->get_override( "setPivot" ) )
            func_setPivot( boost::ref(p) );
        else{
            this->CEGUI::OpenGLGeometryBufferBase::setPivot( boost::ref(p) );
        }
    }
    
    void default_setPivot( ::CEGUI::Vector3f const & p ) {
        CEGUI::OpenGLGeometryBufferBase::setPivot( boost::ref(p) );
    }

    virtual void setRenderEffect( ::CEGUI::RenderEffect * effect ) {
        if( bp::override func_setRenderEffect = this->get_override( "setRenderEffect" ) )
            func_setRenderEffect( boost::python::ptr(effect) );
        else{
            this->CEGUI::OpenGLGeometryBufferBase::setRenderEffect( boost::python::ptr(effect) );
        }
    }
    
    void default_setRenderEffect( ::CEGUI::RenderEffect * effect ) {
        CEGUI::OpenGLGeometryBufferBase::setRenderEffect( boost::python::ptr(effect) );
    }

    virtual void setRotation( ::CEGUI::Quaternion const & r ) {
        if( bp::override func_setRotation = this->get_override( "setRotation" ) )
            func_setRotation( boost::ref(r) );
        else{
            this->CEGUI::OpenGLGeometryBufferBase::setRotation( boost::ref(r) );
        }
    }
    
    void default_setRotation( ::CEGUI::Quaternion const & r ) {
        CEGUI::OpenGLGeometryBufferBase::setRotation( boost::ref(r) );
    }

    virtual void setTranslation( ::CEGUI::Vector3f const & t ) {
        if( bp::override func_setTranslation = this->get_override( "setTranslation" ) )
            func_setTranslation( boost::ref(t) );
        else{
            this->CEGUI::OpenGLGeometryBufferBase::setTranslation( boost::ref(t) );
        }
    }
    
    void default_setTranslation( ::CEGUI::Vector3f const & t ) {
        CEGUI::OpenGLGeometryBufferBase::setTranslation( boost::ref(t) );
    }

    void updateMatrix(  ) const {
        CEGUI::OpenGLGeometryBufferBase::updateMatrix(  );
    }

    virtual void draw(  ) const {
        bp::override func_draw = this->get_override( "draw" );
        func_draw(  );
    }

};

void register_OpenGLGeometryBufferBase_class(){

    { //::CEGUI::OpenGLGeometryBufferBase
        typedef bp::class_< OpenGLGeometryBufferBase_wrapper, bp::bases< ::CEGUI::GeometryBuffer >, boost::noncopyable > OpenGLGeometryBufferBase_exposer_t;
        OpenGLGeometryBufferBase_exposer_t OpenGLGeometryBufferBase_exposer = OpenGLGeometryBufferBase_exposer_t( "OpenGLGeometryBufferBase", "*!\n\
        \n\
            OpenGL based implementation of the GeometryBuffer interface.\n\
        *\n", bp::init< CEGUI::OpenGLRendererBase & >(( bp::arg("owner") ), "! Constructor\n") );
        bp::scope OpenGLGeometryBufferBase_scope( OpenGLGeometryBufferBase_exposer );
        { //::CEGUI::OpenGLGeometryBufferBase::appendGeometry
        
            typedef void ( ::CEGUI::OpenGLGeometryBufferBase::*appendGeometry_function_type )( ::CEGUI::Vertex const * const,::CEGUI::uint ) ;
            typedef void ( OpenGLGeometryBufferBase_wrapper::*default_appendGeometry_function_type )( ::CEGUI::Vertex const * const,::CEGUI::uint ) ;
            
            OpenGLGeometryBufferBase_exposer.def( 
                "appendGeometry"
                , appendGeometry_function_type(&::CEGUI::OpenGLGeometryBufferBase::appendGeometry)
                , default_appendGeometry_function_type(&OpenGLGeometryBufferBase_wrapper::default_appendGeometry)
                , ( bp::arg("vbuff"), bp::arg("vertex_count") ) );
        
        }
        { //::CEGUI::OpenGLGeometryBufferBase::appendVertex
        
            typedef void ( ::CEGUI::OpenGLGeometryBufferBase::*appendVertex_function_type )( ::CEGUI::Vertex const & ) ;
            typedef void ( OpenGLGeometryBufferBase_wrapper::*default_appendVertex_function_type )( ::CEGUI::Vertex const & ) ;
            
            OpenGLGeometryBufferBase_exposer.def( 
                "appendVertex"
                , appendVertex_function_type(&::CEGUI::OpenGLGeometryBufferBase::appendVertex)
                , default_appendVertex_function_type(&OpenGLGeometryBufferBase_wrapper::default_appendVertex)
                , ( bp::arg("vertex") ) );
        
        }
        { //::CEGUI::OpenGLGeometryBufferBase::getActiveTexture
        
            typedef ::CEGUI::Texture * ( ::CEGUI::OpenGLGeometryBufferBase::*getActiveTexture_function_type )(  ) const;
            typedef ::CEGUI::Texture * ( OpenGLGeometryBufferBase_wrapper::*default_getActiveTexture_function_type )(  ) const;
            
            OpenGLGeometryBufferBase_exposer.def( 
                "getActiveTexture"
                , getActiveTexture_function_type(&::CEGUI::OpenGLGeometryBufferBase::getActiveTexture)
                , default_getActiveTexture_function_type(&OpenGLGeometryBufferBase_wrapper::default_getActiveTexture)
                , bp::return_value_policy< bp::reference_existing_object >() );
        
        }
        { //::CEGUI::OpenGLGeometryBufferBase::getBatchCount
        
            typedef ::CEGUI::uint ( ::CEGUI::OpenGLGeometryBufferBase::*getBatchCount_function_type )(  ) const;
            typedef ::CEGUI::uint ( OpenGLGeometryBufferBase_wrapper::*default_getBatchCount_function_type )(  ) const;
            
            OpenGLGeometryBufferBase_exposer.def( 
                "getBatchCount"
                , getBatchCount_function_type(&::CEGUI::OpenGLGeometryBufferBase::getBatchCount)
                , default_getBatchCount_function_type(&OpenGLGeometryBufferBase_wrapper::default_getBatchCount) );
        
        }
        { //::CEGUI::OpenGLGeometryBufferBase::getRenderEffect
        
            typedef ::CEGUI::RenderEffect * ( ::CEGUI::OpenGLGeometryBufferBase::*getRenderEffect_function_type )(  ) ;
            typedef ::CEGUI::RenderEffect * ( OpenGLGeometryBufferBase_wrapper::*default_getRenderEffect_function_type )(  ) ;
            
            OpenGLGeometryBufferBase_exposer.def( 
                "getRenderEffect"
                , getRenderEffect_function_type(&::CEGUI::OpenGLGeometryBufferBase::getRenderEffect)
                , default_getRenderEffect_function_type(&OpenGLGeometryBufferBase_wrapper::default_getRenderEffect)
                , bp::return_value_policy< bp::reference_existing_object >() );
        
        }
        { //::CEGUI::OpenGLGeometryBufferBase::getVertexCount
        
            typedef ::CEGUI::uint ( ::CEGUI::OpenGLGeometryBufferBase::*getVertexCount_function_type )(  ) const;
            typedef ::CEGUI::uint ( OpenGLGeometryBufferBase_wrapper::*default_getVertexCount_function_type )(  ) const;
            
            OpenGLGeometryBufferBase_exposer.def( 
                "getVertexCount"
                , getVertexCount_function_type(&::CEGUI::OpenGLGeometryBufferBase::getVertexCount)
                , default_getVertexCount_function_type(&OpenGLGeometryBufferBase_wrapper::default_getVertexCount) );
        
        }
        { //::CEGUI::OpenGLGeometryBufferBase::isClippingActive
        
            typedef bool ( ::CEGUI::OpenGLGeometryBufferBase::*isClippingActive_function_type )(  ) const;
            typedef bool ( OpenGLGeometryBufferBase_wrapper::*default_isClippingActive_function_type )(  ) const;
            
            OpenGLGeometryBufferBase_exposer.def( 
                "isClippingActive"
                , isClippingActive_function_type(&::CEGUI::OpenGLGeometryBufferBase::isClippingActive)
                , default_isClippingActive_function_type(&OpenGLGeometryBufferBase_wrapper::default_isClippingActive) );
        
        }
        { //::CEGUI::OpenGLGeometryBufferBase::performBatchManagement
        
            typedef void ( OpenGLGeometryBufferBase_wrapper::*performBatchManagement_function_type )(  ) ;
            
            OpenGLGeometryBufferBase_exposer.def( 
                "performBatchManagement"
                , performBatchManagement_function_type( &OpenGLGeometryBufferBase_wrapper::performBatchManagement )
                , "! perform batch management operations prior to adding new geometry.\n" );
        
        }
        { //::CEGUI::OpenGLGeometryBufferBase::reset
        
            typedef void ( ::CEGUI::OpenGLGeometryBufferBase::*reset_function_type )(  ) ;
            typedef void ( OpenGLGeometryBufferBase_wrapper::*default_reset_function_type )(  ) ;
            
            OpenGLGeometryBufferBase_exposer.def( 
                "reset"
                , reset_function_type(&::CEGUI::OpenGLGeometryBufferBase::reset)
                , default_reset_function_type(&OpenGLGeometryBufferBase_wrapper::default_reset) );
        
        }
        { //::CEGUI::OpenGLGeometryBufferBase::setActiveTexture
        
            typedef void ( ::CEGUI::OpenGLGeometryBufferBase::*setActiveTexture_function_type )( ::CEGUI::Texture * ) ;
            typedef void ( OpenGLGeometryBufferBase_wrapper::*default_setActiveTexture_function_type )( ::CEGUI::Texture * ) ;
            
            OpenGLGeometryBufferBase_exposer.def( 
                "setActiveTexture"
                , setActiveTexture_function_type(&::CEGUI::OpenGLGeometryBufferBase::setActiveTexture)
                , default_setActiveTexture_function_type(&OpenGLGeometryBufferBase_wrapper::default_setActiveTexture)
                , ( bp::arg("texture") ) );
        
        }
        { //::CEGUI::OpenGLGeometryBufferBase::setClippingActive
        
            typedef void ( ::CEGUI::OpenGLGeometryBufferBase::*setClippingActive_function_type )( bool const ) ;
            typedef void ( OpenGLGeometryBufferBase_wrapper::*default_setClippingActive_function_type )( bool const ) ;
            
            OpenGLGeometryBufferBase_exposer.def( 
                "setClippingActive"
                , setClippingActive_function_type(&::CEGUI::OpenGLGeometryBufferBase::setClippingActive)
                , default_setClippingActive_function_type(&OpenGLGeometryBufferBase_wrapper::default_setClippingActive)
                , ( bp::arg("active") ) );
        
        }
        { //::CEGUI::OpenGLGeometryBufferBase::setClippingRegion
        
            typedef void ( ::CEGUI::OpenGLGeometryBufferBase::*setClippingRegion_function_type )( ::CEGUI::Rectf const & ) ;
            typedef void ( OpenGLGeometryBufferBase_wrapper::*default_setClippingRegion_function_type )( ::CEGUI::Rectf const & ) ;
            
            OpenGLGeometryBufferBase_exposer.def( 
                "setClippingRegion"
                , setClippingRegion_function_type(&::CEGUI::OpenGLGeometryBufferBase::setClippingRegion)
                , default_setClippingRegion_function_type(&OpenGLGeometryBufferBase_wrapper::default_setClippingRegion)
                , ( bp::arg("region") ) );
        
        }
        { //::CEGUI::OpenGLGeometryBufferBase::setPivot
        
            typedef void ( ::CEGUI::OpenGLGeometryBufferBase::*setPivot_function_type )( ::CEGUI::Vector3f const & ) ;
            typedef void ( OpenGLGeometryBufferBase_wrapper::*default_setPivot_function_type )( ::CEGUI::Vector3f const & ) ;
            
            OpenGLGeometryBufferBase_exposer.def( 
                "setPivot"
                , setPivot_function_type(&::CEGUI::OpenGLGeometryBufferBase::setPivot)
                , default_setPivot_function_type(&OpenGLGeometryBufferBase_wrapper::default_setPivot)
                , ( bp::arg("p") ) );
        
        }
        { //::CEGUI::OpenGLGeometryBufferBase::setRenderEffect
        
            typedef void ( ::CEGUI::OpenGLGeometryBufferBase::*setRenderEffect_function_type )( ::CEGUI::RenderEffect * ) ;
            typedef void ( OpenGLGeometryBufferBase_wrapper::*default_setRenderEffect_function_type )( ::CEGUI::RenderEffect * ) ;
            
            OpenGLGeometryBufferBase_exposer.def( 
                "setRenderEffect"
                , setRenderEffect_function_type(&::CEGUI::OpenGLGeometryBufferBase::setRenderEffect)
                , default_setRenderEffect_function_type(&OpenGLGeometryBufferBase_wrapper::default_setRenderEffect)
                , ( bp::arg("effect") ) );
        
        }
        { //::CEGUI::OpenGLGeometryBufferBase::setRotation
        
            typedef void ( ::CEGUI::OpenGLGeometryBufferBase::*setRotation_function_type )( ::CEGUI::Quaternion const & ) ;
            typedef void ( OpenGLGeometryBufferBase_wrapper::*default_setRotation_function_type )( ::CEGUI::Quaternion const & ) ;
            
            OpenGLGeometryBufferBase_exposer.def( 
                "setRotation"
                , setRotation_function_type(&::CEGUI::OpenGLGeometryBufferBase::setRotation)
                , default_setRotation_function_type(&OpenGLGeometryBufferBase_wrapper::default_setRotation)
                , ( bp::arg("r") ) );
        
        }
        { //::CEGUI::OpenGLGeometryBufferBase::setTranslation
        
            typedef void ( ::CEGUI::OpenGLGeometryBufferBase::*setTranslation_function_type )( ::CEGUI::Vector3f const & ) ;
            typedef void ( OpenGLGeometryBufferBase_wrapper::*default_setTranslation_function_type )( ::CEGUI::Vector3f const & ) ;
            
            OpenGLGeometryBufferBase_exposer.def( 
                "setTranslation"
                , setTranslation_function_type(&::CEGUI::OpenGLGeometryBufferBase::setTranslation)
                , default_setTranslation_function_type(&OpenGLGeometryBufferBase_wrapper::default_setTranslation)
                , ( bp::arg("t") ) );
        
        }
        { //::CEGUI::OpenGLGeometryBufferBase::updateMatrix
        
            typedef void ( OpenGLGeometryBufferBase_wrapper::*updateMatrix_function_type )(  ) const;
            
            OpenGLGeometryBufferBase_exposer.def( 
                "updateMatrix"
                , updateMatrix_function_type( &OpenGLGeometryBufferBase_wrapper::updateMatrix )
                , "! update cached matrix\n" );
        
        }
    }

}
