Make Batch generic over primitive type

Author: jdahlstrom

core/src/render/batch.rs

@@ -8,18 +8,19 @@ use crate::{
     math::{Mat4x4, Vary},
 };
 
-use super::{Context, NdcToScreen, Shader, Target};
+use super::{Clip, Context, NdcToScreen, Render, Shader, Target};
 
 /// A builder for rendering a chunk of geometry as a batch.
 ///
 /// Several values must be assigned before the [`render`][Batch::render]
 /// method can be called:
-/// * [faces][Batch::faces]: A list of triangles, each a triplet of indices
-///   into the list of vertices (TODO: handling oob)
+/// * [primitives][Batch::primitives]: A list of primitives, each a tuple
+///       of indices into the list of vertices (TODO: handling oob)
 /// * [vertices][Batch::vertices]: A list of vertices
 /// * [shader][Batch::shader]: The combined vertex and fragment shader used
 /// * [target][Batch::target]: The render target to render into
-/// * [context][Batch::context]: The rendering context and settings used. (TODO: optional?)
+/// * [context][Batch::context]: The rendering context and settings used.
+///       (TODO: optional?)
 ///
 /// Additionally, setting the following values is optional:
 /// * [uniform][Batch::uniform]: The uniform value passed to the vertex shader
@@ -29,8 +30,8 @@ use super::{Context, NdcToScreen, Shader, Target};
 // using the same configuration, or several [instances] of the same geometry.
 // [instances]: https://en.wikipedia.org/wiki/Geometry_instancing
 #[derive(Clone, Debug, Default)]
-pub struct Batch<Vtx, Uni, Shd, Tgt, Ctx> {
-    faces: Vec<Tri<usize>>,
+pub struct Batch<Prim, Vtx, Uni, Shd, Tgt, Ctx> {
+    prims: Vec<Prim>,
     verts: Vec<Vtx>,
     uniform: Uni,
     shader: Shd,
@@ -46,21 +47,22 @@ macro_rules! update {
     }};
 }
 
-impl Batch<(), (), (), (), Context> {
+impl Batch<(), (), (), (), (), Context> {
     pub fn new() -> Self {
         Self::default()
     }
 }
 
-impl<Vtx, Uni, Shd, Tgt, Ctx> Batch<Vtx, Uni, Shd, Tgt, Ctx> {
-    /// Sets the faces to be rendered.
+impl<Prim, Vtx, Uni, Shd, Tgt, Ctx> Batch<Prim, Vtx, Uni, Shd, Tgt, Ctx> {
+    /// Sets the primitives to be rendered.
     ///
-    /// The faces are copied into the batch.
-    pub fn faces(self, faces: impl AsRef<[Tri<usize>]>) -> Self {
-        Self {
-            faces: faces.as_ref().to_vec(),
-            ..self
-        }
+    /// The primitives are copied into the batch.
+    pub fn primitives<P: Clone>(
+        self,
+        prims: impl AsRef<[P]>,
+    ) -> Batch<P, Vtx, Uni, Shd, Tgt, Ctx> {
+        let prims = prims.as_ref().to_vec();
+        update!(prims; self verts uniform shader viewport target ctx)
     }
 
     /// Sets the vertices to be rendered.
@@ -70,69 +72,78 @@ impl<Vtx, Uni, Shd, Tgt, Ctx> Batch<Vtx, Uni, Shd, Tgt, Ctx> {
     pub fn vertices<V: Clone>(
         self,
         verts: impl AsRef<[V]>,
-    ) -> Batch<V, Uni, Shd, Tgt, Ctx> {
+    ) -> Batch<Prim, V, Uni, Shd, Tgt, Ctx> {
         let verts = verts.as_ref().to_vec();
-        update!(verts; self faces uniform shader viewport target ctx)
+        update!(verts; self prims uniform shader viewport target ctx)
     }
 
     /// Clones faces and vertices from a mesh to this batch.
     pub fn mesh<A: Clone>(
         self,
         mesh: &Mesh<A>,
-    ) -> Batch<Vertex3<A>, Uni, Shd, Tgt, Ctx> {
-        let faces = mesh.faces.clone();
+    ) -> Batch<Tri<usize>, Vertex3<A>, Uni, Shd, Tgt, Ctx> {
+        let prims = mesh.faces.clone();
         let verts = mesh.verts.clone();
-        update!(verts faces; self uniform shader viewport target ctx)
+        update!(verts prims; self uniform shader viewport target ctx)
     }
 
     /// Sets the uniform data to be passed to the vertex shaders.
-    pub fn uniform<U: Copy>(self, uniform: U) -> Batch<Vtx, U, Shd, Tgt, Ctx> {
-        update!(uniform; self verts faces shader viewport target ctx)
+    pub fn uniform<U: Copy>(
+        self,
+        uniform: U,
+    ) -> Batch<Prim, Vtx, U, Shd, Tgt, Ctx> {
+        update!(uniform; self verts prims shader viewport target ctx)
     }
 
     /// Sets the combined vertex and fragment shader.
-    pub fn shader<V: Vary, S: Shader<Vtx, V, Uni>>(
+    pub fn shader<V: Vary, U, S: Shader<Vtx, V, U>>(
         self,
         shader: S,
-    ) -> Batch<Vtx, Uni, S, Tgt, Ctx> {
-        update!(shader; self verts faces uniform viewport target ctx)
+    ) -> Batch<Prim, Vtx, Uni, S, Tgt, Ctx> {
+        update!(shader; self verts prims uniform viewport target ctx)
     }
 
     /// Sets the viewport matrix.
     pub fn viewport(self, viewport: Mat4x4<NdcToScreen>) -> Self {
-        update!(viewport; self verts faces uniform shader target ctx)
+        update!(viewport; self verts prims uniform shader target ctx)
     }
 
     /// Sets the render target.
     // TODO what bound for T?
-    pub fn target<T>(self, target: T) -> Batch<Vtx, Uni, Shd, T, Ctx> {
-        update!(target; self verts faces uniform shader viewport ctx)
+    pub fn target<T>(self, target: T) -> Batch<Prim, Vtx, Uni, Shd, T, Ctx> {
+        update!(target; self verts prims uniform shader viewport ctx)
     }
 
     /// Sets the rendering context.
-    pub fn context(self, ctx: &Context) -> Batch<Vtx, Uni, Shd, Tgt, &Context> {
-        update!(ctx; self verts faces uniform shader viewport target)
+    pub fn context(
+        self,
+        ctx: &Context,
+    ) -> Batch<Prim, Vtx, Uni, Shd, Tgt, &Context> {
+        update!(ctx; self verts prims uniform shader viewport target)
     }
 }
 
-impl<Vtx, Uni, Shd, Tgt, Ctx> Batch<Vtx, Uni, Shd, &mut Tgt, Ctx> {
+impl<Prim, Vtx, Uni, Shd, Tgt, Ctx> Batch<Prim, Vtx, Uni, Shd, &mut Tgt, Ctx> {
     /// Renders this batch of geometry.
     #[rustfmt::skip]
-    pub fn render<V: Vary>(&mut self)
+    pub fn render<Var>(&mut self)
     where
+        Var: Vary,
+        Prim: Render<Var> + Clone,
         Vtx: Clone,
         Uni: Copy,
-        Shd: Shader<Vtx, V, Uni>,
+        [<Prim>::Clip]: Clip<Item= Prim::Clip>,
+        Shd: Shader<Vtx, Var, Uni>,
         Tgt: Target,
         Ctx: Borrow<Context>
     {
         let Self {
-            faces, verts, shader, uniform, viewport, target, ctx,
+            prims, verts, shader, uniform, viewport, target, ctx,
         } = self;
 
         super::render(
-            faces, verts, shader, *uniform, *viewport,
-            *target, (*ctx).borrow(),
+            prims, verts, shader, *uniform, *viewport, *target,
+            (*ctx).borrow(),
         );
     }
 }