using buffer_view for creating and updating render buffers

headers/enduro2d/core/render.hpp

@@ -266,7 +266,7 @@ namespace e2d
         explicit index_buffer(internal_state_uptr);
         ~index_buffer() noexcept;
     public:
-        void update(const buffer& indices, std::size_t offset) noexcept;
+        void update(buffer_view indices, std::size_t offset) noexcept;
         std::size_t buffer_size() const noexcept;
         std::size_t index_count() const noexcept;
         const index_declaration& decl() const noexcept;
@@ -293,7 +293,7 @@ namespace e2d
         explicit vertex_buffer(internal_state_uptr);
         ~vertex_buffer() noexcept;
     public:
-        void update(const buffer& vertices, std::size_t offset) noexcept;
+        void update(buffer_view vertices, std::size_t offset) noexcept;
         std::size_t buffer_size() const noexcept;
         std::size_t vertex_count() const noexcept;
         const vertex_declaration& decl() const noexcept;
@@ -890,12 +890,12 @@ namespace e2d
             const pixel_declaration& decl);
 
         index_buffer_ptr create_index_buffer(
-            const buffer& indices,
+            buffer_view indices,
             const index_declaration& decl,
             index_buffer::usage usage);
 
         vertex_buffer_ptr create_vertex_buffer(
-            const buffer& vertices,
+            buffer_view vertices,
             const vertex_declaration& decl,
             vertex_buffer::usage usage);
 

samples/sources/sample_00/sample_00.cpp

@@ -114,19 +114,19 @@ namespace
 
             const auto indices = generate_quad_indices();
             index_buffer_ = the<render>().create_index_buffer(
-                buffer(indices.data(), indices.size() * sizeof(indices[0])),
+                indices,
                 index_declaration::index_type::unsigned_byte,
                 index_buffer::usage::static_draw);
 
             const auto vertices1 = generate_quad_vertices(texture1_->size());
             vertex_buffer1_ = the<render>().create_vertex_buffer(
-                buffer(vertices1.data(), vertices1.size() * sizeof(vertices1[0])),
+                vertices1,
                 vertex1::decl(),
                 vertex_buffer::usage::static_draw);
 
             const auto vertices2 = generate_quad_colors();
             vertex_buffer2_ = the<render>().create_vertex_buffer(
-                buffer(vertices2.data(), vertices2.size() * sizeof(vertices2[0])),
+                vertices2,
                 vertex2::decl(),
                 vertex_buffer::usage::static_draw);
 

samples/sources/sample_01/sample_01.cpp

@@ -173,19 +173,19 @@ namespace
 
             const auto indices = generate_cube_indices();
             index_buffer_ = the<render>().create_index_buffer(
-                buffer(indices.data(), indices.size() * sizeof(indices[0])),
+                indices,
                 index_declaration::index_type::unsigned_byte,
                 index_buffer::usage::static_draw);
 
             const auto vertices1 = generate_cube_vertices(make_vec3(1.f));
             vertex_buffer1_ = the<render>().create_vertex_buffer(
-                buffer(vertices1.data(), vertices1.size() * sizeof(vertices1[0])),
+                vertices1,
                 vertex1::decl(),
                 vertex_buffer::usage::static_draw);
 
             const auto vertices2 = generate_cube_colors();
             vertex_buffer2_ = the<render>().create_vertex_buffer(
-                buffer(vertices2.data(), vertices2.size() * sizeof(vertices2[0])),
+                vertices2,
                 vertex2::decl(),
                 vertex_buffer::usage::static_draw);
 

samples/sources/sample_02/sample_02.cpp

@@ -128,13 +128,13 @@ namespace
 
             const auto indices = generate_cube_indices();
             index_buffer_ = the<render>().create_index_buffer(
-                buffer(indices.data(), indices.size() * sizeof(indices[0])),
+                indices,
                 index_declaration::index_type::unsigned_byte,
                 index_buffer::usage::static_draw);
 
             const auto vertices = generate_cube_vertices(make_vec3(1.f));
             vertex_buffer_ = the<render>().create_vertex_buffer(
-                buffer(vertices.data(), vertices.size() * sizeof(vertices[0])),
+                vertices,
                 vertex::decl(),
                 vertex_buffer::usage::static_draw);
 

sources/enduro2d/core/dbgui.cpp

@@ -158,13 +158,13 @@ namespace e2d
             for ( int i = 0; i < draw_data->CmdListsCount; ++i ) {
                 const ImDrawList* cmd_list = draw_data->CmdLists[i];
 
-                update_index_buffer(
+                update_index_buffer({
                     cmd_list->IdxBuffer.Data,
-                    math::numeric_cast<std::size_t>(cmd_list->IdxBuffer.Size) * sizeof(ImDrawIdx));
+                    math::numeric_cast<std::size_t>(cmd_list->IdxBuffer.Size) * sizeof(ImDrawIdx)});
 
-                update_vertex_buffer(
+                update_vertex_buffer({
                     cmd_list->VtxBuffer.Data,
-                    math::numeric_cast<std::size_t>(cmd_list->VtxBuffer.Size) * sizeof(ImDrawVert));
+                    math::numeric_cast<std::size_t>(cmd_list->VtxBuffer.Size) * sizeof(ImDrawVert)});
 
                 const auto geometry = render::geometry()
                     .indices(index_buffer_)
@@ -301,19 +301,19 @@ namespace e2d
             return math::max(osize * 2u, nsize);
         }
 
-        void update_index_buffer(const void* indices, std::size_t size) {
+        void update_index_buffer(buffer_view indices) {
-            if ( index_buffer_ && index_buffer_->buffer_size() >= size ) {
+            if ( index_buffer_ && index_buffer_->buffer_size() >= indices.size() ) {
-                index_buffer_->update(buffer(indices, size), 0);
+                index_buffer_->update(indices, 0);
                 return;
             }
 
             const std::size_t new_buffer_size = calculate_new_buffer_size(
                 sizeof(ImDrawIdx),
                 index_buffer_ ? index_buffer_->buffer_size() : 0u,
-                size);
+                indices.size());
 
             buffer new_buffer_data(new_buffer_size);
-            std::memcpy(new_buffer_data.data(), indices, size);
+            std::memcpy(new_buffer_data.data(), indices.data(), indices.size());
 
             index_buffer_ = render_.create_index_buffer(
                 new_buffer_data,
@@ -327,19 +327,19 @@ namespace e2d
             }
         }
 
-        void update_vertex_buffer(const void* vertices, std::size_t size) {
+        void update_vertex_buffer(buffer_view vertices) {
-            if ( vertex_buffer_ && vertex_buffer_->buffer_size() >= size ) {
+            if ( vertex_buffer_ && vertex_buffer_->buffer_size() >= vertices.size() ) {
-                vertex_buffer_->update(buffer(vertices, size), 0);
+                vertex_buffer_->update(vertices, 0);
                 return;
             }
 
             const std::size_t new_buffer_size = calculate_new_buffer_size(
                 sizeof(ImDrawVert),
                 vertex_buffer_ ? vertex_buffer_->buffer_size() : 0u,
-                size);
+                vertices.size());
 
             buffer new_buffer_data(new_buffer_size);
-            std::memcpy(new_buffer_data.data(), vertices, size);
+            std::memcpy(new_buffer_data.data(), vertices.data(), vertices.size());
 
             vertex_buffer_ = render_.create_vertex_buffer(
                 new_buffer_data,

sources/enduro2d/core/render_impl/render_none.cpp

@@ -121,7 +121,7 @@ namespace e2d
     : state_(std::move(state)) {}
     index_buffer::~index_buffer() noexcept = default;
 
-    void index_buffer::update(const buffer& indices, std::size_t offset) noexcept {
+    void index_buffer::update(buffer_view indices, std::size_t offset) noexcept {
         E2D_UNUSED(indices, offset);
     }
 
@@ -141,7 +141,7 @@ namespace e2d
     : state_(std::move(state)) {}
     vertex_buffer::~vertex_buffer() noexcept = default;
 
-    void vertex_buffer::update(const buffer& vertices, std::size_t offset) noexcept {
+    void vertex_buffer::update(buffer_view vertices, std::size_t offset) noexcept {
         E2D_UNUSED(vertices, offset);
     }
 
@@ -212,7 +212,7 @@ namespace e2d
     }
 
     index_buffer_ptr render::create_index_buffer(
-        const buffer& indices,
+        buffer_view indices,
         const index_declaration& decl,
         index_buffer::usage usage)
     {
@@ -221,7 +221,7 @@ namespace e2d
     }
 
     vertex_buffer_ptr render::create_vertex_buffer(
-        const buffer& vertices,
+        buffer_view vertices,
         const vertex_declaration& decl,
         vertex_buffer::usage usage)
     {

sources/enduro2d/core/render_impl/render_opengl.cpp

@@ -355,7 +355,7 @@ namespace e2d
     }
     index_buffer::~index_buffer() noexcept = default;
 
-    void index_buffer::update(const buffer& indices, std::size_t offset) noexcept {
+    void index_buffer::update(buffer_view indices, std::size_t offset) noexcept {
         const std::size_t buffer_offset = offset * state_->decl().bytes_per_index();
         E2D_ASSERT(indices.size() + buffer_offset <= state_->size());
         E2D_ASSERT(indices.size() % state_->decl().bytes_per_index() == 0);
@@ -396,7 +396,7 @@ namespace e2d
     }
     vertex_buffer::~vertex_buffer() noexcept = default;
 
-    void vertex_buffer::update(const buffer& vertices, std::size_t offset) noexcept {
+    void vertex_buffer::update(buffer_view vertices, std::size_t offset) noexcept {
         const std::size_t buffer_offset = offset * state_->decl().bytes_per_vertex();
         E2D_ASSERT(vertices.size() + buffer_offset <= state_->size());
         E2D_ASSERT(vertices.size() % state_->decl().bytes_per_vertex() == 0);
@@ -689,7 +689,7 @@ namespace e2d
     }
 
     index_buffer_ptr render::create_index_buffer(
-        const buffer& indices,
+        buffer_view indices,
         const index_declaration& decl,
         index_buffer::usage usage)
     {
@@ -725,7 +725,7 @@ namespace e2d
     }
 
     vertex_buffer_ptr render::create_vertex_buffer(
-        const buffer& vertices,
+        buffer_view vertices,
         const vertex_declaration& decl,
         vertex_buffer::usage usage)
     {

sources/enduro2d/high/model.cpp

@@ -52,7 +52,7 @@ namespace
                 }
 
                 const index_buffer_ptr index_buffer = render.create_index_buffer(
-                    buffer(indices.data(), indices.size() * sizeof(indices[0])),
+                    indices,
                     index_declaration::index_type::unsigned_int,
                     index_buffer::usage::static_draw);
 
@@ -65,7 +65,7 @@ namespace
         {
             const vector<v3f>& vertices = mesh.vertices();
             const vertex_buffer_ptr vertex_buffer = render.create_vertex_buffer(
-                buffer(vertices.data(), vertices.size() * sizeof(vertices[0])),
+                vertices,
                 vertex_buffer_decl,
                 vertex_buffer::usage::static_draw);
             if ( vertex_buffer ) {
@@ -80,7 +80,7 @@ namespace
             for ( std::size_t i = 0; i < uv_count; ++i ) {
                 const vector<v2f>& uvs = mesh.uvs(i);
                 const vertex_buffer_ptr uv_buffer = render.create_vertex_buffer(
-                    buffer(uvs.data(), uvs.size() * sizeof(uvs[0])),
+                    uvs,
                     uv_buffer_decls[i],
                     vertex_buffer::usage::static_draw);
                 if ( uv_buffer ) {
@@ -96,7 +96,7 @@ namespace
             for ( std::size_t i = 0; i < color_count; ++i ) {
                 const vector<color32>& colors = mesh.colors(i);
                 const vertex_buffer_ptr color_buffer = render.create_vertex_buffer(
-                    buffer(colors.data(), colors.size() * sizeof(colors[0])),
+                    colors,
                     color_buffer_decls[i],
                     vertex_buffer::usage::static_draw);
                 if ( color_buffer ) {
@@ -108,7 +108,7 @@ namespace
         {
             const vector<v3f>& normals = mesh.normals();
             const vertex_buffer_ptr normal_buffer = render.create_vertex_buffer(
-                buffer(normals.data(), normals.size() * sizeof(normals[0])),
+                normals,
                 normal_buffer_decl,
                 vertex_buffer::usage::static_draw);
             if ( normal_buffer ) {
@@ -119,7 +119,7 @@ namespace
         {
             const vector<v3f>& tangents = mesh.tangents();
             const vertex_buffer_ptr tangent_buffer = render.create_vertex_buffer(
-                buffer(tangents.data(), tangents.size() * sizeof(tangents[0])),
+                tangents,
                 tangent_buffer_decl,
                 vertex_buffer::usage::static_draw);
             if ( tangent_buffer ) {
@@ -130,7 +130,7 @@ namespace
         {
             const vector<v3f>& bitangents = mesh.bitangents();
             const vertex_buffer_ptr bitangent_buffer = render.create_vertex_buffer(
-                buffer(bitangents.data(), bitangents.size() * sizeof(bitangents[0])),
+                bitangents,
                 bitangent_buffer_decl,
                 vertex_buffer::usage::static_draw);
             if ( bitangent_buffer ) {

sources/enduro2d/high/systems/render_system_impl/render_system_batcher.hpp

@@ -200,7 +200,7 @@ namespace e2d { namespace render_system_impl
     void batcher<Index, Vertex>::update_index_buffer_() {
         const std::size_t min_ib_size = indices_.size() * sizeof(indices_[0]);
         if ( index_buffer_ && index_buffer_->buffer_size() >= min_ib_size ) {
-            index_buffer_->update(buffer(indices_.data(), min_ib_size), 0u);
+            index_buffer_->update(indices_, 0u);
         } else {
             const std::size_t new_ib_size = calculate_new_buffer_size(
                 sizeof(Index),
@@ -227,7 +227,7 @@ namespace e2d { namespace render_system_impl
     void batcher<Index, Vertex>::update_vertex_buffer_() {
         const std::size_t min_vb_size = vertices_.size() * sizeof(vertices_[0]);
         if ( vertex_buffer_ && vertex_buffer_->buffer_size() >= min_vb_size ) {
-            vertex_buffer_->update(buffer(vertices_.data(), min_vb_size), 0u);
+            vertex_buffer_->update(vertices_, 0u);
         } else {
             const std::size_t new_vb_size = calculate_new_buffer_size(
                 sizeof(Vertex),