1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182

//! 

//! 

//! 

//! 

//! 

//! 

//! 



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`](tess::VertexBuffers) of [`BevyVertex`](BevyVertex)'s and [`BevyIndex`](BevyIndex)'s.

pub type BevyVertexBuffers = tess::VertexBuffers<BevyVertex, BevyIndex>;
/// 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`](lyon) tessellated meshes and build them so [`bevy`](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`](PrimitiveTopology::TriangleStrip) as the default primitive topology.

    pub fn build(self) -> Mesh
    {
        self.build_with_topology(PrimitiveTopology::TriangleStrip)
    }

    /// Finishes a mesh using a specific [`PrimitiveTopology`].

    ///

    /// 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 {
            primitive_topology: topology,
            attributes: self.verts_to_attributes(),
            indices: Some(self.geometry.indices),
        }
    }

    /// 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.

    ///

    /// 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)
            .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],
        }
    }
}