Changeset 299 for trunk/src


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/src
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • 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.