├── .gitignore
├── Cargo.toml
├── LICENSE
├── README.md
├── .github
    └── workflows
    │   └── rust.yml
├── examples
    └── demo.rs
└── src
    ├── lib.rs
    ├── sphere.rs
    ├── aabb.rs
    ├── obb.rs
    └── debug.rs


/.gitignore:
--------------------------------------------------------------------------------
1 | /target
2 | Cargo.lock
3 | .cargo/config
4 | .cargo/config.toml
5 | .vscode
6 | .cargo/credentials.toml
7 | .cargo/config_fast_compile
8 | **/trace-*.json


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "bevy_mod_bounding"
 3 | version = "0.1.2-alpha.0"
 4 | authors = ["Aevyrie Roessler <aevyrie@gmail.com>"]
 5 | edition = "2018"
 6 | license = "MIT"
 7 | description = "Bounding box generation for the Bevy Engine."
 8 | repository = "https://github.com/aevyrie/bevy_mod_bounding/"
 9 | keywords = ["gamedev", "graphics", "bevy", "3d", "bounding"]
10 | categories = ["game-engines", "rendering"]
11 | resolver = "2"
12 | 
13 | [dependencies]
14 | bevy = { git = "https://github.com/bevyengine/bevy", branch = "main", version = "0.5" }
15 | 
16 | [[example]]
17 | name = "demo"
18 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 Aevyrie
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Bounding Box Generation for Bevy
 2 | 
 3 | [![CI](https://github.com/aevyrie/bevy_mod_bounding/workflows/CI/badge.svg?branch=master)](https://github.com/aevyrie/bevy_mod_bounding/actions?query=workflow%3A%22CI%22+branch%3Amaster)
 4 | [![crates.io](https://img.shields.io/crates/v/bevy_mod_bounding)](https://crates.io/crates/bevy_mod_bounding)
 5 | [![docs.rs](https://docs.rs/bevy_mod_bounding/badge.svg)](https://docs.rs/bevy_mod_bounding)
 6 | [![Bevy tracking](https://img.shields.io/badge/Bevy%20tracking-main-lightblue)](https://github.com/bevyengine/bevy/blob/main/docs/plugins_guidelines.md#main-branch-tracking)
 7 | 
 8 | Unofficial plugin for generating bounding volumes.
 9 | 
10 | ![demo](https://user-images.githubusercontent.com/2632925/114147530-a4785800-98cd-11eb-9395-7a0522e117a2.gif)
11 | 
12 | ## Status
13 | 
14 | | Status | Bounding Volume |
15 | |:-:|----------------------------|
16 | | ✅ | Bounding Sphere            |
17 | | ✅ | Axis Aligned Bounding Box  |
18 | | ✅ | Oriented Bounding Box      |
19 | 
20 | ## Example
21 | 
22 | Run the demo with:
23 | 
24 | ```shell
25 | cargo run --features ex --example demo
26 | ```
27 | 
28 | ## Bevy Version Support
29 | 
30 | I intend to track the `main` branch of Bevy. PRs supporting this are welcome! 
31 | 
32 | |bevy|bevy_mod_bounding|
33 | |---|---|
34 | |0.5|0.1|
35 | 
36 | # License
37 | 
38 | This project is licensed under the [MIT license](https://github.com/aevyrie/bevy_mod_bounding/blob/master/LICENSE).
39 | 
40 | ## Contribution
41 | 
42 | Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in bevy_mod_bounding by you, shall be licensed as MIT, without any additional terms or conditions.
43 | 


--------------------------------------------------------------------------------
/.github/workflows/rust.yml:
--------------------------------------------------------------------------------
  1 | on: 
  2 |   pull_request:
  3 |   push:
  4 |     branches:
  5 |       - master
  6 | 
  7 | name: CI
  8 | 
  9 | jobs:
 10 |   check:
 11 |     name: Check
 12 |     runs-on: ubuntu-latest
 13 |     steps:
 14 |       - name: Install alsa
 15 |         run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev
 16 |         if: ${{ runner.os == 'Linux' }}
 17 |         
 18 |       - name: Install udev
 19 |         run: sudo apt-get update; sudo apt-get install --no-install-recommends libudev-dev
 20 |         if: ${{ runner.os == 'Linux' }}
 21 | 
 22 |       - uses: actions/checkout@v2
 23 |       - uses: actions-rs/toolchain@v1
 24 |         with:
 25 |           profile: minimal
 26 |           toolchain: stable
 27 |           override: true
 28 |       - uses: actions-rs/cargo@v1
 29 |         with:
 30 |           command: check
 31 | 
 32 |   test:
 33 |     name: Test Suite
 34 |     runs-on: ubuntu-latest
 35 |     steps:
 36 |       - name: Install alsa
 37 |         run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev
 38 |         if: ${{ runner.os == 'Linux' }}
 39 |         
 40 |       - name: Install udev
 41 |         run: sudo apt-get update; sudo apt-get install --no-install-recommends libudev-dev
 42 |         if: ${{ runner.os == 'Linux' }}
 43 | 
 44 |       - uses: actions/checkout@v2
 45 |       - uses: actions-rs/toolchain@v1
 46 |         with:
 47 |           profile: minimal
 48 |           toolchain: stable
 49 |           override: true
 50 |       - uses: actions-rs/cargo@v1
 51 |         with:
 52 |           command: test
 53 | 
 54 |   fmt:
 55 |     name: Rustfmt
 56 |     runs-on: ubuntu-latest
 57 |     steps:
 58 |       - name: Install alsa
 59 |         run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev
 60 |         if: ${{ runner.os == 'Linux' }}
 61 |       
 62 |       - name: Install udev
 63 |         run: sudo apt-get update; sudo apt-get install --no-install-recommends libudev-dev
 64 |         if: ${{ runner.os == 'Linux' }}
 65 | 
 66 |       - uses: actions/checkout@v2
 67 |       - uses: actions-rs/toolchain@v1
 68 |         with:
 69 |           profile: minimal
 70 |           toolchain: stable
 71 |           override: true
 72 |       - run: rustup component add rustfmt
 73 |       - uses: actions-rs/cargo@v1
 74 |         with:
 75 |           command: fmt
 76 |           args: --all -- --check
 77 | 
 78 |   clippy:
 79 |     name: Clippy
 80 |     runs-on: ubuntu-latest
 81 |     steps:
 82 |       - name: Install alsa
 83 |         run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev
 84 |         if: ${{ runner.os == 'Linux' }}
 85 |       
 86 |       - name: Install udev
 87 |         run: sudo apt-get update; sudo apt-get install --no-install-recommends libudev-dev
 88 |         if: ${{ runner.os == 'Linux' }}
 89 | 
 90 |       - uses: actions/checkout@v2
 91 |       - uses: actions-rs/toolchain@v1
 92 |         with:
 93 |           profile: minimal
 94 |           toolchain: stable
 95 |           override: true
 96 |       - run: rustup component add clippy
 97 |       - uses: actions-rs/cargo@v1
 98 |         with:
 99 |           command: clippy
100 |           args: -- -D warnings
101 | 


--------------------------------------------------------------------------------
/examples/demo.rs:
--------------------------------------------------------------------------------
 1 | use bevy::prelude::*;
 2 | use bevy_mod_bounding::{aabb, debug, obb, *};
 3 | 
 4 | fn main() {
 5 |     App::new()
 6 |         .insert_resource(Msaa { samples: 2 })
 7 |         .add_plugins(DefaultPlugins)
 8 |         .add_plugin(BoundingVolumePlugin::<sphere::BSphere>::default())
 9 |         .add_plugin(BoundingVolumePlugin::<aabb::Aabb>::default())
10 |         .add_plugin(BoundingVolumePlugin::<obb::Obb>::default())
11 |         .add_startup_system(setup.system())
12 |         .add_system(rotation_system.system())
13 |         .run();
14 | }
15 | 
16 | #[derive(Component)]
17 | struct Rotator;
18 | 
19 | fn setup(
20 |     mut commands: Commands,
21 |     mut meshes: ResMut<Assets<Mesh>>,
22 |     mut materials: ResMut<Assets<StandardMaterial>>,
23 | ) {
24 |     let mut ortho_cam = OrthographicCameraBundle::new_3d();
25 |     ortho_cam.transform = Transform::from_matrix(Mat4::face_toward(
26 |         Vec3::new(0.1, 0.1, 1.0),
27 |         Vec3::ZERO,
28 |         Vec3::Y,
29 |     ));
30 |     commands.spawn_bundle(ortho_cam);
31 |     // AABB
32 |     commands
33 |         .spawn_bundle(PbrBundle {
34 |             mesh: meshes.add(Mesh::from(shape::Cube::default())),
35 |             material: materials.add(Color::rgb(1.0, 1.0, 1.0).into()),
36 |             transform: Transform::from_translation(Vec3::new(-1.0, 0.0, 0.0)),
37 |             ..Default::default()
38 |         })
39 |         .insert(Bounded::<aabb::Aabb>::default())
40 |         .insert(debug::DebugBounds)
41 |         .insert(Rotator);
42 |     // OBB
43 |     commands
44 |         .spawn_bundle(PbrBundle {
45 |             mesh: meshes.add(Mesh::from(shape::Cube::default())),
46 |             material: materials.add(Color::rgb(1.0, 1.0, 1.0).into()),
47 |             transform: Transform::from_translation(Vec3::new(0.0, 0.0, 0.0)),
48 |             ..Default::default()
49 |         })
50 |         .insert(Bounded::<obb::Obb>::default())
51 |         .insert(debug::DebugBounds)
52 |         .insert(Rotator);
53 |     // Sphere
54 |     commands
55 |         .spawn_bundle(PbrBundle {
56 |             mesh: meshes.add(Mesh::from(shape::Cube::default())),
57 |             material: materials.add(Color::rgb(1.0, 1.0, 1.0).into()),
58 |             transform: Transform::from_translation(Vec3::new(1.0, 0.0, 0.0)),
59 |             ..Default::default()
60 |         })
61 |         .insert(Bounded::<sphere::BSphere>::default())
62 |         .insert(debug::DebugBounds)
63 |         .insert(Rotator);
64 |     // Light
65 |     commands.spawn_bundle(PointLightBundle {
66 |         transform: Transform::from_translation(Vec3::new(4.0, 8.0, 4.0)),
67 |         ..Default::default()
68 |     });
69 | }
70 | 
71 | /// Rotate the meshes to demonstrate how the bounding volumes update
72 | fn rotation_system(time: Res<Time>, mut query: Query<&mut Transform, With<Rotator>>) {
73 |     for mut transform in query.iter_mut() {
74 |         let scale = Vec3::ONE * ((time.seconds_since_startup() as f32).sin() * 0.3 + 1.0) * 0.3;
75 |         let rot_x = Quat::from_rotation_x((time.seconds_since_startup() as f32 / 5.0).sin() / 50.0);
76 |         let rot_y = Quat::from_rotation_y((time.seconds_since_startup() as f32 / 3.0).sin() / 50.0);
77 |         let rot_z = Quat::from_rotation_z((time.seconds_since_startup() as f32 / 4.0).sin() / 50.0);
78 |         transform.scale = scale;
79 |         transform.rotate(rot_x * rot_y * rot_z);
80 |     }
81 | }
82 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
  1 | pub mod aabb;
  2 | pub mod debug;
  3 | pub mod obb;
  4 | pub mod sphere;
  5 | 
  6 | use bevy::{prelude::*, transform::TransformSystem};
  7 | use debug::{update_debug_mesh_visibility, update_debug_meshes};
  8 | use std::fmt::Debug;
  9 | use std::marker::PhantomData;
 10 | 
 11 | #[derive(Debug, Hash, PartialEq, Eq, Clone, SystemLabel)]
 12 | pub enum BoundingSystem {
 13 |     UpdateBounds,
 14 |     UpdateDebug,
 15 |     UpdateDebugVisibility,
 16 | }
 17 | 
 18 | #[derive(Default)]
 19 | pub struct BoundingVolumePlugin<T: BoundingVolume> {
 20 |     marker: std::marker::PhantomData<T>,
 21 | }
 22 | 
 23 | /// A plugin that provides functionality for generating and updating bounding volumes for meshes.
 24 | impl<T> Plugin for BoundingVolumePlugin<T>
 25 | where
 26 |     T: 'static + Send + Sync + BoundingVolume + Clone + Debug + Component,
 27 |     Mesh: From<&'static T>,
 28 | {
 29 |     fn build(&self, app: &mut App) {
 30 |         app.add_system_to_stage(CoreStage::PreUpdate, spawn::<T>.system())
 31 |             .add_system_to_stage(
 32 |                 CoreStage::PostUpdate,
 33 |                 update::<T>
 34 |                     .system()
 35 |                     .after(TransformSystem::TransformPropagate)
 36 |                     .label(BoundingSystem::UpdateBounds),
 37 |             )
 38 |             .add_system_to_stage(
 39 |                 CoreStage::PostUpdate,
 40 |                 update_debug_meshes::<T>
 41 |                     .system()
 42 |                     .after(BoundingSystem::UpdateBounds)
 43 |                     .label(BoundingSystem::UpdateDebug),
 44 |             )
 45 |             .add_system_to_stage(
 46 |                 CoreStage::PostUpdate,
 47 |                 update_debug_mesh_visibility::<T>
 48 |                     .system()
 49 |                     .after(BoundingSystem::UpdateDebug)
 50 |                     .before(bevy::render::RenderSystem::VisibleEntities),
 51 |             );
 52 |     }
 53 | }
 54 | 
 55 | /// Marks an entity to have a bounding volume generated. This entity should have a [Mesh]
 56 | /// component. A bounding volume component of type T will be computed and added to the entity once
 57 | /// the aforementioned mesh has loaded and can be read. This ensures that bounding volume
 58 | /// components are always valid when queried, and at worst case can only be out of date if queried
 59 | /// in a frame before the bounding volume update system is run.
 60 | #[derive(Debug, Clone, Component)]
 61 | pub struct Bounded<T: BoundingVolume + Send + Sync>(PhantomData<T>);
 62 | 
 63 | impl<T: BoundingVolume + Send + Sync> Default for Bounded<T> {
 64 |     fn default() -> Self {
 65 |         Bounded(PhantomData::default())
 66 |     }
 67 | }
 68 | 
 69 | /// A [BoundingVolume] stores its properties in mesh space to maximize precision. Because some types
 70 | /// of bounding volume must be recomputed if the mesh is scaled or rotated, this trait calls an
 71 | /// update function depending on whether the mesh or transform has updated.
 72 | pub trait BoundingVolume {
 73 |     /// Initializes a valid bounding volume given a [Mesh] and [GlobalTransform].
 74 |     fn new(mesh: &Mesh, transform: &GlobalTransform) -> Self;
 75 |     /// Generate a debug [Mesh] representing the bounding volume from a [BoundingVolume].
 76 |     fn new_debug_mesh(&self, transform: &GlobalTransform) -> Mesh;
 77 |     /// This function is only called when only the entity's [GlobalTransform] has changed. Only
 78 |     /// some types of bounding volume need to be recomputed in this case.
 79 |     fn update_on_transform_change(
 80 |         &self,
 81 |         _mesh: &Mesh,
 82 |         _transform: &GlobalTransform,
 83 |     ) -> Option<Self>
 84 |     where
 85 |         Self: Sized;
 86 |     /// Returns true iff the bounding mesh is entirely on the outside of the supplied plane.
 87 |     /// "Outside" is the direction that the plane normal points to.
 88 |     fn outside_plane(
 89 |         &self,
 90 |         bound_vol_position: &GlobalTransform,
 91 |         point: Vec3,
 92 |         normal: Vec3,
 93 |     ) -> bool;
 94 | }
 95 | 
 96 | /// Spawns a new [BoundingVolume], replacing the [AddBoundingVolume] marker component on the
 97 | /// entity. This new BoundingVolume is fully initialized and will be kept up to date with the
 98 | /// `update()` system.
 99 | #[allow(clippy::type_complexity)]
100 | pub fn spawn<T: 'static + BoundingVolume + Send + Sync + Debug + Component>(
101 |     mut commands: Commands,
102 |     meshes: Res<Assets<Mesh>>,
103 |     query: Query<(&Handle<Mesh>, &GlobalTransform, Entity), With<Bounded<T>>>,
104 | ) {
105 |     for (handle, transform, entity) in query.iter() {
106 |         if let Some(mesh) = meshes.get(handle) {
107 |             let new_bound = T::new(mesh, transform);
108 |             info!("New bounding volume generated: {:?}", new_bound);
109 |             commands
110 |                 .entity(entity)
111 |                 .insert(new_bound)
112 |                 .remove::<Bounded<T>>();
113 |         }
114 |     }
115 | }
116 | 
117 | /// Updates [BoundingVolume]s when their meshes or [GlobalTransform]s are changed. If an entity's
118 | /// mesh has changed, triggering a bounding volume update, the update function will won't update it
119 | /// a second time if the transform has also changed.
120 | fn update<T: 'static + BoundingVolume + Send + Sync + Component>(
121 |     meshes: Res<Assets<Mesh>>,
122 |     changed_mesh_query: Query<Entity, Changed<Handle<Mesh>>>,
123 |     changed_transform_query: Query<Entity, Changed<GlobalTransform>>,
124 |     mut bound_vol_query: Query<(&mut T, &GlobalTransform, &Handle<Mesh>)>,
125 | ) {
126 |     for entity in changed_mesh_query.iter() {
127 |         if let Ok((mut bounding_vol, transform, handle)) = bound_vol_query.get_mut(entity) {
128 |             if let Some(mesh) = meshes.get(handle) {
129 |                 *bounding_vol = T::new(mesh, transform);
130 |             }
131 |         }
132 |     }
133 |     for entity in changed_transform_query.iter() {
134 |         // Only process entities that haven't already been updated.
135 |         if changed_mesh_query.get(entity).is_err() {
136 |             if let Ok((mut bounding_vol, transform, handle)) = bound_vol_query.get_mut(entity) {
137 |                 if let Some(mesh) = meshes.get(handle) {
138 |                     if let Some(bound_vol) =
139 |                         bounding_vol.update_on_transform_change(mesh, transform)
140 |                     {
141 |                         *bounding_vol = bound_vol;
142 |                     }
143 |                 }
144 |             }
145 |         }
146 |     }
147 | }
148 | 


--------------------------------------------------------------------------------
/src/sphere.rs:
--------------------------------------------------------------------------------
  1 | use crate::BoundingVolume;
  2 | use bevy::{
  3 |     prelude::*,
  4 |     render::{mesh::VertexAttributeValues, pipeline::PrimitiveTopology},
  5 | };
  6 | use core::panic;
  7 | 
  8 | /// Defines a bounding sphere with a radius and an origin at the center.
  9 | #[derive(Debug, Clone, Default, Component)]
 10 | pub struct BSphere {
 11 |     /// Origin of the sphere in mesh space. The intent is that the bounding volume will be queried
 12 |     /// along with its [GlobalTransform], so the origin of the sphere will be transformed to the
 13 |     /// world position of the mesh, and the radius can be used to determine the bounding volume.
 14 |     mesh_space_origin: Vec3,
 15 |     /// Radius of the sphere that bounds the mesh, in mesh space.
 16 |     mesh_space_radius: f32,
 17 | }
 18 | impl BSphere {
 19 |     /// Given the current [GlobalTransform] of the bounded mesh, returns the central origin of the
 20 |     /// sphere that bounds the mesh in world space.
 21 |     pub fn origin(&self, transform: GlobalTransform) -> Vec3 {
 22 |         self.mesh_space_origin + transform.translation
 23 |     }
 24 |     /// Given the current [GlobalTransform] of the bounded mesh, returns the radius of the sphere
 25 |     /// that bounds the mesh in world space.
 26 |     pub fn radius(&self, transform: &GlobalTransform) -> f32 {
 27 |         self.mesh_space_radius * transform.scale.max_element()
 28 |     }
 29 |     /// Get a reference to the b sphere's mesh space origin.
 30 |     pub fn mesh_space_origin(&self) -> &Vec3 {
 31 |         &self.mesh_space_origin
 32 |     }
 33 |     /// Get a reference to the b sphere's mesh space radius.
 34 |     pub fn mesh_space_radius(&self) -> &f32 {
 35 |         &self.mesh_space_radius
 36 |     }
 37 | }
 38 | 
 39 | /// Create a valid boundary sphere from a mesh and globaltransform.
 40 | impl BoundingVolume for BSphere {
 41 |     fn new(mesh: &Mesh, _transform: &GlobalTransform) -> Self {
 42 |         // Grab a vector of vertex coordinates we can use to iterate through
 43 |         if mesh.primitive_topology() != PrimitiveTopology::TriangleList {
 44 |             panic!("Non-TriangleList mesh supplied for bounding sphere generation")
 45 |         }
 46 |         let vertices: Vec<Vec3> = match mesh.attribute(Mesh::ATTRIBUTE_POSITION) {
 47 |             None => panic!("Mesh does not contain vertex positions"),
 48 |             Some(vertex_values) => match &vertex_values {
 49 |                 VertexAttributeValues::Float32x3(positions) => positions
 50 |                     .iter()
 51 |                     .map(|coordinates| Vec3::from(*coordinates))
 52 |                     .collect(),
 53 |                 _ => panic!("Unexpected vertex types in ATTRIBUTE_POSITION"),
 54 |             },
 55 |         };
 56 |         let point_x = vertices[0];
 57 |         // Find point y, the point furthest from point x
 58 |         let point_y = vertices.iter().fold(point_x, |acc, x| {
 59 |             if x.distance(point_x) >= acc.distance(point_x) {
 60 |                 *x
 61 |             } else {
 62 |                 acc
 63 |             }
 64 |         });
 65 |         // Find point z, the point furthest from point y
 66 |         let point_z = vertices.iter().fold(point_y, |acc, x| {
 67 |             if x.distance(point_y) >= acc.distance(point_y) {
 68 |                 *x
 69 |             } else {
 70 |                 acc
 71 |             }
 72 |         });
 73 |         // Construct a bounding sphere using these two points as the poles
 74 |         let mut sphere = BSphere {
 75 |             mesh_space_origin: point_y.lerp(point_z, 0.5),
 76 |             mesh_space_radius: point_y.distance(point_z) / 2.0,
 77 |         };
 78 |         // Iteratively adjust sphere until it encloses all points
 79 |         loop {
 80 |             // Find the furthest point from the origin
 81 |             let point_n = vertices.iter().fold(point_x, |acc, x| {
 82 |                 if x.distance(sphere.mesh_space_origin) >= acc.distance(sphere.mesh_space_origin) {
 83 |                     *x
 84 |                 } else {
 85 |                     acc
 86 |                 }
 87 |             });
 88 |             // If the furthest point is outside the sphere, we need to adjust it
 89 |             let point_dist = point_n.distance(sphere.mesh_space_origin);
 90 |             if point_dist > sphere.mesh_space_radius {
 91 |                 let radius_new = (sphere.mesh_space_radius + point_dist) / 2.0;
 92 |                 let lerp_ratio = (point_dist - radius_new) / point_dist;
 93 |                 sphere = BSphere {
 94 |                     mesh_space_origin: sphere.mesh_space_origin.lerp(point_n, lerp_ratio),
 95 |                     mesh_space_radius: radius_new,
 96 |                 };
 97 |             } else {
 98 |                 return sphere;
 99 |             }
100 |         }
101 |     }
102 | 
103 |     /// Generate a debug mesh, and apply the inverse transform. Because the debug mesh is a child,
104 |     /// the transform of the parent will be applied to it. This needs to be negated so the bounding
105 |     /// circle debug mesh isn't warped.
106 |     fn new_debug_mesh(&self, transform: &GlobalTransform) -> Mesh {
107 |         let mut mesh = Mesh::from(self);
108 |         let inverse_transform = Transform::from_matrix(
109 |             Mat4::from_scale_rotation_translation(Vec3::ONE, transform.rotation, Vec3::ZERO)
110 |                 .inverse(),
111 |         );
112 |         match mesh.attribute_mut(Mesh::ATTRIBUTE_POSITION) {
113 |             None => panic!("Mesh does not contain vertex positions"),
114 |             Some(vertex_values) => match vertex_values {
115 |                 VertexAttributeValues::Float32x3(ref mut positions) => {
116 |                     *positions = positions
117 |                         .iter()
118 |                         .map(|coordinates| {
119 |                             inverse_transform.mul_vec3(Vec3::from(*coordinates)).into()
120 |                         })
121 |                         .collect()
122 |                 }
123 |                 _ => panic!("Unexpected vertex types in ATTRIBUTE_POSITION"),
124 |             },
125 |         };
126 |         mesh
127 |     }
128 | 
129 |     fn update_on_transform_change(&self, mesh: &Mesh, transform: &GlobalTransform) -> Option<Self> {
130 |         Some(Self::new(mesh, transform))
131 |     }
132 | 
133 |     fn outside_plane(
134 |         &self,
135 |         bound_vol_position: &GlobalTransform,
136 |         point: Vec3,
137 |         normal: Vec3,
138 |     ) -> bool {
139 |         normal.dot(self.origin(*bound_vol_position)) + -normal.dot(point)
140 |             - self.radius(bound_vol_position)
141 |             > 0.0
142 |     }
143 | }
144 | 


--------------------------------------------------------------------------------
/src/aabb.rs:
--------------------------------------------------------------------------------
  1 | use crate::BoundingVolume;
  2 | use bevy::{
  3 |     prelude::*,
  4 |     render::{mesh::VertexAttributeValues, pipeline::PrimitiveTopology},
  5 | };
  6 | use core::panic;
  7 | 
  8 | /// Defines an axis-aligned bounding box in mesh space - that is - the bounding box is located at
  9 | /// the mesh's origin, but the current [GlobalTransform] has been used to rotate and scale the mesh
 10 | /// to compute a valid AABB. This reduces float error when the mesh is located far from the origin.
 11 | #[derive(Debug, Clone, Default, Component)]
 12 | pub struct Aabb {
 13 |     /// The coordinates of the point located at the minimum x, y, and z coordinate. This can also
 14 |     /// be thought of as the length of the -x, -y, -z axes that extend from the origin and touch
 15 |     /// the inside of the bounding box faces.
 16 |     minimums: Vec3,
 17 |     /// The coordinates of the point located at the maximum x, y, and z coordinate. This can also
 18 |     /// be thought of as the length of the +x, +y, +z axes that extend from the origin and touch
 19 |     /// the inside of the bounding box faces.
 20 |     maximums: Vec3,
 21 | }
 22 | impl Aabb {
 23 |     /// Returns the distance from the origin of the mesh to the negative extents of the bounding
 24 |     /// box in world space, aligned with the world axes. I.e.: distance from the mesh origin to the
 25 |     /// faces of the bounding box in the -x, -y, -z world axis directions.
 26 |     pub fn minimums(&self) -> Vec3 {
 27 |         self.minimums
 28 |     }
 29 |     /// Returns the distance from the origin of the mesh to the positive extents of the bounding
 30 |     /// box in world space, aligned with the world axes. I.e.: distance from the mesh origin to the
 31 |     /// faces of the bounding box in the +x, +y, +z world axis directions.
 32 |     pub fn maximums(&self) -> Vec3 {
 33 |         self.maximums
 34 |     }
 35 |     /// Returns the vertices of the bounding box in world space, given the current mesh transform.
 36 |     pub fn vertices(&self, transform: GlobalTransform) -> [Vec3; 8] {
 37 |         let vertices_mesh_space = self.vertices_mesh_space();
 38 |         [
 39 |             transform.translation + vertices_mesh_space[0],
 40 |             transform.translation + vertices_mesh_space[1],
 41 |             transform.translation + vertices_mesh_space[2],
 42 |             transform.translation + vertices_mesh_space[3],
 43 |             transform.translation + vertices_mesh_space[4],
 44 |             transform.translation + vertices_mesh_space[5],
 45 |             transform.translation + vertices_mesh_space[6],
 46 |             transform.translation + vertices_mesh_space[7],
 47 |         ]
 48 |     }
 49 |     pub fn vertices_mesh_space(&self) -> [Vec3; 8] {
 50 |         /*
 51 |               (2)-----(3)               Y
 52 |                | \     | \              |
 53 |                |  (1)-----(0) MAX       o---X
 54 |                |   |   |   |             \
 55 |           MIN (6)--|--(7)  |              Z
 56 |                  \ |     \ |
 57 |                   (5)-----(4)
 58 |         */
 59 |         [
 60 |             Vec3::new(self.maximums.x, self.maximums.y, self.maximums.z),
 61 |             Vec3::new(self.minimums.x, self.maximums.y, self.maximums.z),
 62 |             Vec3::new(self.minimums.x, self.maximums.y, self.minimums.z),
 63 |             Vec3::new(self.maximums.x, self.maximums.y, self.minimums.z),
 64 |             Vec3::new(self.maximums.x, self.minimums.y, self.maximums.z),
 65 |             Vec3::new(self.minimums.x, self.minimums.y, self.maximums.z),
 66 |             Vec3::new(self.minimums.x, self.minimums.y, self.minimums.z),
 67 |             Vec3::new(self.maximums.x, self.minimums.y, self.minimums.z),
 68 |         ]
 69 |     }
 70 |     pub fn from_extents(minimums: Vec3, maximums: Vec3) -> Self {
 71 |         Aabb { minimums, maximums }
 72 |     }
 73 |     /// Given a set of points, fit an axis oriented bounding box to the vertices by finding the
 74 |     /// extents of the mesh.
 75 |     pub fn compute_aabb(vertices: &[Vec3]) -> Aabb {
 76 |         let mut maximums = Vec3::new(f32::MIN, f32::MIN, f32::MIN);
 77 |         let mut minimums = Vec3::new(f32::MAX, f32::MAX, f32::MAX);
 78 |         for vertex in vertices.iter() {
 79 |             maximums = vertex.max(maximums);
 80 |             minimums = vertex.min(minimums);
 81 |         }
 82 |         Aabb { minimums, maximums }
 83 |     }
 84 | }
 85 | 
 86 | impl BoundingVolume for Aabb {
 87 |     fn new(mesh: &Mesh, transform: &GlobalTransform) -> Self {
 88 |         let transform_matrix = Transform {
 89 |             translation: Vec3::ZERO,
 90 |             rotation: transform.rotation,
 91 |             scale: transform.scale,
 92 |         }
 93 |         .compute_matrix();
 94 |         // Grab a vector of vertex coordinates we can use to iterate through
 95 |         if mesh.primitive_topology() != PrimitiveTopology::TriangleList {
 96 |             panic!("Non-TriangleList mesh supplied for bounding box generation")
 97 |         }
 98 |         let vertices: Vec<Vec3> = match mesh.attribute(Mesh::ATTRIBUTE_POSITION) {
 99 |             None => panic!("Mesh does not contain vertex positions"),
100 |             Some(vertex_values) => match &vertex_values {
101 |                 VertexAttributeValues::Float32x3(positions) => positions
102 |                     .iter()
103 |                     .map(|coordinates| transform_matrix.transform_point3(Vec3::from(*coordinates)))
104 |                     .collect(),
105 |                 _ => panic!("Unexpected vertex types in ATTRIBUTE_POSITION"),
106 |             },
107 |         };
108 |         Self::compute_aabb(&vertices)
109 |     }
110 | 
111 |     fn new_debug_mesh(&self, transform: &GlobalTransform) -> Mesh {
112 |         let mut mesh = Mesh::from(self);
113 |         let inverse_transform = Transform::from_matrix(
114 |             Mat4::from_scale_rotation_translation(transform.scale, transform.rotation, Vec3::ZERO)
115 |                 .inverse(),
116 |         );
117 |         match mesh.attribute_mut(Mesh::ATTRIBUTE_POSITION) {
118 |             None => panic!("Mesh does not contain vertex positions"),
119 |             Some(vertex_values) => match vertex_values {
120 |                 VertexAttributeValues::Float32x3(ref mut positions) => {
121 |                     *positions = positions
122 |                         .iter()
123 |                         .map(|coordinates| {
124 |                             inverse_transform.mul_vec3(Vec3::from(*coordinates)).into()
125 |                         })
126 |                         .collect()
127 |                 }
128 |                 _ => panic!("Unexpected vertex types in ATTRIBUTE_POSITION"),
129 |             },
130 |         };
131 |         mesh
132 |     }
133 | 
134 |     fn update_on_transform_change(&self, mesh: &Mesh, transform: &GlobalTransform) -> Option<Self> {
135 |         Some(Self::new(mesh, transform))
136 |     }
137 | 
138 |     fn outside_plane(
139 |         &self,
140 |         bound_vol_position: &GlobalTransform,
141 |         point: Vec3,
142 |         normal: Vec3,
143 |     ) -> bool {
144 |         for vertex in self.vertices(*bound_vol_position).iter() {
145 |             if normal.dot(*vertex) + -normal.dot(point) < 0.0 {
146 |                 // if any point is on the inside of the plane, we can end early.
147 |                 return false;
148 |             }
149 |         }
150 |         true
151 |     }
152 | }
153 | 


--------------------------------------------------------------------------------
/src/obb.rs:
--------------------------------------------------------------------------------
  1 | use crate::aabb::Aabb;
  2 | use crate::BoundingVolume;
  3 | use bevy::{
  4 |     prelude::*,
  5 |     render::{mesh::VertexAttributeValues, pipeline::PrimitiveTopology},
  6 | };
  7 | use core::panic;
  8 | use std::{convert::TryInto, f32::consts::PI};
  9 | 
 10 | /// Defines a bounding box, oriented to minimize the bounded volume. This bounding box is expensive
 11 | /// to compute, but cheap to update.
 12 | ///
 13 | /// The volume of an OBB is <= to the AABB of the same mesh. It is similar to an AABB, but the
 14 | /// orientation is determined not by the world axes but with respect to the mesh itself, so the
 15 | /// bounding box definition only changes if the underlying mesh changes. The entire bounding volume
 16 | /// can simply be transformed with the current [GlobalTransform] of the bounded mesh, lazily.
 17 | ///
 18 | /// This structure stores the AABB of the mesh in mesh space, with the mesh oriented to minimize
 19 | /// the volume of the bounding box. The properties are stored in mesh space to minimize rounding
 20 | /// error, and make it easy to defer recomputing the bounding volume until the mesh itself is
 21 | /// changed.
 22 | #[derive(Debug, Clone, Default, Component)]
 23 | pub struct Obb {
 24 |     aabb: Aabb,
 25 |     /// The orientation of the mesh that minimizes the AABB.
 26 |     ///
 27 |     /// ## Note
 28 |     /// This is *not* the orientation of the bounding box! You probably want the conjugate of
 29 |     /// this quaternion if that's what you need.
 30 |     mesh_orientation: Quat,
 31 | }
 32 | 
 33 | impl Obb {
 34 |     /// Returns an array of the 8 vertices of the bounding box in world space.
 35 |     pub fn vertices(&self, transform: GlobalTransform) -> [Vec3; 8] {
 36 |         let orient = Mat4::from_quat(self.orientation());
 37 |         let transform = transform.compute_matrix() * orient;
 38 |         let transform = GlobalTransform::from_matrix(transform);
 39 |         self.aabb
 40 |             .vertices_mesh_space()
 41 |             .iter()
 42 |             .map(|&vertex| transform * vertex)
 43 |             .collect::<Vec<Vec3>>()
 44 |             .as_slice()
 45 |             .try_into()
 46 |             .unwrap()
 47 |     }
 48 |     pub fn vertices_mesh_space(&self) -> [Vec3; 8] {
 49 |         let orient = Mat4::from_quat(self.orientation());
 50 |         let transform = GlobalTransform::from_matrix(orient);
 51 |         self.aabb.vertices(transform)
 52 |     }
 53 |     pub fn from_aabb_orientation(aabb: Aabb, mesh_orientation: Quat) -> Obb {
 54 |         Obb {
 55 |             aabb,
 56 |             mesh_orientation,
 57 |         }
 58 |     }
 59 |     /// Returns the [AxisAlignedBB] of this [OrientedBB] in ***mesh space***.
 60 |     pub fn mesh_aabb(&self) -> &Aabb {
 61 |         &self.aabb
 62 |     }
 63 |     /// Returns the orientation of the [OrientedBB] in ***mesh space***.
 64 |     ///
 65 |     /// ## Note
 66 |     /// This orientation tells you how to rotate the [AxisAlignedBB] that defines the [OrientedBB]
 67 |     /// so that the bounding box matches its [Mesh]s orientation.
 68 |     pub fn orientation(&self) -> Quat {
 69 |         self.mesh_orientation.conjugate()
 70 |     }
 71 |     /// Returns an [AxisAlignedBB] that contains this [OrientedBB]. In other words, this returns
 72 |     /// the AABB of this OBB.
 73 |     ///
 74 |     /// ## Y tho
 75 |     /// This is much faster than calculating the AABB of a high-poly mesh every time it moves.
 76 |     /// Because the [OrientedBB] only needs to recompute when the mesh itself changes, by taking
 77 |     /// the AABB of the OBB, and not the mesh, we only need to iterate through all mesh vertices
 78 |     /// when the mesh changes, but we still get a bounding box that is aligned to the world axes.
 79 |     /// This comes with a tradeoff - because we are finding the AABB of the OBB, the bounding box
 80 |     /// will be more conservative, and will be larger than the AABB of the mesh itself.
 81 |     pub fn outer_aabb(&self) -> Aabb {
 82 |         let axis_aligned_vertices = self.aabb.vertices_mesh_space();
 83 |         let oriented_vertices: Vec<Vec3> = axis_aligned_vertices
 84 |             .iter()
 85 |             .map(|vertex| self.orientation().mul_vec3(*vertex))
 86 |             .collect();
 87 |         Aabb::compute_aabb(&oriented_vertices)
 88 |     }
 89 |     /// Given a list of mesh vertices, and the orientation of this mesh, constructs an oriented
 90 |     /// bounding box.
 91 |     fn compute_obb(vertices: &[Vec3], orientation: Quat) -> Obb {
 92 |         let mut maximums = Vec3::new(f32::MIN, f32::MIN, f32::MIN);
 93 |         let mut minimums = Vec3::new(f32::MAX, f32::MAX, f32::MAX);
 94 |         let transform = Mat4::from_quat(orientation);
 95 |         for vertex in vertices.iter() {
 96 |             maximums = maximums.max(transform.transform_point3(*vertex));
 97 |             minimums = minimums.min(transform.transform_point3(*vertex));
 98 |         }
 99 |         Obb {
100 |             aabb: Aabb::from_extents(minimums, maximums),
101 |             mesh_orientation: orientation,
102 |         }
103 |     }
104 | }
105 | 
106 | impl BoundingVolume for Obb {
107 |     fn new(mesh: &Mesh, _transform: &GlobalTransform) -> Self {
108 |         // Grab a vector of vertex coordinates we can use to iterate through
109 |         if mesh.primitive_topology() != PrimitiveTopology::TriangleList {
110 |             panic!("Non-TriangleList mesh supplied for oriented bounding box generation")
111 |         }
112 |         let vertices: Vec<Vec3> = match mesh.attribute(Mesh::ATTRIBUTE_POSITION) {
113 |             None => panic!("Mesh does not contain vertex positions"),
114 |             Some(vertex_values) => match &vertex_values {
115 |                 VertexAttributeValues::Float32x3(positions) => positions
116 |                     .iter()
117 |                     .map(|coordinates| Vec3::from(*coordinates))
118 |                     .collect(),
119 |                 _ => panic!("Unexpected vertex types in ATTRIBUTE_POSITION"),
120 |             },
121 |         };
122 | 
123 |         let mut orientation = Quat::IDENTITY;
124 |         let mut volume = f32::MAX;
125 |         // Rotate about y-axis  (turntable) until the smallest volume box is found
126 |         let orientation_temp = orientation;
127 |         for angle in (0..45).step_by(15) {
128 |             let new_orientation =
129 |                 orientation_temp * Quat::from_rotation_y(angle as f32 * 2.0 * PI / 360.0);
130 |             let temp_obb = Obb::compute_obb(&vertices, new_orientation);
131 |             let diff = temp_obb.mesh_aabb().maximums() - temp_obb.mesh_aabb().minimums();
132 |             let new_volume = diff.x * diff.y * diff.z;
133 |             if new_volume < volume {
134 |                 volume = new_volume;
135 |                 orientation = new_orientation;
136 |             }
137 |         }
138 |         let mut obb = Obb::compute_obb(&vertices, orientation);
139 |         let orientation_temp = orientation;
140 |         for angle in (0..90).step_by(15) {
141 |             let new_orientation =
142 |                 orientation_temp * Quat::from_rotation_x(angle as f32 * 2.0 * PI / 360.0);
143 |             let temp_obb = Obb::compute_obb(&vertices, new_orientation);
144 |             let diff = temp_obb.mesh_aabb().maximums() - temp_obb.mesh_aabb().minimums();
145 |             let new_volume = diff.x * diff.y * diff.z;
146 |             if new_volume < volume {
147 |                 volume = new_volume;
148 |                 obb = temp_obb;
149 |             }
150 |         }
151 |         obb
152 |     }
153 | 
154 |     fn new_debug_mesh(&self, _transform: &GlobalTransform) -> Mesh {
155 |         Mesh::from(self)
156 |     }
157 | 
158 |     fn update_on_transform_change(
159 |         &self,
160 |         _mesh: &Mesh,
161 |         _transform: &GlobalTransform,
162 |     ) -> Option<Self> {
163 |         // No-op
164 |         None
165 |     }
166 | 
167 |     fn outside_plane(
168 |         &self,
169 |         bound_vol_position: &GlobalTransform,
170 |         point: Vec3,
171 |         normal: Vec3,
172 |     ) -> bool {
173 |         for vertex in self.vertices(*bound_vol_position).iter() {
174 |             if normal.dot(*vertex) + -normal.dot(point) < 0.0 {
175 |                 // if any point is on the inside of the plane, we can end early.
176 |                 return false;
177 |             }
178 |         }
179 |         true
180 |     }
181 | }
182 | 


--------------------------------------------------------------------------------
/src/debug.rs:
--------------------------------------------------------------------------------
  1 | use crate::{aabb::Aabb, obb::Obb, sphere::BSphere, BoundingVolume};
  2 | use bevy::{
  3 |     prelude::*,
  4 |     render::{mesh::Indices, pipeline::PrimitiveTopology},
  5 | };
  6 | 
  7 | /// Marks an entity that should have a mesh added as a child to represent the mesh's bounding volume.
  8 | #[derive(Component)]
  9 | pub struct DebugBounds;
 10 | 
 11 | /// Marks the debug bounding volume mesh, which exists as a child of a [BoundingVolumeDebug] entity
 12 | #[derive(Component)]
 13 | pub struct DebugBoundsMesh;
 14 | 
 15 | /// Updates existing debug meshes, and creates new debug meshes on entities with a bounding volume
 16 | /// component marked with [BoundingVolumeDebug] and no existing debug mesh.
 17 | #[allow(clippy::type_complexity)]
 18 | pub fn update_debug_meshes<T>(
 19 |     mut commands: Commands,
 20 |     mut materials: ResMut<Assets<StandardMaterial>>,
 21 |     mut meshes: ResMut<Assets<Mesh>>,
 22 |     query: Query<
 23 |         (&'static GlobalTransform, &T, Entity, Option<&Children>),
 24 |         (Changed<T>, With<DebugBounds>),
 25 |     >,
 26 |     mut debug_mesh_query: Query<&mut Handle<Mesh>, With<DebugBoundsMesh>>,
 27 | ) where
 28 |     T: 'static + BoundingVolume + Clone + Send + Sync + std::fmt::Debug + Component,
 29 |     Mesh: From<&'static T>,
 30 | {
 31 |     for (transform, bound_vol, entity, optional_children) in query.iter() {
 32 |         let mut updated_existing_child = false;
 33 |         if let Some(children) = optional_children {
 34 |             for child in children.iter() {
 35 |                 if let Ok(mut mesh_handle) = debug_mesh_query.get_mut(*child) {
 36 |                     let mesh = bound_vol.new_debug_mesh(transform);
 37 |                     let new_handle = meshes.add(mesh);
 38 |                     *mesh_handle = new_handle;
 39 |                     updated_existing_child = true;
 40 |                     break;
 41 |                 }
 42 |             }
 43 |         }
 44 |         // if the entity had a child, we don't need to create a new one
 45 |         if !updated_existing_child {
 46 |             let mesh_handle = meshes.add(bound_vol.new_debug_mesh(transform));
 47 |             commands.entity(entity).with_children(|parent| {
 48 |                 parent
 49 |                     .spawn_bundle(PbrBundle {
 50 |                         mesh: mesh_handle,
 51 |                         material: materials.add(StandardMaterial {
 52 |                             base_color: Color::rgb(0.0, 1.0, 0.0),
 53 |                             unlit: true,
 54 |                             ..Default::default()
 55 |                         }),
 56 |                         ..Default::default()
 57 |                     })
 58 |                     .insert(DebugBoundsMesh);
 59 |             });
 60 |         }
 61 |     }
 62 | }
 63 | 
 64 | #[allow(clippy::type_complexity)]
 65 | pub fn update_debug_mesh_visibility<T>(
 66 |     mut query: QuerySet<(
 67 |         QueryState<(&Children, &Visible), (With<DebugBounds>, With<T>, Changed<Visible>)>,
 68 |         QueryState<&mut Visible, With<DebugBoundsMesh>>,
 69 |     )>,
 70 | ) where
 71 |     T: 'static + BoundingVolume + Clone + Send + Sync + Component,
 72 | {
 73 |     let child_list: Vec<(Box<Children>, bool)> = query
 74 |         .q0()
 75 |         .iter()
 76 |         .map(|(children, visible)| (Box::new((*children).clone()), visible.is_visible))
 77 |         .collect();
 78 |     for (children, parent_visible) in child_list.iter() {
 79 |         for child in children.iter() {
 80 |             if let Ok(mut child_visible) = query.q1().get_mut(*child) {
 81 |                 child_visible.is_visible = *parent_visible;
 82 |             }
 83 |         }
 84 |     }
 85 | }
 86 | 
 87 | impl From<&Aabb> for Mesh {
 88 |     fn from(aabb: &Aabb) -> Self {
 89 |         /*
 90 |               (2)-----(3)               Y
 91 |                | \     | \              |
 92 |                |  (1)-----(0) MAX       o---X
 93 |                |   |   |   |             \
 94 |           MIN (6)--|--(7)  |              Z
 95 |                  \ |     \ |
 96 |                   (5)-----(4)
 97 |         */
 98 |         let vertices: Vec<[f32; 3]> = aabb
 99 |             .vertices_mesh_space()
100 |             .iter()
101 |             .map(|vert| [vert.x, vert.y, vert.z])
102 |             .collect();
103 | 
104 |         let indices = Indices::U32(vec![
105 |             0, 1, 1, 2, 2, 3, 3, 0, // Top ring
106 |             4, 5, 5, 6, 6, 7, 7, 4, // Bottom ring
107 |             0, 4, 1, 5, 2, 6, 3, 7, // Verticals
108 |         ]);
109 | 
110 |         let mut mesh = Mesh::new(PrimitiveTopology::LineList);
111 |         mesh.set_attribute(Mesh::ATTRIBUTE_POSITION, vertices.clone());
112 |         mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, vertices.clone());
113 |         mesh.set_attribute(Mesh::ATTRIBUTE_NORMAL, vertices);
114 |         mesh.set_indices(Some(indices));
115 |         mesh
116 |     }
117 | }
118 | 
119 | impl From<&Obb> for Mesh {
120 |     fn from(obb: &Obb) -> Self {
121 |         /*
122 |               (2)-----(3)               Y
123 |                | \     | \              |
124 |                |  (1)-----(0) MAX       o---X
125 |                |   |   |   |             \
126 |           MIN (6)--|--(7)  |              Z
127 |                  \ |     \ |
128 |                   (5)-----(4)
129 |         */
130 |         let vertices: Vec<[f32; 3]> = obb
131 |             .vertices_mesh_space()
132 |             .iter()
133 |             .map(|vert| [vert.x, vert.y, vert.z])
134 |             .collect();
135 | 
136 |         let indices = Indices::U32(vec![
137 |             0, 1, 1, 2, 2, 3, 3, 0, // Top ring
138 |             4, 5, 5, 6, 6, 7, 7, 4, // Bottom ring
139 |             0, 4, 1, 5, 2, 6, 3, 7, // Verticals
140 |         ]);
141 | 
142 |         let mut mesh = Mesh::new(PrimitiveTopology::LineList);
143 |         mesh.set_attribute(Mesh::ATTRIBUTE_POSITION, vertices.clone());
144 |         mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, vertices.clone());
145 |         mesh.set_attribute(Mesh::ATTRIBUTE_NORMAL, vertices);
146 |         mesh.set_indices(Some(indices));
147 |         mesh
148 |     }
149 | }
150 | 
151 | impl From<&BSphere> for Mesh {
152 |     fn from(sphere: &BSphere) -> Self {
153 |         let radius = sphere.mesh_space_radius();
154 |         let origin = sphere.mesh_space_origin();
155 |         let n_points: i8 = 24;
156 |         let vertices_x0: Vec<[f32; 3]> = (0..n_points)
157 |             .map(|i| {
158 |                 let angle = i as f32 * 2.0 * std::f32::consts::PI / (n_points as f32);
159 |                 [
160 |                     0.0,
161 |                     angle.sin() * radius + origin.y,
162 |                     angle.cos() * radius + origin.z,
163 |                 ]
164 |             })
165 |             .collect();
166 |         let vertices_y0: Vec<[f32; 3]> = (0..n_points)
167 |             .map(|i| {
168 |                 let angle = i as f32 * 2.0 * std::f32::consts::PI / (n_points as f32);
169 |                 [
170 |                     angle.cos() * radius + origin.x,
171 |                     0.0,
172 |                     angle.sin() * radius + origin.z,
173 |                 ]
174 |             })
175 |             .collect();
176 |         let vertices_z0: Vec<[f32; 3]> = (0..n_points)
177 |             .map(|i| {
178 |                 let angle = i as f32 * 2.0 * std::f32::consts::PI / (n_points as f32);
179 |                 [
180 |                     angle.cos() * radius + origin.x,
181 |                     angle.sin() * radius + origin.y,
182 |                     0.0,
183 |                 ]
184 |             })
185 |             .collect();
186 |         let vertices = [vertices_x0, vertices_y0, vertices_z0].concat();
187 |         let indices_single: Vec<u32> = (0..n_points * 2)
188 |             .map(|i| {
189 |                 let result = (i as u32 + 1) / 2;
190 |                 if result == n_points as u32 {
191 |                     0
192 |                 } else {
193 |                     result
194 |                 }
195 |             })
196 |             .collect();
197 |         let indices = Indices::U32(
198 |             [
199 |                 indices_single
200 |                     .iter()
201 |                     .map(|&index| index + n_points as u32)
202 |                     .collect(),
203 |                 indices_single
204 |                     .iter()
205 |                     .map(|&index| index + 2 * n_points as u32)
206 |                     .collect(),
207 |                 indices_single,
208 |             ]
209 |             .concat(),
210 |         );
211 |         let mut mesh = Mesh::new(PrimitiveTopology::LineList);
212 |         mesh.set_attribute(Mesh::ATTRIBUTE_POSITION, vertices.clone());
213 |         mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, vertices.clone());
214 |         mesh.set_attribute(Mesh::ATTRIBUTE_NORMAL, vertices);
215 |         mesh.set_indices(Some(indices));
216 |         mesh
217 |     }
218 | }
219 | 


--------------------------------------------------------------------------------