Ignore:
Timestamp:
08/18/14 23:25:46 (11 years ago)
Author:
epyon
Message:
  • cleanup of context and device interfaces
  • create_vertex_array moved to context (as it's context bound)
  • added partial framebuffer functions to context
File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/nv/interface/device.hh

    r303 r313  
    5252
    5353        struct texture_tag {};
    54         struct vertex_array_tag {};
    5554        struct buffer_tag {};
    5655        struct program_tag {};
    5756        typedef handle< uint32, 16, 16, buffer_tag >       buffer;
    5857        typedef handle< uint32, 16, 16, texture_tag >      texture;
    59         typedef handle< uint32, 16, 16, vertex_array_tag > vertex_array;
    6058        typedef handle< uint32, 16, 16, program_tag >      program;
    6159
     
    118116        };
    119117
    120         struct vertex_array_info
    121         {
    122                 static const int MAX_ATTRIBUTES = 24;
    123 
    124                 uint32        count;
    125                 buffer        index;
    126                 bool          index_owner;
    127                 datatype      index_type;
    128                 vertex_buffer_attribute attr[MAX_ATTRIBUTES];
    129         };
    130 
    131118        struct program_info
    132119        {
     
    150137                virtual image_data* create_image_data( const std::string& filename ) = 0; // temporary
    151138                virtual texture create_texture( ivec2 size, image_format aformat, sampler asampler, void* data = nullptr ) = 0;
    152                 virtual vertex_array create_vertex_array() = 0;
    153139                virtual void release( texture ) = 0;
    154140                virtual void release( buffer ) = 0;
    155                 virtual void release( vertex_array ) = 0;
    156141                virtual void release( program ) = 0;
    157142                virtual const texture_info* get_texture_info( texture ) const = 0;
    158143                virtual const buffer_info* get_buffer_info( buffer ) const = 0;
    159                 virtual const vertex_array_info* get_vertex_array_info( vertex_array ) const = 0;
    160144                virtual uint32 get_ticks() = 0;
    161145                virtual void delay( uint32 ms ) = 0;
     
    164148                {
    165149                        return create_texture( data->get_size(), data->get_format(), asampler, (void*)data->get_data() );
    166                 }
    167 
    168                 template < typename VTX, slot SLOT >
    169                 void add_vertex_buffer_impl( vertex_array, buffer, const std::false_type& )
    170                 {
    171                 }
    172 
    173                 template < typename VTX, slot SLOT >
    174                 void add_vertex_buffer_impl( vertex_array va, buffer vb, const std::true_type& )
    175                 {
    176                         typedef vertex_slot_info< VTX, SLOT > vinfo;
    177                         typedef datatype_traits< typename vinfo::value_type > dt_traits;
    178                         add_vertex_buffer( va, SLOT, vb, type_to_enum< dt_traits::base_type >::type, dt_traits::size, vinfo::offset, sizeof( VTX ), false );
    179                 }
    180 
    181                 template < typename VTX, slot SLOT >
    182                 void add_vertex_buffer( vertex_array va, buffer vb )
    183                 {
    184                         add_vertex_buffer_impl< VTX, SLOT >( va, vb, std::integral_constant< bool, vertex_has_slot< VTX, SLOT >::value >() );
    185                 }
    186 
    187                 template < typename VTX >
    188                 void add_vertex_buffers( vertex_array va, buffer vb )
    189                 {
    190                         add_vertex_buffer< VTX, slot::POSITION >  ( va, vb );
    191                         add_vertex_buffer< VTX, slot::TEXCOORD >  ( va, vb );
    192                         add_vertex_buffer< VTX, slot::NORMAL   >  ( va, vb );
    193                         add_vertex_buffer< VTX, slot::TANGENT >   ( va, vb );
    194                         add_vertex_buffer< VTX, slot::BONEINDEX > ( va, vb );
    195                         add_vertex_buffer< VTX, slot::BONEWEIGHT >( va, vb );
    196                         add_vertex_buffer< VTX, slot::COLOR >     ( va, vb );
    197                 }
    198 
    199                 void add_vertex_buffers( vertex_array va, buffer buf, const mesh_raw_channel* channel )
    200                 {
    201                         for ( uint32 s = 0; s < channel->desc.count; ++s )
    202                         {
    203                                 const vertex_descriptor_slot& slot = channel->desc.slots[s];
    204                                 const datatype_info& info = get_datatype_info(slot.etype);
    205                                 add_vertex_buffer( va, slot.vslot, buf, info.base , info.elements, slot.offset, channel->desc.size, false );
    206                         }
    207                 }
    208 
    209                 template < typename VTX >
    210                 vertex_array create_vertex_array( const VTX* v, size_t count, buffer_hint hint )
    211                 {
    212                         // TODO: vb will not be owned or freed!
    213                         vertex_array va = create_vertex_array();
    214                         buffer       vb = create_buffer( VERTEX_BUFFER, hint, count * sizeof( VTX ), v );
    215                         add_vertex_buffers< VTX >( va, vb );
    216                         return va;
    217                 }
    218 
    219                 template < typename VTX >
    220                 vertex_array create_vertex_array( const std::vector< VTX >& data, buffer_hint hint )
    221                 {
    222                         return create_vertex_array( data.data(), data.size(), hint );
    223                 }
    224 
    225                 template < typename VTX, typename IDX >
    226                 vertex_array create_vertex_array( const VTX* v, size_t vcount, const IDX* i, size_t icount, buffer_hint hint )
    227                 {
    228                         vertex_array va = create_vertex_array( v, vcount, hint );
    229                         buffer       ib = create_buffer( INDEX_BUFFER, hint, icount * sizeof( IDX ), i );
    230                         va->set_index_buffer( ib, type_to_enum< IDX >::type, true );
    231                         return va;
    232                 }
    233 
    234                 template < typename VTX, typename IDX >
    235                 vertex_array create_vertex_array( const std::vector< VTX >& data, const std::vector< IDX >& idata, buffer_hint hint )
    236                 {
    237                         return create_vertex_array( data.data(), data.size(), idata.data(), idata.size(), hint );
    238                 }
    239 
    240                 void replace_vertex_buffer( vertex_array va, buffer vb, bool owner )
    241                 {
    242                         vertex_array_info* info = get_vertex_array_info_mutable( va );
    243                         if ( info )
    244                         {
    245                                 for ( uint32 i = 0; i < info->count; ++i )
    246                                 {
    247                                         vertex_buffer_attribute& vba = info->attr[i];
    248                                         if ( vba.owner ) release( vba.vbuffer );
    249                                         vba.vbuffer = vb;
    250                                         vba.owner   = owner;
    251                                 }
    252                         }
    253                 }
    254 
    255                 void replace_vertex_buffer( vertex_array va, buffer vb, slot location, bool owner )
    256                 {
    257                         vertex_array_info* info = get_vertex_array_info_mutable( va );
    258                         if ( info )
    259                         {
    260                                 for ( uint32 i = 0; i < info->count; ++i )
    261                                 {
    262                                         if ( info->attr[i].location == location )
    263                                         {
    264                                                 vertex_buffer_attribute& vba = info->attr[i];
    265                                                 if ( vba.owner ) release( vba.vbuffer );
    266                                                 vba.vbuffer = vb;
    267                                                 vba.owner   = owner;
    268                                         }
    269                                 }
    270                         }
    271                 }
    272 
    273                 void update_attribute_offset( vertex_array va, slot location, size_t offset )
    274                 {
    275                         vertex_array_info* info = get_vertex_array_info_mutable( va );
    276                         if ( info )
    277                         {
    278                                 for ( uint32 i = 0; i < info->count; ++i )
    279                                 {
    280                                         if ( info->attr[i].location == location )
    281                                         {
    282                                                 info->attr[i].offset = offset;
    283                                         }
    284                                 }
    285                         }
    286                 }
    287 
    288                 void set_index_buffer( vertex_array va, buffer b, datatype datatype, bool owner )
    289                 {
    290                         vertex_array_info* info = get_vertex_array_info_mutable( va );
    291                         if ( info )
    292                         {
    293                                 if ( get_buffer_info( b )->type == INDEX_BUFFER )
    294                                 {
    295                                         if (info->index.is_valid() && info->index_owner) release( info->index );
    296 
    297                                         info->index       = b;
    298                                         info->index_owner = owner;
    299                                         info->index_type  = datatype;
    300                                 }
    301                         }
    302                 }
    303 
    304                 virtual void add_vertex_buffer( vertex_array va, slot location, buffer buf, datatype datatype, size_t components, size_t offset = 0, size_t stride = 0, bool owner = true )
    305                 {
    306                         vertex_array_info* info = get_vertex_array_info_mutable( va );
    307                         if ( info )
    308                         {
    309                                 NV_ASSERT( info->count < vertex_array_info::MAX_ATTRIBUTES, "MAX_ATTRIBUTES reached!" );
    310                                 vertex_buffer_attribute& p = info->attr[ info->count ];
    311                                 p.vbuffer    = buf;
    312                                 p.dtype      = datatype;
    313                                 p.components = components;
    314                                 p.offset     = offset;
    315                                 p.stride     = stride;
    316                                 p.owner      = owner;
    317                                 p.location   = location;
    318                                 info->count++;
    319                         }
    320                 }
    321 
    322                 buffer find_buffer( vertex_array va, slot location )
    323                 {
    324                         const vertex_array_info* info = get_vertex_array_info( va );
    325                         if ( info )
    326                         {
    327                                 for ( uint32 i = 0; i < info->count; ++i )
    328                                 {
    329                                         if ( info->attr[i].location == location )
    330                                         {
    331                                                 return info->attr[i].vbuffer;
    332                                         }
    333                                 }
    334                         }
    335                         return buffer();
    336                 }
    337 
    338                 // TODO: HINTS ARE DIFFERENT!
    339                 vertex_array create_vertex_array( const mesh_data* data, buffer_hint hint )
    340                 {
    341                         vertex_array  va = create_vertex_array();
    342                         const std::vector< mesh_raw_channel* >& channels = data->get_raw_channels();
    343                         for ( uint32 ch = 0; ch < channels.size(); ++ch )
    344                         {
    345                                 const mesh_raw_channel* channel = channels[ch];
    346                                 if ( channel->count > 0 )
    347                                 {
    348                                         buffer_type type = channel->get_buffer_type();
    349                                         buffer b = create_buffer( type, hint, channel->size(), channel->data );
    350                                         // TODO: no if switch
    351                                         if ( type == INDEX_BUFFER )
    352                                         {
    353                                                 set_index_buffer( va, b, channel->desc.slots[0].etype, true );
    354                                         }
    355                                         else
    356                                         {
    357                                                 add_vertex_buffers( va, b, channel );
    358                                         }
    359                                 }
    360                         }
    361                         return va;
    362150                }
    363151
     
    445233        protected:
    446234                virtual uniform_base* get_uniform( program p, const string& name, bool fatal = true ) const = 0;
    447 
    448                 // TODO: remove
    449                 virtual vertex_array_info* get_vertex_array_info_mutable( vertex_array ) = 0;
    450235
    451236                void initialize_engine_uniforms()
Note: See TracChangeset for help on using the changeset viewer.