Changeset 299


Ignore:
Timestamp:
08/07/14 10:10:24 (11 years ago)
Author:
epyon
Message:
  • all bind and update function for graphics objects are done via context (will simplify directx device, and allow for handles instead of objects)
Location:
trunk
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • trunk/nv/gfx/keyframed_mesh.hh

    r296 r299  
    1919        {
    2020        public:
    21                 keyframed_mesh( device* a_device, const mesh_data* a_data, const mesh_nodes_data* a_tag_map );
     21                keyframed_mesh( const mesh_data* a_data, const mesh_nodes_data* a_tag_map );
    2222                virtual size_t get_index_count() const { return m_index_count; }
    2323                virtual void run_animation( animation_entry* a_anim );
    … …  
    6767        {
    6868        public:
    69                 keyframed_mesh_gpu( device* a_device, const mesh_data* a_data, const mesh_nodes_data* a_tag_map );
     69                keyframed_mesh_gpu( context* a_context, const mesh_data* a_data, const mesh_nodes_data* a_tag_map );
    7070                void update( uint32 ms );
    7171                virtual void update( program* a_program );
    … …  
    8282        {
    8383        public:
    84                 keyframed_mesh_cpu( device* a_device, const mesh_data* a_data, const mesh_nodes_data* a_tag_map );
     84                keyframed_mesh_cpu( context* a_context, const mesh_data* a_data, const mesh_nodes_data* a_tag_map );
    8585                void update( uint32 ms );
    8686                ~keyframed_mesh_cpu();
    8787        private:
     88                context* m_context;
     89
    8890                uint8*         m_data;
    8991                vertex_buffer* m_vb;

  • trunk/nv/gfx/skeletal_mesh.hh

    r296 r299  
    4141        {
    4242        public:
    43                 skeletal_mesh_cpu( device* a_device, const mesh_data* a_mesh_data, const mesh_nodes_data* bones );
     43                skeletal_mesh_cpu( context* a_context, const mesh_data* a_mesh_data, const mesh_nodes_data* bones );
    4444                virtual size_t get_index_count() const { return m_indices; }
    4545                virtual void update_animation( animation_entry* a_anim, uint32 a_anim_time );
    4646                virtual ~skeletal_mesh_cpu();
    4747        protected:
     48                context*                     m_context;
    4849                uint32                       m_indices;
    4950                dynamic_array< md5_vtx_pnt > m_pntdata;
    … …  
    9192        {
    9293        public:
    93                 skeletal_mesh_gpu( device* a_device, const mesh_data* a_mesh, const mesh_nodes_data* a_bone_data );
     94                skeletal_mesh_gpu( context* a_context, const mesh_data* a_mesh, const mesh_nodes_data* a_bone_data );
    9495                virtual size_t get_index_count() const { return m_index_count; }
    9596                virtual void update( program* a_program );

  • trunk/nv/gfx/sliced_buffer.hh

    r152 r299  
    9393                static const size_t value_type_size = sizeof(T);
    9494
    95                 sliced_buffer( device* dev, buffer_hint hint, size_t initial_size, bool is_vertex = true )
    96                         : m_device( dev )
     95                sliced_buffer( context* ctx, buffer_hint hint, size_t initial_size, bool is_vertex = true )
     96                        : m_context( ctx )
    9797                        , m_buffer( nullptr )
    9898                        , m_hint( hint )
    … …  
    166166                        if ( m_max > 0 )
    167167                        {
    168                                 m_buffer->bind();
    169168                                size_t offset = m_min * value_type_size;
    170169                                size_t size   = (m_max-m_min) * value_type_size;
    171                                 m_buffer->update( m_data.data() + m_min, offset, size );
    172                                 m_buffer->unbind();
     170                                if ( m_is_vertex )
     171                                        m_context->update( (vertex_buffer*)m_buffer, m_data.data() + m_min, offset, size );
     172                                else
     173                                        m_context->update( (index_buffer*)m_buffer, m_data.data() + m_min, offset, size );
    173174                        }
    174175                        m_full_update = false;
    … …  
    202203                        delete m_buffer;
    203204                        if ( m_is_vertex )
    204                                 m_buffer = m_device->create_vertex_buffer( m_hint, size * value_type_size, nullptr );
     205                                m_buffer = m_context->get_device()->create_vertex_buffer( m_hint, size * value_type_size, nullptr );
    205206                        else
    206                                 m_buffer = m_device->create_index_buffer( m_hint, size * value_type_size, nullptr );
     207                                m_buffer = m_context->get_device()->create_index_buffer( m_hint, size * value_type_size, nullptr );
    207208                }
    208209        private:
    209                 device*     m_device;
     210                context*    m_context;
    210211                buffer*     m_buffer;
    211212                buffer_hint m_hint;

  • trunk/nv/gl/gl_context.hh

    r295 r299  
    2323        public:
    2424                ~gl_context();
     25                virtual void bind( texture2d* texture, texture_slot slot );
     26                virtual void bind( program* p );
     27                virtual void bind( vertex_buffer* b );
     28                virtual void bind( index_buffer* b );
     29                virtual void bind( vertex_array* va );
     30                virtual void unbind( program* p );
     31                virtual void unbind( index_buffer* b );
     32                virtual void unbind( vertex_buffer* b );
     33                virtual void unbind( vertex_array* va );
     34
     35                virtual void update( texture2d* texture, void* data );
     36                virtual void update( index_buffer* b, const void* data, size_t offset, size_t size );
     37                virtual void update( vertex_buffer* b, const void* data, size_t offset, size_t size );
     38
    2539                virtual void clear( const clear_state& cs );
    2640                // temporary

  • trunk/nv/gl/gl_program.hh

    r121 r299  
    4444        {
    4545        public:
     46                friend class gl_context;
     47
    4648                gl_program( const string& vertex_program, const string& fragment_program );
    4749                bool compile( const string& vertex_program, const string& fragment_program );
    4850
    49                 virtual void bind();
    50                 virtual void unbind();
    5151                virtual bool is_valid() const;
    5252

  • trunk/nv/gl/gl_texture2d.hh

    r292 r299  
    2222        {
    2323        public:
     24                friend class gl_context;
     25
    2426                gl_texture2d( ivec2 size, pixel_format aformat, datatype adatatype, sampler asampler, void* data = nullptr );
    25                 virtual void assign( void* data );
    26                 virtual void bind( size_t slot = 0 );
    27                 virtual void unbind();
    28                 virtual bool is_valid() const;
    2927        protected:
    3028                gl_texture_name m_name;

  • trunk/nv/gl/gl_vertex_buffer.hh

    r153 r299  
    2222        {
    2323        public:
     24                friend class gl_context;
     25
    2426                gl_vertex_buffer( buffer_hint hint, size_t size, const void* data = nullptr );
    25                 virtual void update( const void* data, size_t offset, size_t size );
    26                 virtual void bind();
    27                 virtual void unbind();
    28                 virtual bool is_valid() const;
    2927        private:
    3028                gl_buffer_name m_name;
    … …  
    3432        {
    3533        public:
     34                friend class gl_context;
     35
    3636                gl_index_buffer( buffer_hint hint, size_t size, const void* data = nullptr );
    37                 virtual void update( const void* data, size_t offset, size_t size );
    38                 virtual void bind();
    39                 virtual void unbind();
    40                 virtual bool is_valid() const;
    4137        private:
    4238                gl_buffer_name m_name;
    43         };
    44 
    45         class gl_vertex_array : public vertex_array
    46         {
    47         public:
    48                 gl_vertex_array();
    49                 virtual void bind();
    50                 virtual void unbind();
    5139        };
    5240

  • trunk/nv/gui/gui_renderer.hh

    r267 r299  
    5959                        typedef std::vector< vec4 >                       image_vector;
    6060
     61                        context*      m_context;
    6162                        window*       m_window;
    6263                        style         m_style;

  • trunk/nv/interface/context.hh

    r296 r299  
    4949
    5050        class device;
     51        class texture2d;
    5152        class context
    5253        {
    … …  
    5859                        m_device = a_device;
    5960                }
     61                virtual void bind( texture2d*, texture_slot ) = 0;
     62                virtual void bind( vertex_buffer* ) = 0;
     63                virtual void bind( index_buffer* ) = 0;
     64                virtual void bind( program* ) = 0;
     65                virtual void bind( vertex_array* ) = 0;
     66                virtual void unbind( vertex_buffer* ) = 0;
     67                virtual void unbind( index_buffer* ) = 0;
     68                virtual void unbind( program* ) = 0;
     69                virtual void unbind( vertex_array* ) = 0;
     70                virtual void update( texture2d*, void* ) = 0;
     71                virtual void update( index_buffer*, const void*, size_t /*offset*/, size_t /*size*/ ) = 0;
     72                virtual void update( vertex_buffer*, const void*, size_t /*offset*/, size_t /*size*/ ) = 0;
     73
    6074                virtual void clear( const clear_state& cs ) = 0;
    6175                // temporary

  • trunk/nv/interface/program.hh

    r287 r299  
    6464        {
    6565        public:
    66                 virtual void bind() = 0;
    67                 virtual void unbind() = 0;
    6866                virtual bool is_valid() const = 0;
    6967               

  • trunk/nv/interface/texture2d.hh

    r292 r299  
    5353        class texture2d
    5454        {
    55         public:
     55        protected:
    5656                texture2d( ivec2 size, pixel_format aformat, datatype adatatype, sampler asampler ) :
    5757                        m_size( size ), m_format( aformat, adatatype ), m_sampler( asampler ) {}
    58                 virtual void assign( void* data ) = 0;
    59                 virtual void bind( size_t slot = 0 ) = 0;
    60                 virtual void unbind() = 0;
    61                 virtual bool is_valid() const = 0;
     58        public:
    6259                const ivec2& get_size() const { return m_size; }
    6360                int get_width() const { return m_size.x; }

  • trunk/nv/interface/vertex_buffer.hh

    r281 r299  
    3434        public:
    3535                buffer( buffer_hint hint, size_t size ) { m_size = size; m_hint = hint; }
    36                 virtual void update( const void* data, size_t offset, size_t size ) = 0;
    37                 virtual void bind() = 0;
    38                 virtual void unbind() = 0;
    39                 virtual bool is_valid() const = 0;
    4036                size_t get_size() const { return m_size; }
    4137                buffer_hint get_hint() const { return m_hint; }
    … …  
    9490        {
    9591        public:
     92                friend class context;
     93                friend class gl_context; // TODO: HACK, remove
     94
    9695                vertex_array() : m_map(), m_index( nullptr ), m_index_owner( false ), m_index_type(USHORT) {}
    9796                void add_vertex_buffer( int location, vertex_buffer* buffer, datatype datatype, size_t components, size_t offset = 0, size_t stride = 0, bool owner = true )
    … …  
    162161                bool has_index_buffer() const { return m_index != nullptr; }
    163162                datatype get_index_buffer_type() const { return m_index_type; }
    164                 virtual void bind() = 0;
    165                 virtual void unbind() = 0;
    166163                virtual ~vertex_array() {
    167164                        for ( vertex_buffer_attribute_map::iterator i = m_map.begin();  i != m_map.end(); ++i )

  • trunk/src/gfx/keyframed_mesh.cc

    r296 r299  
    1515using namespace nv;
    1616
    17 nv::keyframed_mesh::keyframed_mesh( device* a_device, const mesh_data* a_data, const mesh_nodes_data* a_tag_map )
     17nv::keyframed_mesh::keyframed_mesh( const mesh_data* a_data, const mesh_nodes_data* a_tag_map )
    1818        : animated_mesh()
    1919        , m_mesh_data( a_data )
    … …  
    2424        , m_active( false )
    2525{
    26         m_va = a_device->create_vertex_array();
    27 
    2826        m_index_count  = m_mesh_data->get_index_channel()->count;
    2927        m_vertex_count = m_mesh_data->get_channel<vertex_t>()->count;
    … …  
    123121}
    124122
    125 nv::keyframed_mesh_gpu::keyframed_mesh_gpu( device* a_device, const mesh_data* a_data, const mesh_nodes_data* a_tag_map )
    126         : keyframed_mesh( a_device, a_data, a_tag_map )
     123nv::keyframed_mesh_gpu::keyframed_mesh_gpu( context* a_context, const mesh_data* a_data, const mesh_nodes_data* a_tag_map )
     124        : keyframed_mesh( a_data, a_tag_map )
    127125        , m_loc_next_position( -1 )
    128126        , m_loc_next_normal( -1 )
    … …  
    131129        , m_gpu_next_frame( 0xFFFFFFFF )
    132130{
    133         m_va = a_device->create_vertex_array( a_data, STATIC_DRAW );
     131        m_va = a_context->get_device()->create_vertex_array( a_data, STATIC_DRAW );
    134132}
    135133
    … …  
    177175}
    178176
    179 nv::keyframed_mesh_cpu::keyframed_mesh_cpu( device* a_device, const mesh_data* a_data, const mesh_nodes_data* a_tag_map )
    180         : keyframed_mesh( a_device, a_data, a_tag_map )
    181 {
    182         m_vb = a_device->create_vertex_buffer( nv::STATIC_DRAW, m_vertex_count * m_vsize, (void*)m_vchannel->data );
     177nv::keyframed_mesh_cpu::keyframed_mesh_cpu( context* a_context, const mesh_data* a_data, const mesh_nodes_data* a_tag_map )
     178        : keyframed_mesh( a_data, a_tag_map )
     179        , m_context( a_context )
     180{
     181        m_va = m_context->get_device()->create_vertex_array();
     182        m_vb = m_context->get_device()->create_vertex_buffer( nv::STATIC_DRAW, m_vertex_count * m_vsize, (void*)m_vchannel->data );
    183183        m_va->add_vertex_buffers( m_vb, m_vchannel );
    184184
    185         nv::vertex_buffer* vb = a_device->create_vertex_buffer( nv::STATIC_DRAW, m_vertex_count * sizeof( nv::vec2 ), (void*)m_mesh_data->get_channel<vertex_t>()->data );
     185        nv::vertex_buffer* vb = m_context->get_device()->create_vertex_buffer( nv::STATIC_DRAW, m_vertex_count * sizeof( nv::vec2 ), (void*)m_mesh_data->get_channel<vertex_t>()->data );
    186186        m_va->add_vertex_buffers( vb, m_mesh_data->get_channel<vertex_t>() );
    187187
    188         nv::index_buffer* ib = a_device->create_index_buffer( nv::STATIC_DRAW, m_mesh_data->get_index_channel()->size(), (void*)m_mesh_data->get_index_channel()->data );
     188        nv::index_buffer* ib = m_context->get_device()->create_index_buffer( nv::STATIC_DRAW, m_mesh_data->get_index_channel()->size(), (void*)m_mesh_data->get_index_channel()->data );
    189189        m_va->set_index_buffer( ib, m_mesh_data->get_index_channel()->desc.slots[0].etype, true );
    190190
    … …  
    224224        }
    225225
    226         m_vb->bind();
    227         m_vb->update( m_data, 0, m_vertex_count * m_vsize );
    228         m_vb->unbind();
     226        m_context->update( m_vb, m_data, 0, m_vertex_count * m_vsize );
    229227}
    230228

  • trunk/src/gfx/skeletal_mesh.cc

    r296 r299  
    1111
    1212
    13 nv::skeletal_mesh_cpu::skeletal_mesh_cpu( device* a_device, const mesh_data* a_mesh_data, const mesh_nodes_data* bones )
     13nv::skeletal_mesh_cpu::skeletal_mesh_cpu( context* a_context, const mesh_data* a_mesh_data, const mesh_nodes_data* bones )
    1414        : skeletal_mesh()
     15        , m_context( a_context )
    1516        , m_data( a_mesh_data )
    1617{
    … …  
    2627        m_vtx_data  = a_mesh_data->get_channel_data<md5_vtx_pntiw>();
    2728        m_indices   = a_mesh_data->get_count();
    28         m_va        = a_device->create_vertex_array( a_mesh_data, nv::STREAM_DRAW );
     29        m_va        = a_context->get_device()->create_vertex_array( a_mesh_data, nv::STREAM_DRAW );
    2930}
    3031
    … …  
    6364
    6465                vertex_buffer* vb = m_va->find_buffer( nv::slot::POSITION );
    65                 vb->bind();
    66                 vb->update( m_pntdata.data(), 0, m_pntdata.raw_size() );
    67                 vb->unbind();
     66                m_context->update( vb, m_pntdata.data(), 0, m_pntdata.raw_size() );
    6867        }
    6968}
    … …  
    200199}
    201200
    202 nv::skeletal_mesh_gpu::skeletal_mesh_gpu( device* a_device, const mesh_data* a_mesh, const mesh_nodes_data* a_bone_data )
     201nv::skeletal_mesh_gpu::skeletal_mesh_gpu( context* a_context, const mesh_data* a_mesh, const mesh_nodes_data* a_bone_data )
    203202        : skeletal_mesh(), m_bone_data( a_bone_data ), m_transform( nullptr )
    204203{
    205         m_va          = a_device->create_vertex_array( a_mesh, nv::STATIC_DRAW );
     204        m_va          = a_context->get_device()->create_vertex_array( a_mesh, nv::STATIC_DRAW );
    206205        m_index_count = a_mesh->get_count();
    207206        if ( m_bone_data )

  • trunk/src/gl/gl_context.cc

    r245 r299  
    88#include "nv/lib/gl.hh"
    99#include "nv/lib/sdl.hh"
     10#include "nv/gl/gl_texture2d.hh"
     11#include "nv/gl/gl_program.hh"
     12#include "nv/gl/gl_vertex_buffer.hh"
    1013
    1114using namespace nv;
     15
     16void gl_context::bind( texture2d* texture, texture_slot slot )
     17{
     18        GLuint id = static_cast< gl_texture2d* >( texture )->m_name.get_value();
     19        glActiveTexture( GL_TEXTURE0 + static_cast< GLenum >( slot ) );
     20        glBindTexture( GL_TEXTURE_2D, id );
     21}
     22
     23void nv::gl_context::bind( program* p )
     24{
     25        gl_program* glp = static_cast< gl_program* >( p );
     26        glUseProgram( glp->m_name.get_value() );
     27        glp->update_uniforms();
     28}
     29
     30void nv::gl_context::bind( vertex_buffer* b )
     31{
     32        GLuint id = static_cast< gl_vertex_buffer* >( b )->m_name.get_value();
     33        glBindBuffer( GL_ARRAY_BUFFER, id );
     34}
     35
     36void nv::gl_context::bind( index_buffer* b )
     37{
     38        GLuint id = static_cast< gl_index_buffer* >( b )->m_name.get_value();
     39        glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, id );
     40}
     41
     42void nv::gl_context::bind( vertex_array* va )
     43{
     44        for ( vertex_buffer_attribute_map::iterator i = va->m_map.begin();      i != va->m_map.end(); ++i )
     45        {
     46                uint32 location             = static_cast<uint32>( i->first );
     47                vertex_buffer_attribute* va = i->second;
     48                vertex_buffer*           vb = va->get_buffer();
     49                glEnableVertexAttribArray( location );
     50                bind( vb );
     51                glVertexAttribPointer(
     52                        location,
     53                        static_cast<GLint>( va->get_components() ),
     54                        nv::datatype_to_gl_enum( va->get_datatype() ),
     55                        GL_FALSE,
     56                        static_cast<GLsizei>( va->get_stride() ),
     57                        (void*)va->get_offset()
     58                        );
     59                unbind( vb );
     60        }
     61
     62        if ( va->m_index )
     63        {
     64                bind( va->m_index );
     65        }
     66}
     67
     68void nv::gl_context::unbind( program* )
     69{
     70        glUseProgram( 0 );
     71}
     72
     73void nv::gl_context::unbind( vertex_buffer* )
     74{
     75        glBindBuffer( GL_ARRAY_BUFFER, 0 );
     76}
     77
     78void nv::gl_context::unbind( index_buffer* )
     79{
     80        glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 );
     81}
     82
     83void nv::gl_context::unbind( vertex_array* va )
     84{
     85        if ( va->m_index )
     86        {
     87                unbind( va->m_index );
     88        }
     89
     90        for ( vertex_buffer_attribute_map::iterator i = va->m_map.begin();      i != va->m_map.end(); ++i )
     91        {
     92                glDisableVertexAttribArray( static_cast<uint32>( i->first ) );
     93        }
     94}
     95
     96void gl_context::update( texture2d* texture, void* data )
     97{
     98        GLuint id = static_cast< gl_texture2d* >( texture )->m_name.get_value();
     99        image_format format = texture->get_format();
     100        ivec2        size   = texture->get_size();
     101
     102        glBindTexture( GL_TEXTURE_2D, id );
     103        glTexImage2D( GL_TEXTURE_2D, 0, (GLint)nv::image_format_to_enum(format.format), size.x, size.y, 0, nv::image_format_to_enum(format.format), nv::datatype_to_gl_enum(format.type), data );
     104}
     105
     106void gl_context::update( vertex_buffer* b, const void* data, size_t offset, size_t size )
     107{
     108        bind( b );
     109        glBufferSubData( GL_ARRAY_BUFFER, (GLintptr)offset, (GLsizeiptr)size, data );
     110}
     111
     112void gl_context::update( index_buffer* b, const void* data, size_t offset, size_t size )
     113{
     114        bind( b );
     115        glBufferSubData( GL_ELEMENT_ARRAY_BUFFER, (GLintptr)offset, (GLsizeiptr)size, data );
     116}
    12117
    13118void gl_context::clear( const clear_state& cs )
    … …  
    372477}
    373478
    374 
    375479void gl_context::draw( primitive prim, const render_state& rs, program* p, vertex_array* va, size_t count )
    376480{
    … …  
    378482        if ( count > 0 )
    379483        {
    380                 p->bind();
    381                 va->bind();
     484                bind( p );
     485                bind( va );
    382486                if ( va->has_index_buffer() )
    383487                {
    … …  
    388492                        glDrawArrays( primitive_to_enum(prim), 0, static_cast<GLsizei>( count ) );
    389493                }
    390                 va->unbind();
    391                 p->unbind();
     494                unbind( va );
     495                //unbind( p );
    392496        }
    393497}

  • trunk/src/gl/gl_device.cc

    r292 r299  
    6767vertex_array* gl_device::create_vertex_array()
    6868{
    69         return new gl_vertex_array();
     69        return new vertex_array();
    7070}
    7171

  • trunk/src/gl/gl_program.cc

    r237 r299  
    125125        load_uniforms();
    126126        return true;
    127 }
    128 
    129 void gl_program::bind()
    130 {
    131         glUseProgram( m_name.get_value() );
    132         update_uniforms();
    133 }
    134 
    135 void gl_program::unbind()
    136 {
    137         glUseProgram( 0 );
    138127}
    139128

  • trunk/src/gl/gl_texture2d.cc

    r292 r299  
    3131        if (data)
    3232        {
    33                 assign(data);
     33                glBindTexture( GL_TEXTURE_2D, m_name.get_value() );
     34                glTexImage2D( GL_TEXTURE_2D, 0, (GLint)nv::image_format_to_enum(m_format.format), m_size.x, m_size.y, 0, nv::image_format_to_enum(m_format.format), nv::datatype_to_gl_enum(m_format.type), data );
     35                glBindTexture( GL_TEXTURE_2D, 0 );
    3436        }
    3537}
    3638
    37 void nv::gl_texture2d::assign( void* data )
    38 {
    39         glBindTexture( GL_TEXTURE_2D, m_name.get_value() );
    40         glTexImage2D( GL_TEXTURE_2D, 0, (GLint)nv::image_format_to_enum(m_format.format), m_size.x, m_size.y, 0, nv::image_format_to_enum(m_format.format), nv::datatype_to_gl_enum(m_format.type), data );
    41         glBindTexture( GL_TEXTURE_2D, 0 );
    42 }
    43 
    44 void nv::gl_texture2d::bind( size_t slot )
    45 {
    46         glActiveTexture( GL_TEXTURE0 + static_cast< GLenum >( slot ) );
    47         glBindTexture( GL_TEXTURE_2D, m_name.get_value() );
    48 }
    49 
    50 void nv::gl_texture2d::unbind()
    51 {
    52         glBindTexture( GL_TEXTURE_2D, 0 );
    53 }
    54 
    55 bool nv::gl_texture2d::is_valid() const
    56 {
    57         return m_name.is_valid();
    58 }

  • trunk/src/gl/gl_vertex_buffer.cc

    r191 r299  
    1313        : vertex_buffer( hint, size ), m_name()
    1414{
    15         bind();
     15        glBindBuffer( GL_ARRAY_BUFFER, m_name.get_value() );
    1616        glBufferData( GL_ARRAY_BUFFER, (GLsizeiptr)m_size, data, buffer_hint_to_enum( m_hint ) );
    17         unbind();
    18 }
    19 
    20 void gl_vertex_buffer::update( const void* data, size_t offset, size_t size )
    21 {
    22         // IMPORTANT - THIS DOES NOT BIND, SHOULD IT?
    23         glBufferSubData( GL_ARRAY_BUFFER, (GLintptr)offset, (GLsizeiptr)size, data );
    24 }
    25 
    26 
    27 void gl_vertex_buffer::bind()
    28 {
    29         glBindBuffer( GL_ARRAY_BUFFER, m_name.get_value() );
    30 }
    31 
    32 void gl_vertex_buffer::unbind()
    33 {
    3417        glBindBuffer( GL_ARRAY_BUFFER, 0 );
    35 }
    36 
    37 bool gl_vertex_buffer::is_valid() const
    38 {
    39         return m_name.is_valid();
    4018}
    4119
    … …  
    4321        : index_buffer( hint, size ), m_name()
    4422{
    45         bind();
     23        glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, m_name.get_value() );
    4624        glBufferData( GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)m_size, data, buffer_hint_to_enum( m_hint ) );
    47         unbind();
    48 }
    49 
    50 void gl_index_buffer::update( const void* data, size_t offset, size_t size )
    51 {
    52         glBufferSubData( GL_ELEMENT_ARRAY_BUFFER, (GLintptr)offset, (GLsizeiptr)size, data );
    53 }
    54 
    55 void gl_index_buffer::bind()
    56 {
    57         glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, m_name.get_value() );
    58 }
    59 
    60 void gl_index_buffer::unbind()
    61 {
    6225        glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 );
    6326}
    6427
    65 bool gl_index_buffer::is_valid() const
    66 {
    67         return m_name.is_valid();
    68 }
    69 
    70 gl_vertex_array::gl_vertex_array()
    71 {
    72 
    73 }
    74 
    75 void gl_vertex_array::bind()
    76 {
    77         for ( vertex_buffer_attribute_map::iterator i = m_map.begin();  i != m_map.end(); ++i )
    78         {
    79                 uint32 location             = static_cast<uint32>( i->first );
    80                 vertex_buffer_attribute* va = i->second;
    81                 vertex_buffer*           vb = va->get_buffer();
    82                 glEnableVertexAttribArray( location );
    83                 vb->bind();
    84                 glVertexAttribPointer(
    85                         location,
    86                         static_cast<GLint>( va->get_components() ),
    87                         nv::datatype_to_gl_enum( va->get_datatype() ),
    88                         GL_FALSE,
    89                         static_cast<GLsizei>( va->get_stride() ),
    90                         (void*)va->get_offset()
    91                         );
    92                 vb->unbind();
    93         }
    94 
    95         if ( m_index )
    96         {
    97                 m_index->bind();
    98         }
    99 }
    100 
    101 void gl_vertex_array::unbind()
    102 {
    103         if ( m_index )
    104         {
    105                 m_index->unbind();
    106         }
    107 
    108         for ( vertex_buffer_attribute_map::iterator i = m_map.begin();  i != m_map.end(); ++i )
    109         {
    110                 glDisableVertexAttribArray( static_cast<uint32>( i->first ) );
    111         }
    112 }

  • trunk/src/gui/gui_renderer.cc

    r281 r299  
    6565{
    6666public:
    67         screen_render_data( device* dev, size_t initial_size )
    68                 : buffer( dev, nv::DYNAMIC_DRAW, initial_size ), varray( nullptr ), shader(nullptr), texture(nullptr)
     67        screen_render_data( context* ctx, size_t initial_size )
     68                : buffer( ctx, nv::DYNAMIC_DRAW, initial_size ), varray( nullptr ), shader(nullptr), texture(nullptr)
    6969        {
    7070
    … …  
    9898        , m_reupload( true )
    9999{
     100        m_context = w->get_context();
    100101        m_area.dim( dimension( w->get_width(), w->get_height() ) );
    101102        region white = m_atlas.get_region( ivec2(3,3) );
    … …  
    107108        delete[] wfill;
    108109
    109         screen_render_data* sr = new screen_render_data( w->get_device(), 1024 );
     110        screen_render_data* sr = new screen_render_data( w->get_context(), 1024 );
    110111        m_render_data = sr;
    111112        // ** EXTREMELY TEMPORARY!
    … …  
    261262        if ( m_reupload )
    262263        {
    263                 sr->texture->assign( (void*)m_atlas.get_data() );
     264                m_context->update( sr->texture, (void*)m_atlas.get_data() );
    264265                m_reupload = false;
    265266        }
    … …  
    272273                sr->varray->update_vertex_buffer( nv::slot::COLOR,    vb, false );
    273274        }
    274         sr->texture->bind( nv::TEX_DIFFUSE );
    275         m_window->get_context()->draw( TRIANGLES, m_render_state, m_scene_state, sr->shader, sr->varray, sr->buffer.get_size() * 6 );
     275        m_context->bind( sr->texture, TEX_DIFFUSE );
     276        m_context->draw( TRIANGLES, m_render_state, m_scene_state, sr->shader, sr->varray, sr->buffer.get_size() * 6 );
    276277}
    277278
Note: See TracChangeset for help on using the changeset viewer.