buffer update moved to render class

headers/enduro2d/core/render.hpp

@@ -264,7 +264,6 @@ namespace e2d
         explicit index_buffer(internal_state_uptr);
         ~index_buffer() noexcept;
     public:
-        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;
@@ -291,7 +290,6 @@ namespace e2d
         explicit vertex_buffer(internal_state_uptr);
         ~vertex_buffer() noexcept;
     public:
-        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;
@@ -940,6 +938,11 @@ namespace e2d
         render& execute(const target_command& command);
         render& execute(const viewport_command& command);
 
+        render& update_buffer(const index_buffer_ptr& ibuffer, buffer_view indices, std::size_t offset);
+        render& update_buffer(const vertex_buffer_ptr& vbuffer, buffer_view vertices, std::size_t offset);
+        render& update_texture(const texture_ptr& tex, const image& img, v2u offset, u32 level = 0);
+        render& update_texture(const texture_ptr& tex, const void* data, v2u size, v2u offset, u32 level = 0);
+
         const device_caps& device_capabilities() const noexcept;
         bool is_pixel_supported(const pixel_declaration& decl) const noexcept;
         bool is_index_supported(const index_declaration& decl) const noexcept;

sources/enduro2d/core/dbgui.cpp

@@ -303,7 +303,7 @@ namespace e2d
 
         void update_index_buffer(buffer_view indices) {
             if ( index_buffer_ && index_buffer_->buffer_size() >= indices.size() ) {
-                index_buffer_->update(indices, 0);
+                render_.update_buffer(index_buffer_, indices, 0u);
                 return;
             }
 
@@ -329,7 +329,7 @@ namespace e2d
 
         void update_vertex_buffer(buffer_view vertices) {
             if ( vertex_buffer_ && vertex_buffer_->buffer_size() >= vertices.size() ) {
-                vertex_buffer_->update(vertices, 0);
+                render_.update_buffer(vertex_buffer_, vertices, 0u);
                 return;
             }
 

sources/enduro2d/core/render_impl/render_none.cpp

@@ -121,10 +121,6 @@ namespace e2d
     : state_(std::move(state)) {}
     index_buffer::~index_buffer() noexcept = default;
 
-    void index_buffer::update(buffer_view indices, std::size_t offset) noexcept {
-        E2D_UNUSED(indices, offset);
-    }
-
     std::size_t index_buffer::buffer_size() const noexcept {
         return 0u;
     }
@@ -141,10 +137,6 @@ namespace e2d
     : state_(std::move(state)) {}
     vertex_buffer::~vertex_buffer() noexcept = default;
 
-    void vertex_buffer::update(buffer_view vertices, std::size_t offset) noexcept {
-        E2D_UNUSED(vertices, offset);
-    }
-
     std::size_t vertex_buffer::buffer_size() const noexcept {
         return 0u;
     }
@@ -258,6 +250,26 @@ namespace e2d
         E2D_UNUSED(command);
         return *this;
     }
+    
+    render& render::update_buffer(const index_buffer_ptr& ibuffer, buffer_view indices, std::size_t offset) {
+        E2D_UNUSED(ibuffer, indices, offset);
+        return *this;
+    }
+
+    render& render::update_buffer(const vertex_buffer_ptr& vbuffer, buffer_view vertices, std::size_t offset) {
+        E2D_UNUSED(vbuffer, vertices, offset);
+        return *this;
+    }
+
+    render& render::update_texture(const texture_ptr& tex, const image& img, v2u offset, u32 level) {
+        E2D_UNUSED(tex, img, offset, level);
+        return *this;
+    }
+
+    render& render::update_texture(const texture_ptr& tex, const void* data, v2u size, v2u offset, u32 level) {
+        E2D_UNUSED(tex, img, size, offset, level);
+        return *this;
+    }
 
     const render::device_caps& render::device_capabilities() const noexcept {
         static device_caps caps;

sources/enduro2d/core/render_impl/render_opengl.cpp

@@ -355,20 +355,6 @@ namespace e2d
     }
     index_buffer::~index_buffer() noexcept = default;
 
-    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);
-        opengl::with_gl_bind_buffer(state_->dbg(), state_->id(),
-            [this, &indices, &buffer_offset]() noexcept {
-                GL_CHECK_CODE(state_->dbg(), glBufferSubData(
-                    state_->id().target(),
-                    math::numeric_cast<GLintptr>(buffer_offset),
-                    math::numeric_cast<GLsizeiptr>(indices.size()),
-                    indices.data()));
-            });
-    }
-
     std::size_t index_buffer::buffer_size() const noexcept {
         return state_->size();
     }
@@ -396,20 +382,6 @@ namespace e2d
     }
     vertex_buffer::~vertex_buffer() noexcept = default;
 
-    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);
-        opengl::with_gl_bind_buffer(state_->dbg(), state_->id(),
-            [this, &vertices, &buffer_offset]() noexcept {
-                GL_CHECK_CODE(state_->dbg(), glBufferSubData(
-                    state_->id().target(),
-                    math::numeric_cast<GLintptr>(buffer_offset),
-                    math::numeric_cast<GLsizeiptr>(vertices.size()),
-                    vertices.data()));
-            });
-    }
-
     std::size_t vertex_buffer::buffer_size() const noexcept {
         return state_->size();
     }
@@ -1000,6 +972,72 @@ namespace e2d
 
         return *this;
     }
+    
+    render& render::update_buffer(const index_buffer_ptr& ibuffer, buffer_view indices, std::size_t offset) {
+        E2D_ASSERT(is_in_main_thread());
+        E2D_ASSERT(ibuffer);
+        const std::size_t buffer_offset = offset * ibuffer->state().decl().bytes_per_index();
+        E2D_ASSERT(indices.size() + buffer_offset <= ibuffer->state().size());
+        E2D_ASSERT(indices.size() % ibuffer->state().decl().bytes_per_index() == 0);
+        opengl::with_gl_bind_buffer(ibuffer->state().dbg(), ibuffer->state().id(),
+            [&ibuffer, &indices, &buffer_offset]() noexcept {
+                GL_CHECK_CODE(ibuffer->state().dbg(), glBufferSubData(
+                    ibuffer->state().id().target(),
+                    math::numeric_cast<GLintptr>(buffer_offset),
+                    math::numeric_cast<GLsizeiptr>(indices.size()),
+                    indices.data()));
+            });
+        return *this;
+    }
+
+    render& render::update_buffer(const vertex_buffer_ptr& vbuffer, buffer_view vertices, std::size_t offset) {
+        E2D_ASSERT(is_in_main_thread());
+        E2D_ASSERT(vbuffer);
+        const std::size_t buffer_offset = offset * vbuffer->state().decl().bytes_per_vertex();
+        E2D_ASSERT(vertices.size() + buffer_offset <= vbuffer->state().size());
+        E2D_ASSERT(vertices.size() % vbuffer->state().decl().bytes_per_vertex() == 0);
+        opengl::with_gl_bind_buffer(vbuffer->state().dbg(), vbuffer->state().id(),
+            [&vbuffer, &vertices, &buffer_offset]() noexcept {
+                GL_CHECK_CODE(vbuffer->state().dbg(), glBufferSubData(
+                    vbuffer->state().id().target(),
+                    math::numeric_cast<GLintptr>(buffer_offset),
+                    math::numeric_cast<GLsizeiptr>(vertices.size()),
+                    vertices.data()));
+            });
+        return *this;
+    }
+
+    render& render::update_texture(const texture_ptr& tex, const image& img, v2u offset, u32 level) {
+        E2D_ASSERT(is_in_main_thread());
+        E2D_ASSERT(tex);
+        const pixel_declaration decl =
+            convert_image_data_format_to_pixel_declaration(img.format());
+        E2D_ASSERT(tex->decl() == decl);
+        return update_texture(tex, img.data().data(), img.size(), offset, level);
+    }
+
+    render& render::update_texture(const texture_ptr& tex, const void* data, v2u size, v2u offset, u32 level) {
+        E2D_ASSERT(is_in_main_thread());
+        E2D_ASSERT(tex);
+        E2D_ASSERT(offset.x < tex->size().x && offset.y < tex->size().y);
+        E2D_ASSERT(offset.x + size.x <= tex->size().x);
+        E2D_ASSERT(offset.y + size.y <= tex->size().y);
+        E2D_ASSERT(level == 0); // not supported yet
+        opengl::with_gl_bind_texture(state_->dbg(), tex->state().id(),
+            [&tex, data, &size, &offset, level]() noexcept {
+                GL_CHECK_CODE(tex->state().dbg(), glTexSubImage2D(
+                    tex->state().id().target(),
+                    math::numeric_cast<GLint>(level),
+                    math::numeric_cast<GLint>(offset.x),
+                    math::numeric_cast<GLint>(offset.y),
+                    math::numeric_cast<GLsizei>(size.x),
+                    math::numeric_cast<GLsizei>(size.y),
+                    convert_pixel_type_to_external_format(tex->state().decl().type()),
+                    convert_pixel_type_to_external_data_type(tex->state().decl().type()),
+                    data));
+            });
+        return *this;
+    }
 
     const render::device_caps& render::device_capabilities() const noexcept {
         E2D_ASSERT(is_in_main_thread());

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

@@ -203,7 +203,7 @@ namespace e2d::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(indices_, 0u);
+            render_.update_buffer(index_buffer_, indices_, 0u);
         } else {
             const std::size_t new_ib_size = calculate_new_buffer_size(
                 sizeof(Index),
@@ -230,7 +230,7 @@ namespace e2d::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(vertices_, 0u);
+            render_.update_buffer(vertex_buffer_, vertices_, 0u);
         } else {
             const std::size_t new_vb_size = calculate_new_buffer_size(
                 sizeof(Vertex),