Added some basic documentation

Author: Jerald

examples/basic_usage.rs

@@ -0,0 +1,91 @@
+use bevy::{
+    prelude::*,
+};
+
+use bevy_lyon::{
+    shapes,
+    LyonMeshBuilder,
+    math
+};
+
+fn main() {
+    App::build()
+        .add_default_plugins()
+        .add_startup_system(setup_system.system())
+        .run();
+}
+
+fn setup_system(
+    mut commands: Commands,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+    mut meshes: ResMut<Assets<Mesh>>,
+) {
+    let red = materials.add(Color::RED.into());
+    let green = materials.add(Color::GREEN.into());
+    let blue = materials.add(Color::BLUE.into());
+
+    let fill_circle = meshes.add(LyonMeshBuilder::with_only(
+        shapes::FillCircle {
+            center: math::point(-100.0, 0.0),
+            ..Default::default()
+        }
+    ));
+
+    let stroke_circle = meshes.add(LyonMeshBuilder::with_only(
+        shapes::StrokeCircle {
+            center: math::point(-100.0, 0.0),
+            radius: 35.0,
+            ..Default::default()
+        }
+    ));
+
+    let ellipse = meshes.add(LyonMeshBuilder::with_only(
+        shapes::StrokeEllipse {
+            center: math::point(50.0, 25.0),
+            ..Default::default()
+        }
+    ));
+
+    let convex_polyline = meshes.add(LyonMeshBuilder::with_only(
+        shapes::FillConvexPolyline {
+            points: vec![
+                math::point(0.0, 0.0),
+                math::point(25.0, 50.0),
+                math::point(50.0, 0.0),
+                math::point(50.0, -100.0),
+                math::point(25.0, -150.0),
+                math::point(0.0, -100.0)
+            ],
+            ..Default::default()
+        }
+    ));
+
+    commands
+        .spawn(Camera2dComponents::default())
+        .spawn(SpriteComponents {
+            mesh: fill_circle,
+            material: red,
+            sprite: Sprite { size: Vec2::new(1.0, 1.0) },
+            ..Default::default()
+        })
+        .spawn(SpriteComponents {
+            mesh: stroke_circle,
+            material: green,
+            sprite: Sprite { size: Vec2::new(1.0, 1.0) },
+            ..Default::default()
+        })
+        .spawn(SpriteComponents {
+            mesh: ellipse,
+            material: red,
+            sprite: Sprite { size: Vec2::new(1.0, 1.0) },
+            ..Default::default()
+        })
+        .spawn(SpriteComponents {
+            mesh: convex_polyline,
+            material: blue,
+            sprite: Sprite { size: Vec2::new(1.0, 1.0) },
+            translation: Translation::new(25.0, 75.0, 0.0),
+            ..Default::default()
+        });
+
+}

src/lib.rs

@@ -1,4 +1,5 @@
 pub mod mesh_builder;
+
 pub mod shapes;
 
 #[doc(inline)]
@@ -15,3 +16,6 @@ pub use mesh_builder::{
 
     LyonMeshBuilder,
 };
+
+#[doc(no_inline)]
+pub use lyon::math;

src/mesh_builder.rs

@@ -1,3 +1,12 @@
+//! 
+//! 
+//! 
+//! 
+//! 
+//! 
+//! 
+
+
 use bevy::render::{
     mesh::{
         VertexAttribute,
@@ -16,14 +25,14 @@ use lyon::{
 
 use super::shapes::LyonShapeBuilder;
 
-/// Type alias for the type of a mesh index in bevy.
+/// 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.
+/// Type alias for a [`VertexBuffers`](tess::VertexBuffers) of [`BevyVertex`](BevyVertex)'s and [`BevyIndex`](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.
+/// Type alias for a [`BuffersBuilder`](tess::BuffersBuilder) 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.
+/// Builder that provides customizable functionality to create [`lyon`](lyon) tessellated meshes and build them so [`bevy`](bevy) can consume them.
 #[derive(Debug, Clone)]
 pub struct LyonMeshBuilder
 {
@@ -42,15 +51,16 @@ impl LyonMeshBuilder
 
     /// Finish the building and produce the final mesh.
     ///
-    /// Uses TriangleStrip as the default primitive topology.
+    /// Uses [`TriangleStrip`](PrimitiveTopology::TriangleStrip) as the default primitive topology.
     pub fn build(self) -> Mesh
     {
+        LyonMeshBuilder::
         self.build_with_topology(PrimitiveTopology::TriangleStrip)
     }
 
-    /// Finishes a mesh using a custom specified `PrimitiveTopology`.
+    /// Finishes a mesh using a specific [`PrimitiveTopology`].
     ///
-    /// Prefer using `build()` as its default works in the vast majority of cases.
+    /// Prefer using [`LyonMeshBuilder::build`] as its default topology works in the vast majority of cases.
     pub fn build_with_topology(self, topology: PrimitiveTopology) -> Mesh
     {
         Mesh {
@@ -60,15 +70,30 @@ impl LyonMeshBuilder
         }
     }
 
-    /// Adds a shape specified by its `LyonShapeBuilder` implementation to the mesh being constructed.
+    /// Adds a shape specified by argument's [`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
+    /// A convenience function that makes a new [`LyonMeshBuilder`] and builds it with only the single shape provided.
+    ///
+    /// This is equivalent to calling:
+    /// ```rust
+    /// # use bevy::render::mesh::Mesh;
+    /// # use bevy_lyon::{
+    /// #    LyonShapeBuilder,
+    /// #    LyonMeshBuilder
+    /// # };
+    /// # fn with_only_example(shape: impl LyonShapeBuilder) -> Mesh
+    /// # {
+    /// LyonMeshBuilder::new()
+    ///     .with(shape)
+    ///     .build()
+    /// # }
+    /// ```
+    pub fn with_only(shape: impl LyonShapeBuilder) -> Mesh
     {
         LyonMeshBuilder::new()
             .with(shape)

src/shapes.rs

@@ -1,3 +1,12 @@
+//! Shapes for easily constructing basic meshes with [`LyonMeshBuilder`].
+//!
+//! # Overview
+//! 
+//! This module provides a set of shapes consumable by the [`LyonMeshBuilder`] which draws some simple basic shapes.
+//! The shapes provided here match with the shapes that have simple tesselators provided by `lyon`.
+//! 
+//! [`LyonMeshBuilder`]: crate::mesh_builder::LyonMeshBuilder
+
 use smart_default::*;
 
 use lyon::{
@@ -6,19 +15,17 @@ use lyon::{
         self as tess,
         basic_shapes,
     },
-    self
 };
 
 use super::mesh_builder::BevyBuffersBuilder;
 
-/// Represents something capable of being built into a shape with the `LyonMeshBuilder`.
+/// Represents something capable of being built into a shape with the [`LyonMeshBuilder`](crate::mesh_builder::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.
-///
+/// 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
@@ -50,6 +57,7 @@ impl LyonShapeBuilder for FillCircle<'_>
     }
 }
 
+/// Requires the points to represent a convex shape. If the shape is concave the result will likely be incorrect.
 #[derive(Debug, SmartDefault)]
 pub struct FillConvexPolyline<'a, I, G>
 where
@@ -223,6 +231,7 @@ where
     I: IntoIterator<Item=math::Point> + Default
 {
     pub points: I,
+    #[default = true]
     pub is_closed: bool,
     #[default(&tess::StrokeOptions::DEFAULT)]
     pub options: &'a tess::StrokeOptions,