Refactor primitive meshing

benches/Cargo.toml

@@ -68,6 +68,12 @@ name = "torus"
 path = "benches/bevy_render/torus.rs"
 harness = false
 
+[[bench]]
+name = "capsule"
+path = "benches/bevy_render/capsule.rs"
+harness = false
+
+
 [[bench]]
 name = "entity_hash"
 path = "benches/bevy_ecs/world/entity_hash.rs"

benches/benches/bevy_render/capsule.rs

@@ -0,0 +1,52 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
+use bevy_render::mesh::Capsule3dMeshBuilder;
+
+criterion_group!(benches, capsule_low_res, capsule_default, capsule_high_res);
+fn capsule_low_res(c: &mut Criterion) {
+    c.bench_function("build_capsule_low_res", |b| {
+        b.iter(|| {
+            black_box(
+                Capsule3dMeshBuilder::new(
+                    black_box(0.5),
+                    black_box(1.0),
+                    black_box(16),
+                    black_box(4),
+                )
+                .build(),
+            )
+        });
+    });
+}
+fn capsule_default(c: &mut Criterion) {
+    c.bench_function("build_capsule_default", |b| {
+        b.iter(|| {
+            black_box(
+                Capsule3dMeshBuilder::new(
+                    black_box(0.5),
+                    black_box(1.0),
+                    black_box(32),
+                    black_box(8),
+                )
+                .build(),
+            )
+        });
+    });
+}
+
+fn capsule_high_res(c: &mut Criterion) {
+    c.bench_function("build_capsule_high_res", |b| {
+        b.iter(|| {
+            black_box(
+                Capsule3dMeshBuilder::new(
+                    black_box(0.5),
+                    black_box(1.0),
+                    black_box(64),
+                    black_box(16),
+                )
+                .build(),
+            )
+        });
+    });
+}
+criterion_main!(benches);

benches/benches/bevy_render/torus.rs

@@ -2,14 +2,38 @@ use criterion::{black_box, criterion_group, criterion_main, Criterion};
 
 use bevy_render::mesh::TorusMeshBuilder;
 
-fn torus(c: &mut Criterion) {
-    c.bench_function("build_torus", |b| {
-        b.iter(|| black_box(TorusMeshBuilder::new(black_box(0.5),black_box(1.0))));
+criterion_group!(benches, torus_low_res, torus_default, torus_high_res,);
+
+fn torus_low_res(c: &mut Criterion) {
+    c.bench_function("build_torus_low_res", |b| {
+        b.iter(|| {
+            black_box(
+                TorusMeshBuilder::new(black_box(0.5), black_box(1.0))
+                    .minor_resolution(black_box(12))
+                    .major_resolution(black_box(16))
+                    .build(),
+            )
+        });
+    });
+}
+
+fn torus_default(c: &mut Criterion) {
+    c.bench_function("build_torus_default", |b| {
+        b.iter(|| black_box(TorusMeshBuilder::new(black_box(0.5), black_box(1.0)).build()));
+    });
+}
+
+fn torus_high_res(c: &mut Criterion) {
+    c.bench_function("build_torus_high_res", |b| {
+        b.iter(|| {
+            black_box(
+                TorusMeshBuilder::new(black_box(0.5), black_box(1.0))
+                    .minor_resolution(black_box(48))
+                    .major_resolution(black_box(64))
+                    .build(),
+            )
+        });
     });
 }
 
-criterion_group!(
-    benches,
-    torus,
-);
 criterion_main!(benches);

crates/bevy_render/src/mesh/primitives/circle_iterator.rs

@@ -0,0 +1,83 @@
+use bevy_math::DMat2;
+use bevy_math::DVec2;
+use bevy_math::Vec2;
+use std::f64::consts::TAU;
+
+//iterator for generating a set of points around a unit circle, beginning at 0 radians
+#[derive(Debug, Clone)]
+pub(crate) struct CircleIterator {
+    count: usize,
+    rot: DMat2,
+    pos: DVec2,
+}
+
+impl CircleIterator {
+    //produces an iterator over (count) equidistant points that starts at (1.0, 0.0) on the unit circle
+    pub(crate) fn new(count: usize) -> CircleIterator {
+        Self {
+            count,
+            rot: DMat2::from_angle(TAU / (count as f64)),
+            pos: DVec2::new(1.0, 0.0),
+        }
+    }
+
+    //produces an iterator over (count) equidistant points that starts at (1.0, 0.0) on the unit circle, with an additional end point of (1.0, 0.0)
+    pub(crate) fn wrapping(count: usize) -> impl Iterator<Item = Vec2> {
+        Self::new(count).chain(std::iter::once(Vec2::new(1.0, 0.0)))
+    }
+
+    //semicircle with points ranging from 0 radians to pi radians, with (count) regions between points.
+    pub(crate) fn semicircle(count: usize) -> impl Iterator<Item = Vec2> {
+        Self::new(count * 2)
+            .take(count)
+            .chain(std::iter::once(Vec2::new(-1.0, 0.0)))
+    }
+
+    //quarter circle with points ranging from 0 radians to pi/2 radians, with (count) regions between points.
+    pub(crate) fn quarter_circle(count: usize) -> impl Iterator<Item = Vec2> {
+        Self::new(count * 4)
+            .take(count)
+            .chain(std::iter::once(Vec2::new(0.0, 1.0)))
+    }
+}
+impl Iterator for CircleIterator {
+    type Item = Vec2;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.count != 0 {
+            let prev = self.pos.as_vec2();
+            self.pos = self.rot * self.pos;
+            self.count -= 1;
+            Some(prev)
+        } else {
+            None
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::CircleIterator;
+    use bevy_math::Vec2;
+    #[test]
+    fn circle_iterator_has_correct_length() {
+        let vertices: Vec<Vec2> = CircleIterator::new(6).collect();
+        assert_eq!(vertices.len(), 6);
+    }
+
+    #[test]
+    fn circle_iterator_vertices_are_equidistant() {
+        let epsilon = 0.00001;
+        let vertices: Vec<Vec2> = CircleIterator::new(6).collect();
+        let center = Vec2::new(0.0, 0.0);
+        let distances_center: Vec<f32> = vertices.iter().map(|x| center.distance(*x)).collect();
+        assert!(distances_center
+            .windows(2)
+            .all(|w| (w[0] - w[1]).abs() < epsilon));
+        let distances_neighbors: Vec<f32> =
+            vertices.windows(2).map(|w| w[0].distance(w[1])).collect();
+        assert!(distances_neighbors
+            .windows(2)
+            .all(|w| (w[0] - w[1]).abs() < epsilon));
+    }
+}