Initial commit

Author: Jerald

.gitignore

@@ -0,0 +1,2 @@
+/target
+Cargo.lock

Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "bevy_lyon"
+version = "0.1.0"
+authors = ["Matrixmage <[email protected]>"]
+edition = "2018"
+license = "MIT"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+bevy = "0.1.3"
+lyon = "0.16.0"
+smart-default = "0.6.0"

README.md

@@ -0,0 +1,17 @@
+pub mod mesh_builder;
+pub mod shapes;
+
+#[doc(inline)]
+pub use shapes::{
+    LyonShapeBuilder
+};
+
+#[doc(inline)]
+pub use mesh_builder::{
+    BevyIndex,
+    BevyVertex,
+    BevyVertexBuffers,
+    BevyBuffersBuilder,
+
+    LyonMeshBuilder,
+};

src/lib.rs

@@ -0,0 +1,158 @@
+use bevy::render::{
+    mesh::{
+        VertexAttribute,
+        Mesh
+    },
+    pipeline::PrimitiveTopology,
+};
+
+use lyon::{
+    math::{
+        self,
+        Point
+    },
+    tessellation as tess,
+};
+
+use super::shapes::LyonShapeBuilder;
+
+/// Type alias for the type of a mesh index in bevy.
+pub type BevyIndex = u32;
+/// Type alias for a `VertexBuffers` of `BevyVertex`'s and `BevyIndex`'s.
+pub type BevyVertexBuffers = tess::VertexBuffers<BevyVertex, BevyIndex>;
+/// Type alias for a buffer builder that contains the information to properly convert lyon points to `BevyVertex`'s and `BevyIndex`'s.
+pub type BevyBuffersBuilder<'a> = tess::BuffersBuilder<'a, BevyVertex, BevyIndex, BevyVertexConstructor>;
+
+/// Builder that provides customizable functionality to create `lyon` tessellated meshes and build them so `bevy` can consume them.
+#[derive(Debug, Clone)]
+pub struct LyonMeshBuilder
+{
+    geometry: BevyVertexBuffers
+}
+
+impl LyonMeshBuilder
+{
+    /// Create a new mesh builder.
+    pub fn new() -> Self
+    {
+        LyonMeshBuilder {
+            geometry: BevyVertexBuffers::new()
+        }
+    }
+
+    /// Finish the building and produce the final mesh.
+    ///
+    /// Uses TriangleStrip as the default primitive topology.
+    pub fn build(self) -> Mesh
+    {
+        self.build_with_topology(PrimitiveTopology::TriangleStrip)
+    }
+
+    /// Finishes a mesh using a custom specified `PrimitiveTopology`.
+    ///
+    /// Prefer using `build()` as its default works in the vast majority of cases.
+    pub fn build_with_topology(self, topology: PrimitiveTopology) -> Mesh
+    {
+        Mesh {
+            primitive_topology: topology,
+            attributes: self.verts_to_attributes(),
+            indices: Some(self.geometry.indices),
+        }
+    }
+
+    /// Adds a shape specified by its `LyonShapeBuilder` implementation to the mesh being constructed.
+    pub fn with(mut self, shape: impl LyonShapeBuilder) -> Self
+    {
+        shape.build(&mut self.buffers_builder());
+        self
+    }
+
+    /// A convenience function that makes a new `LyonMeshBuilder` and builds it with only the single shape provided.
+    pub fn only(shape: impl LyonShapeBuilder) -> Mesh
+    {
+        LyonMeshBuilder::new()
+            .with(shape)
+            .build()
+    }
+
+    /// Internal utility function to simplify creation of an output buffer builder.
+    fn buffers_builder(&mut self) -> tess::BuffersBuilder<BevyVertex, BevyIndex, BevyVertexConstructor>
+    {
+        tess::BuffersBuilder::new(&mut self.geometry, BevyVertexConstructor)
+    }
+
+    /// Internal utility function that transforms an iterator of `BevyVertex`'s into the proper array of vertex attributes.
+    fn verts_to_attributes(&self) -> Vec<VertexAttribute>
+    {
+        let mut positions = vec![];
+        let mut normals = vec![];
+        let mut uvs = vec![];
+    
+        for vertex in &self.geometry.vertices
+        {
+            positions.push(vertex.pos);
+            normals.push(vertex.norm);
+            uvs.push(vertex.uv);
+        }
+
+        vec![
+            VertexAttribute::position(positions),
+            VertexAttribute::normal(normals),
+            VertexAttribute::uv(uvs),
+        ]
+    }
+}
+
+/// Utility type for containing the trait implementations that transforms a lyon point into a `BevyVertex`.
+pub struct BevyVertexConstructor;
+
+// TODO: Figure out if uv mapping should be specific for this
+impl tess::BasicVertexConstructor<BevyVertex> for BevyVertexConstructor
+{
+    fn new_vertex(&mut self, point: Point) -> BevyVertex
+    {
+        point.into()
+    }
+}
+
+// TODO: Figure out if uv mapping should be specific for this
+impl tess::FillVertexConstructor<BevyVertex> for BevyVertexConstructor
+{
+    fn new_vertex(&mut self, point: Point, _: tess::FillAttributes) -> BevyVertex
+    {
+        point.into()
+    }
+}
+
+// TODO: Figure out if uv mapping should be specific for this
+impl tess::StrokeVertexConstructor<BevyVertex> for BevyVertexConstructor
+{
+    fn new_vertex(&mut self, point: Point, _: tess::StrokeAttributes) -> BevyVertex
+    {
+        point.into()
+    }
+}
+
+/// Contains all the vertex information needed by bevy to correctly create a mesh.
+#[derive(Debug, Clone)]
+pub struct BevyVertex
+{
+    pub pos: [f32; 3],
+    pub norm: [f32; 3],
+    pub uv: [f32; 2],
+}
+
+/// Performs a trivial conversion from a lyon point into a `BevyVertex`
+impl From<math::Point> for BevyVertex
+{
+    fn from(point: math::Point) -> Self
+    {
+        // In 2d, Z can just be 0
+        BevyVertex {
+            pos: [point.x, point.y, 0.0],
+            norm: [0.0, 0.0, 1.0],
+            uv: [point.x, point.y],
+        }
+    }
+}
+

src/mesh_builder.rs

@@ -0,0 +1,71 @@
+use smart_default::*;
+
+use lyon::{
+    math,
+    tessellation::{
+        self as tess,
+        basic_shapes,
+    },
+};
+
+use super::mesh_builder::BevyBuffersBuilder;
+
+/// Represents something capable of being built into a shape with the `LyonMeshBuilder`.
+pub trait LyonShapeBuilder
+{
+    fn build(self, builder: &mut BevyBuffersBuilder);
+}
+
+/// Allow all closures and functions that take in a mutable reference to a `BevyBuffersBuilder` to be considered a shape builder.
+///
+/// Permits ergonomically using a closure (or function) for complicated custom meshes.
+impl<F> LyonShapeBuilder for F
+where
+    F: FnOnce(&mut BevyBuffersBuilder)
+{
+    fn build(self, builder: &mut BevyBuffersBuilder) {
+        self(builder);
+    }
+}
+
+#[derive(Debug, SmartDefault)]
+pub struct FillCircle<'a> {
+    pub center: math::Point,
+    #[default = 25.0]
+    pub radius: f32,
+    #[default(&tess::FillOptions::DEFAULT)]
+    pub options: &'a tess::FillOptions
+}
+
+impl LyonShapeBuilder for FillCircle<'_>
+{
+    fn build(self, builder: &mut BevyBuffersBuilder) {
+        let _ = basic_shapes::fill_circle(
+            self.center,
+            self.radius,
+            self.options,
+            builder
+        );
+    }
+}
+
+#[derive(Debug, SmartDefault)]
+pub struct StrokeCircle<'a> {
+    pub center: math::Point,
+    #[default = 25.0]
+    pub radius: f32,
+    #[default(&tess::StrokeOptions::DEFAULT)]
+    pub options: &'a tess::StrokeOptions
+}
+
+impl LyonShapeBuilder for StrokeCircle<'_>
+{
+    fn build(self, builder: &mut BevyBuffersBuilder) {
+        let _ = basic_shapes::stroke_circle(
+            self.center,
+            self.radius,
+            self.options,
+            builder
+        );
+    }
+}