Use a vertex buffer slice in draw_elements args

citro3d/examples/cube.rs

@@ -122,8 +122,10 @@ fn main() {
         vbo_data.push(vert);
     }
 
+    let attr_info = build_attrib_info();
+
     let mut buf_info = buffer::Info::new();
-    let (attr_info, vbo_slice) = prepare_vbos(&mut buf_info, &vbo_data);
+    let vbo_slice = buf_info.add(&vbo_data, &attr_info).unwrap();
 
     // Configure the first fragment shading substage to just pass through the vertex color
     // See https://www.opengl.org/sdk/docs/man2/xhtml/glTexEnv.xml for more insight
@@ -148,7 +150,7 @@ fn main() {
         16, 19, 17, 17, 19, 18, // back (+z)
         20, 21, 23, 21, 22, 23, // forward (-z)
     ];
-    let indices = vbo_slice.index_buffer(indices).unwrap();
+    let index_buffer = vbo_slice.index_buffer(indices).unwrap();
 
     while apt.main_loop() {
         hid.scan_input();
@@ -169,7 +171,7 @@ fn main() {
 
                 instance.set_attr_info(&attr_info);
                 unsafe {
-                    instance.draw_elements(buffer::Primitive::Triangles, &buf_info, &indices);
+                    instance.draw_elements(buffer::Primitive::Triangles, vbo_slice, &index_buffer);
                 }
             };
 
@@ -186,10 +188,7 @@ fn main() {
     }
 }
 
-fn prepare_vbos<'a>(
-    buf_info: &'a mut buffer::Info,
-    vbo_data: &'a [Vertex],
-) -> (attrib::Info, buffer::Slice<'a>) {
+fn build_attrib_info() -> attrib::Info {
     // Configure attributes for use with the vertex shader
     let mut attr_info = attrib::Info::new();
 
@@ -204,9 +203,7 @@ fn prepare_vbos<'a>(
         .add_loader(reg1, attrib::Format::Float, 3)
         .unwrap();
 
-    let buf_idx = buf_info.add(vbo_data, &attr_info).unwrap();
-
-    (attr_info, buf_idx)
+    attr_info
 }
 
 struct Projections {

citro3d/src/buffer.rs

@@ -57,7 +57,7 @@ impl Slice<'_> {
     /// Returns an error if:
     /// - any of the given indices are out of bounds.
     /// - the given slice is too long for its length to fit in a `libc::c_int`.
-    pub fn index_buffer<I>(&self, indices: &[I]) -> Result<Vec<I, LinearAllocator>, Error>
+    pub fn index_buffer<I>(&self, indices: &[I]) -> Result<Indices<I>, Error>
     where
         I: Index + Copy + Into<libc::c_int>,
     {
@@ -83,16 +83,22 @@ impl Slice<'_> {
     ///
     /// If any indices are outside this buffer it can cause an invalid access by the GPU
     /// (this crashes citra).
-    pub unsafe fn index_buffer_unchecked<I: Index + Clone>(
-        &self,
-        indices: &[I],
-    ) -> Vec<I, LinearAllocator> {
-        let mut buf = Vec::with_capacity_in(indices.len(), LinearAllocator);
-        buf.extend_from_slice(indices);
-        buf
+    pub unsafe fn index_buffer_unchecked<I: Index + Clone>(&self, indices: &[I]) -> Indices<I> {
+        let mut buffer = Vec::with_capacity_in(indices.len(), LinearAllocator);
+        buffer.extend_from_slice(indices);
+        Indices {
+            buffer,
+            _slice: *self,
+        }
     }
 }
 
+/// An index buffer for indexed drawing. See [`Slice::index_buffer`] to obtain one.
+pub struct Indices<'buf, I> {
+    pub(crate) buffer: Vec<I, LinearAllocator>,
+    _slice: Slice<'buf>,
+}
+
 /// A type that can be used as an index for indexed drawing.
 pub trait Index: crate::private::Sealed {
     /// The data type of the index, as used by [`citro3d_sys::C3D_DrawElements`]'s `type_` parameter.

citro3d/src/error.rs

@@ -1,6 +1,5 @@
 //! General-purpose error and result types returned by public APIs of this crate.
 
-use core::fmt;
 use std::ffi::NulError;
 use std::num::TryFromIntError;
 use std::sync::TryLockError;

citro3d/src/lib.rs

@@ -30,10 +30,10 @@ use std::cell::{OnceCell, RefMut};
 use std::fmt;
 use std::rc::Rc;
 
-use ctru::linear::LinearAllocation;
 use ctru::services::gfx::Screen;
 pub use error::{Error, Result};
 
+use self::buffer::{Index, Indices};
 use self::texenv::TexEnv;
 use self::uniform::Uniform;
 
@@ -219,18 +219,15 @@ impl Instance {
     ///
     /// If the given index buffer is too long to have its length converted to `i32`.
     #[doc(alias = "C3D_DrawElements")]
-    pub unsafe fn draw_elements<I, Indices>(
+    pub unsafe fn draw_elements<I: Index>(
         &mut self,
         primitive: buffer::Primitive,
-        buf: &buffer::Info,
-        indices: &Indices,
-    ) where
-        I: buffer::Index,
-        Indices: AsRef<[I]> + LinearAllocation,
-    {
-        self.set_buffer_info(buf);
-
-        let indices = indices.as_ref();
+        vbo_data: buffer::Slice,
+        indices: &Indices<I>,
+    ) {
+        self.set_buffer_info(vbo_data.info());
+
+        let indices = &indices.buffer;
         let elements = indices.as_ptr().cast();
 
         citro3d_sys::C3D_DrawElements(

citro3d/src/math/ops.rs

@@ -212,7 +212,7 @@ impl AbsDiffEq for Matrix4 {
     fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool {
         self.rows_wzyx()
             .into_iter()
-            .zip(other.rows_wzyx().into_iter())
+            .zip(other.rows_wzyx())
             .all(|(l, r)| l.abs_diff_eq(&r, epsilon))
     }
 }