removed unnecessary binding of geometry buffer

fyrox-graphics/src/geometry_buffer.rs

@@ -18,13 +18,11 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-use crate::gl::server::GlGraphicsServer;
-use crate::gl::ToGlConstant;
 use crate::{
     buffer::{Buffer, BufferKind, BufferUsage},
     core::{array_as_u8_slice, math::TriangleDefinition},
     error::FrameworkError,
-    gl::buffer::GlBuffer,
+    gl::{buffer::GlBuffer, server::GlGraphicsServer, ToGlConstant},
     ElementKind, ElementRange,
 };
 use glow::HasContext;
@@ -146,88 +144,103 @@ impl AttributeKind {
     }
 }
 
-pub struct GeometryBufferBinding<'a> {
-    state: &'a GlGraphicsServer,
-    buffer: &'a GeometryBuffer,
-}
-
 #[derive(Debug, Copy, Clone, Default)]
 pub struct DrawCallStatistics {
     pub triangles: usize,
 }
 
-impl<'a> GeometryBufferBinding<'a> {
-    pub fn set_triangles(self, triangles: &[TriangleDefinition]) -> Self {
-        assert_eq!(self.buffer.element_kind, ElementKind::Triangle);
-        self.buffer.element_count.set(triangles.len());
+impl GeometryBuffer {
+    pub fn set_buffer_data<T: bytemuck::Pod>(&mut self, buffer: usize, data: &[T]) {
+        self.state
+            .upgrade()
+            .unwrap()
+            .set_vertex_array_object(Some(self.vertex_array_object));
+        self.buffers[buffer]
+            .write_data(array_as_u8_slice(data))
+            .unwrap();
+    }
+
+    pub fn element_count(&self) -> usize {
+        self.element_count.get()
+    }
+
+    pub fn set_triangles(&self, triangles: &[TriangleDefinition]) {
+        assert_eq!(self.element_kind, ElementKind::Triangle);
+        self.element_count.set(triangles.len());
         self.set_elements(array_as_u8_slice(triangles));
-        self
     }
 
-    pub fn set_lines(self, lines: &[[u32; 2]]) -> Self {
-        assert_eq!(self.buffer.element_kind, ElementKind::Line);
-        self.buffer.element_count.set(lines.len());
+    pub fn set_lines(&self, lines: &[[u32; 2]]) {
+        assert_eq!(self.element_kind, ElementKind::Line);
+        self.element_count.set(lines.len());
         self.set_elements(array_as_u8_slice(lines));
-        self
     }
 
     fn set_elements(&self, data: &[u8]) {
-        self.buffer.element_buffer.write_data(data).unwrap()
+        self.state
+            .upgrade()
+            .unwrap()
+            .set_vertex_array_object(Some(self.vertex_array_object));
+        self.element_buffer.write_data(data).unwrap()
     }
 
     pub fn draw(&self, element_range: ElementRange) -> Result<DrawCallStatistics, FrameworkError> {
+        let server = self.state.upgrade().unwrap();
+
         let (offset, count) = match element_range {
-            ElementRange::Full => (0, self.buffer.element_count.get()),
+            ElementRange::Full => (0, self.element_count.get()),
             ElementRange::Specific { offset, count } => (offset, count),
         };
 
         let last_triangle_index = offset + count;
 
-        if last_triangle_index > self.buffer.element_count.get() {
+        if last_triangle_index > self.element_count.get() {
             Err(FrameworkError::InvalidElementRange {
                 start: offset,
                 end: last_triangle_index,
-                total: self.buffer.element_count.get(),
+                total: self.element_count.get(),
             })
         } else {
-            let index_per_element = self.buffer.element_kind.index_per_element();
+            let index_per_element = self.element_kind.index_per_element();
             let start_index = offset * index_per_element;
             let index_count = count * index_per_element;
 
             unsafe {
-                self.draw_internal(start_index, index_count);
+                if index_count > 0 {
+                    server.set_vertex_array_object(Some(self.vertex_array_object));
+
+                    let indices = (start_index * size_of::<u32>()) as i32;
+                    server.gl.draw_elements(
+                        self.mode(),
+                        index_count as i32,
+                        glow::UNSIGNED_INT,
+                        indices,
+                    );
+                }
             }
 
             Ok(DrawCallStatistics { triangles: count })
         }
     }
 
     fn mode(&self) -> u32 {
-        match self.buffer.element_kind {
+        match self.element_kind {
             ElementKind::Triangle => glow::TRIANGLES,
             ElementKind::Line => glow::LINES,
             ElementKind::Point => glow::POINTS,
         }
     }
 
-    unsafe fn draw_internal(&self, start_index: usize, index_count: usize) {
-        if index_count > 0 {
-            let indices = (start_index * size_of::<u32>()) as i32;
-            self.state.gl.draw_elements(
-                self.mode(),
-                index_count as i32,
-                glow::UNSIGNED_INT,
-                indices,
-            );
-        }
-    }
-
     pub fn draw_instances(&self, count: usize) -> DrawCallStatistics {
-        let index_per_element = self.buffer.element_kind.index_per_element();
-        let index_count = self.buffer.element_count.get() * index_per_element;
+        let server = self.state.upgrade().unwrap();
+
+        let index_per_element = self.element_kind.index_per_element();
+        let index_count = self.element_count.get() * index_per_element;
         if index_count > 0 {
             unsafe {
-                self.state.gl.draw_elements_instanced(
+                server.set_vertex_array_object(Some(self.vertex_array_object));
+
+                server.gl.draw_elements_instanced(
                     self.mode(),
                     index_count as i32,
                     glow::UNSIGNED_INT,
@@ -237,32 +250,11 @@ impl<'a> GeometryBufferBinding<'a> {
             }
         }
         DrawCallStatistics {
-            triangles: self.buffer.element_count.get() * count,
+            triangles: self.element_count.get() * count,
         }
     }
 }
 
-impl GeometryBuffer {
-    pub fn set_buffer_data<T: bytemuck::Pod>(&mut self, buffer: usize, data: &[T]) {
-        self.buffers[buffer]
-            .write_data(array_as_u8_slice(data))
-            .unwrap();
-    }
-
-    pub fn bind<'a>(&'a self, state: &'a GlGraphicsServer) -> GeometryBufferBinding<'a> {
-        state.set_vertex_array_object(Some(self.vertex_array_object));
-
-        GeometryBufferBinding {
-            state,
-            buffer: self,
-        }
-    }
-
-    pub fn element_count(&self) -> usize {
-        self.element_count.get()
-    }
-}
-
 impl Drop for GeometryBuffer {
     fn drop(&mut self) {
         if let Some(state) = self.state.upgrade() {

fyrox-graphics/src/gl/framebuffer.rs

@@ -318,7 +318,7 @@ impl FrameBuffer for GlFrameBuffer {
 
         pre_draw(self.id(), &server, viewport, program, params, resources);
 
-        geometry.bind(&server).draw(element_range)
+        geometry.draw(element_range)
     }
 
     fn draw_instances(
@@ -334,7 +334,7 @@ impl FrameBuffer for GlFrameBuffer {
 
         pre_draw(self.id(), &server, viewport, program, params, resources);
 
-        geometry.bind(&server).draw_instances(count)
+        geometry.draw_instances(count)
     }
 }
 

fyrox-impl/src/renderer/cache/geometry.rs

@@ -91,7 +91,6 @@ impl GeometryCache {
                         // Triangles has changed, upload the new content.
                         entry
                             .buffer
-                            .bind(server)
                             .set_triangles(data.geometry_buffer.triangles_ref());
 
                         entry.triangles_modifications_count =

fyrox-impl/src/renderer/debug_renderer.rs

@@ -130,7 +130,7 @@ impl DebugRenderer {
     }
 
     /// Uploads the new set of lines to GPU.
-    pub fn set_lines(&mut self, server: &GlGraphicsServer, lines: &[Line]) {
+    pub fn set_lines(&mut self, lines: &[Line]) {
         self.vertices.clear();
         self.line_indices.clear();
 
@@ -149,7 +149,7 @@ impl DebugRenderer {
             i += 2;
         }
         self.geometry.set_buffer_data(0, &self.vertices);
-        self.geometry.bind(server).set_lines(&self.line_indices);
+        self.geometry.set_lines(&self.line_indices);
     }
 
     pub(crate) fn render(

fyrox-impl/src/renderer/framework/mod.rs

@@ -202,9 +202,7 @@ impl GeometryBufferExt for GeometryBuffer {
             ))
             .build(server)?;
 
-        geometry_buffer
-            .bind(server)
-            .set_triangles(data.geometry_buffer.triangles_ref());
+        geometry_buffer.set_triangles(data.geometry_buffer.triangles_ref());
 
         Ok(geometry_buffer)
     }

fyrox-impl/src/renderer/mod.rs

@@ -1615,8 +1615,7 @@ impl Renderer {
             }
 
             // Render debug geometry in the LDR frame buffer.
-            self.debug_renderer
-                .set_lines(server, &scene.drawing_context.lines);
+            self.debug_renderer.set_lines(&scene.drawing_context.lines);
             scene_associated_data.statistics += self.debug_renderer.render(
                 &**server,
                 &mut self.uniform_buffer_cache,

fyrox-impl/src/renderer/occlusion/mod.rs

@@ -303,7 +303,6 @@ impl OcclusionTester {
 
     fn prepare_tiles(
         &mut self,
-        server: &GlGraphicsServer,
         graph: &Graph,
         viewport: &Rect<i32>,
         debug_renderer: Option<&mut DebugRenderer>,
@@ -352,7 +351,7 @@ impl OcclusionTester {
                 );
             }
 
-            debug_renderer.set_lines(server, &lines);
+            debug_renderer.set_lines(&lines);
         }
 
         self.tile_buffer.borrow_mut().set_data(
@@ -443,7 +442,7 @@ impl OcclusionTester {
         self.framebuffer
             .clear(viewport, Some(Color::TRANSPARENT), None, None);
 
-        self.prepare_tiles(server, graph, &viewport, debug_renderer)?;
+        self.prepare_tiles(graph, &viewport, debug_renderer)?;
 
         self.matrix_storage
             .upload(self.objects_to_test.iter().filter_map(|h| {

fyrox-impl/src/renderer/ui_renderer.rs

@@ -176,9 +176,8 @@ impl UiRenderer {
 
         self.geometry_buffer
             .set_buffer_data(0, drawing_context.get_vertices());
-
-        let geometry_buffer = self.geometry_buffer.bind(server);
-        geometry_buffer.set_triangles(drawing_context.get_triangles());
+        self.geometry_buffer
+            .set_triangles(drawing_context.get_triangles());
 
         let ortho = Matrix4::new_orthographic(0.0, frame_width, frame_height, 0.0, -1.0, 1.0);
         let resolution = Vector2::new(frame_width, frame_height);
@@ -211,7 +210,6 @@ impl UiRenderer {
                 self.clipping_geometry_buffer
                     .set_buffer_data(0, &clipping_geometry.vertex_buffer);
                 self.clipping_geometry_buffer
-                    .bind(server)
                     .set_triangles(&clipping_geometry.triangle_buffer);
 
                 let uniform_buffer = uniform_buffer_cache