From 81f4c903ae664a10531567e18f081170769087e6 Mon Sep 17 00:00:00 2001
From: Aevyrie <aevyrie@gmail.com>
Date: Thu, 22 Feb 2024 20:26:17 -0800
Subject: [PATCH] update to bevy 0.13 (#109)

* update to bevy 0.13

* clippy

* touch up examples

* free perf lying around in a hot loop

* Bump version

* add no culling to benches

* add perf notes to changelog

* Fix CI in bevy-0.13 branch (#111)

* fix(tests): QueryFilter fixed to be in filter position

Authored-by: RobWalt <robwalter96@gmail.com>

* chore(cleanup): remove unneeded `Mesh::from`

Authored-by: RobWalt <robwalter96@gmail.com>

* chore(cleanup): use Direction3D API directly

Ok to be fair this doesn't change a lot. It saves one indirection
through the `TryFrom` trait which might even gets optimized away in the
first place. Nevertheless it is a bit more explicit which will help
newer people to understand the code and develop good habits.

Authored-by: RobWalt <robwalter96@gmail.com>

---------

Co-authored-by: Robert Walter <26892280+RobWalt@users.noreply.github.com>
---
 CHANGELOG.md                       |  14 +-
 Cargo.toml                         |  28 ++--
 README.md                          |   1 +
 benches/ray_mesh_intersection.rs   |  30 +++-
 examples/minimal.rs                |  12 +-
 examples/minimal_deferred.rs       |  14 +-
 examples/mouse_picking.rs          |   4 +-
 examples/mouse_picking_2d.rs       |   7 +-
 examples/mouse_picking_deferred.rs |   4 +-
 examples/reflecting_laser.rs       |  24 ++-
 examples/simplified_mesh.rs        |  16 +-
 examples/stress_test.rs            |   8 +-
 src/deferred.rs                    |  31 ++--
 src/immediate.rs                   |  23 ++-
 src/lib.rs                         |   3 +-
 src/primitives.rs                  | 248 ++++++++++-------------------
 src/raycast.rs                     | 200 +++++++++--------------
 17 files changed, 291 insertions(+), 376 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7d56d83..0063202 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,18 @@
+# 0.17.0
+
+Raycasting is now 20-50% faster.
+
+- Changed: updated to Bevy 0.13.
+- Removed: This crate's `Ray3d` type has been replaced with Bevy's new `Ray3d` type.
+  - Methods on `Ray3d` have been replaced with standalone functions.
+  - This has resulted in a ~10% drop in performance in benchmarks.
+- Changed: `Ray3d::from_transform` is now `ray_from_transform`
+- Changed: `Ray3d::from_screenspace` is now `ray_from_screenspace`
+- Changed: `Triangle` removed in favor of a simpler `[Vec3A; 3]`.
+
 # 0.16.0
 
-- Changed: updated to bevy 0.12.
+- Changed: updated to Bevy 0.12.
 - Changed: plugin depends on bevy sub-crates (e.g. `bevy_ecs`) instead of `bevy` to reduce
   dependency count.
 
diff --git a/Cargo.toml b/Cargo.toml
index b7e899b..5a17dfc 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_mod_raycast"
-version = "0.16.0"
+version = "0.17.0"
 authors = ["Aevyrie <aevyrie@gmail.com>"]
 edition = "2021"
 license = "MIT"
@@ -11,22 +11,22 @@ categories = ["game-engines", "rendering"]
 resolver = "2"
 
 [dependencies]
-bevy_app = { version = "0.12", default-features = false }
-bevy_asset = { version = "0.12", default-features = false }
-bevy_derive = { version = "0.12", default-features = false }
-bevy_ecs = { version = "0.12", default-features = false }
-bevy_gizmos = { version = "0.12", optional = true, default-features = false }
-bevy_math = { version = "0.12", default-features = false }
-bevy_reflect = { version = "0.12", default-features = false }
-bevy_render = { version = "0.12", default-features = false }
-bevy_sprite = { version = "0.12", optional = true, default-features = false }
-bevy_transform = { version = "0.12", default-features = false }
-bevy_utils = { version = "0.12", default-features = false }
-bevy_window = { version = "0.12", default-features = false }
+bevy_app = { version = "0.13", default-features = false }
+bevy_asset = { version = "0.13", default-features = false }
+bevy_derive = { version = "0.13", default-features = false }
+bevy_ecs = { version = "0.13", default-features = false }
+bevy_gizmos = { version = "0.13", optional = true, default-features = false }
+bevy_math = { version = "0.13", default-features = false }
+bevy_reflect = { version = "0.13", default-features = false }
+bevy_render = { version = "0.13", default-features = false }
+bevy_sprite = { version = "0.13", optional = true, default-features = false }
+bevy_transform = { version = "0.13", default-features = false }
+bevy_utils = { version = "0.13", default-features = false }
+bevy_window = { version = "0.13", default-features = false }
 crossbeam-channel = "0.5"
 
 [dev-dependencies]
-bevy = { version = "0.12", default-features = true, features = [
+bevy = { version = "0.13", default-features = true, features = [
     "default_font",
     "ktx2",
     "tonemapping_luts",
diff --git a/README.md b/README.md
index 1f2018e..2883931 100644
--- a/README.md
+++ b/README.md
@@ -34,6 +34,7 @@ I intend to track the `main` branch of Bevy. PRs supporting this are welcome!
 
 | bevy | bevy_mod_raycast |
 | ---- | ---------------- |
+| 0.13 | 0.17             |
 | 0.12 | 0.16             |
 | 0.11 | 0.9 - 0.15       |
 | 0.10 | 0.8              |
diff --git a/benches/ray_mesh_intersection.rs b/benches/ray_mesh_intersection.rs
index 6d3a90c..ddbb05e 100644
--- a/benches/ray_mesh_intersection.rs
+++ b/benches/ray_mesh_intersection.rs
@@ -1,4 +1,5 @@
 use bevy::math::{Mat4, Vec3};
+use bevy_math::Ray3d;
 use bevy_mod_raycast::prelude::*;
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 
@@ -54,7 +55,7 @@ fn ray_mesh_intersection(c: &mut Criterion) {
                     &mesh_to_world,
                     &mesh.positions,
                     Some(&mesh.normals),
-                    &ray,
+                    ray,
                     Some(&mesh.indices),
                     Backfaces::Cull,
                 ));
@@ -63,6 +64,30 @@ fn ray_mesh_intersection(c: &mut Criterion) {
     }
 }
 
+fn ray_mesh_intersection_no_cull(c: &mut Criterion) {
+    let mut group = c.benchmark_group("ray_mesh_intersection_no_cull");
+    group.warm_up_time(std::time::Duration::from_millis(500));
+
+    for vertices_per_side in [10_u32, 100, 1000] {
+        group.bench_function(format!("{}_vertices", vertices_per_side.pow(2)), |b| {
+            let ray = Ray3d::new(Vec3::new(0.0, 1.0, 0.0), Vec3::new(0.0, -1.0, 0.0));
+            let mesh_to_world = Mat4::IDENTITY;
+            let mesh = mesh_creation(vertices_per_side);
+
+            b.iter(|| {
+                black_box(bevy_mod_raycast::prelude::ray_mesh_intersection(
+                    &mesh_to_world,
+                    &mesh.positions,
+                    Some(&mesh.normals),
+                    ray,
+                    Some(&mesh.indices),
+                    Backfaces::Include,
+                ));
+            });
+        });
+    }
+}
+
 fn ray_mesh_intersection_no_intersection(c: &mut Criterion) {
     let mut group = c.benchmark_group("ray_mesh_intersection_no_intersection");
     group.warm_up_time(std::time::Duration::from_millis(500));
@@ -78,7 +103,7 @@ fn ray_mesh_intersection_no_intersection(c: &mut Criterion) {
                     &mesh_to_world,
                     &mesh.positions,
                     Some(&mesh.normals),
-                    &ray,
+                    ray,
                     Some(&mesh.indices),
                     Backfaces::Cull,
                 ));
@@ -90,6 +115,7 @@ fn ray_mesh_intersection_no_intersection(c: &mut Criterion) {
 criterion_group!(
     benches,
     ray_mesh_intersection,
+    ray_mesh_intersection_no_cull,
     ray_mesh_intersection_no_intersection
 );
 criterion_main!(benches);
diff --git a/examples/minimal.rs b/examples/minimal.rs
index c919e56..c9ad3e7 100644
--- a/examples/minimal.rs
+++ b/examples/minimal.rs
@@ -13,12 +13,12 @@ fn main() {
         .run();
 }
 
-const DIST: Vec3 = Vec3::new(0.0, 0.0, -7.0);
+const RAY_DIST: Vec3 = Vec3::new(0.0, 0.0, -7.0);
 
 fn raycast(mut raycast: Raycast, mut gizmos: Gizmos, time: Res<Time>) {
     let t = time.elapsed_seconds();
-    let pos = Vec3::new(t.sin(), (t * 1.5).cos() * 2.0, t.cos()) * 1.5 + DIST;
-    let dir = (DIST - pos).normalize();
+    let pos = Vec3::new(t.sin(), (t * 1.5).cos() * 2.0, t.cos()) * 1.5 + RAY_DIST;
+    let dir = (RAY_DIST - pos).normalize();
     // This is all that is needed to raycast into the world! You can also use the normal, non-debug
     // version (raycast.cast_ray) when you don't need to visualize the ray or intersections.
     raycast.debug_cast_ray(Ray3d::new(pos, dir), &default(), &mut gizmos);
@@ -32,9 +32,9 @@ fn setup(
     commands.spawn(Camera3dBundle::default());
     commands.spawn(PointLightBundle::default());
     commands.spawn(PbrBundle {
-        mesh: meshes.add(Mesh::try_from(shape::Capsule::default()).unwrap()),
-        material: materials.add(Color::rgb(1.0, 1.0, 1.0).into()),
-        transform: Transform::from_translation(DIST),
+        mesh: meshes.add(Capsule3d::default()),
+        material: materials.add(Color::rgb(1.0, 1.0, 1.0)),
+        transform: Transform::from_translation(RAY_DIST),
         ..default()
     });
 }
diff --git a/examples/minimal_deferred.rs b/examples/minimal_deferred.rs
index 274d936..f9ec6a6 100644
--- a/examples/minimal_deferred.rs
+++ b/examples/minimal_deferred.rs
@@ -1,4 +1,4 @@
-//! This example demonstrates how to use the [`bevy_mod_raycast::deferred`]` API. Unlike the
+//! This example demonstrates how to use the [`bevy_mod_raycast::deferred`] API. Unlike the
 //! [`Raycast`] system param, this API is declarative, and does not return a result immediately.
 //! Instead, behavior is defined using components, and raycasting is done once per frame.
 
@@ -16,7 +16,7 @@ fn main() {
         .run();
 }
 
-const DIST: Vec3 = Vec3::new(0.0, 0.0, -7.0);
+const RAY_DIST: Vec3 = Vec3::new(0.0, 0.0, -7.0);
 
 #[derive(Reflect)]
 struct MyRaycastSet; // Groups raycast sources with meshes, can use `()` instead.
@@ -26,8 +26,8 @@ struct MovingRaycaster;
 
 fn move_ray(time: Res<Time>, mut query: Query<&mut Transform, With<MovingRaycaster>>) {
     let t = time.elapsed_seconds();
-    let pos = Vec3::new(t.sin(), (t * 1.5).cos() * 2.0, t.cos()) * 1.5 + DIST;
-    let dir = (DIST - pos).normalize();
+    let pos = Vec3::new(t.sin(), (t * 1.5).cos() * 2.0, t.cos()) * 1.5 + RAY_DIST;
+    let dir = (RAY_DIST - pos).normalize();
     *query.single_mut() = Transform::from_translation(pos).looking_to(dir, Vec3::Y);
 }
 
@@ -47,9 +47,9 @@ fn setup(
     ));
     commands.spawn((
         PbrBundle {
-            mesh: meshes.add(Mesh::try_from(shape::Capsule::default()).unwrap()),
-            material: materials.add(Color::rgb(1.0, 1.0, 1.0).into()),
-            transform: Transform::from_translation(DIST),
+            mesh: meshes.add(Capsule3d::default()),
+            material: materials.add(Color::rgb(1.0, 1.0, 1.0)),
+            transform: Transform::from_translation(RAY_DIST),
             ..default()
         },
         RaycastMesh::<MyRaycastSet>::default(), // Make this mesh ray cast-able
diff --git a/examples/mouse_picking.rs b/examples/mouse_picking.rs
index e6783eb..ff2b88f 100644
--- a/examples/mouse_picking.rs
+++ b/examples/mouse_picking.rs
@@ -28,8 +28,8 @@ fn setup(
     commands.spawn(Camera3dBundle::default());
     commands.spawn(PointLightBundle::default());
     commands.spawn(PbrBundle {
-        mesh: meshes.add(Mesh::from(shape::UVSphere::default())),
-        material: materials.add(Color::GRAY.into()),
+        mesh: meshes.add(Sphere::default()),
+        material: materials.add(Color::GRAY),
         transform: Transform::from_xyz(0.0, 0.0, -5.0),
         ..default()
     });
diff --git a/examples/mouse_picking_2d.rs b/examples/mouse_picking_2d.rs
index 703c045..bb4f3ec 100644
--- a/examples/mouse_picking_2d.rs
+++ b/examples/mouse_picking_2d.rs
@@ -3,7 +3,10 @@ use bevy_mod_raycast::prelude::*;
 
 fn main() {
     App::new()
-        .add_plugins((DefaultPlugins, DeferredRaycastingPlugin::<()>::default()))
+        .add_plugins((
+            DefaultPlugins.set(bevy_mod_raycast::low_latency_window_plugin()),
+            DeferredRaycastingPlugin::<()>::default(),
+        ))
         .insert_resource(RaycastPluginState::<()>::default().with_debug_cursor())
         .add_systems(Startup, setup)
         .add_systems(Update, print_intersections::<()>)
@@ -18,7 +21,7 @@ fn setup(
     commands.spawn((Camera2dBundle::default(), RaycastSource::<()>::new_cursor()));
     commands.spawn((
         MaterialMesh2dBundle {
-            mesh: meshes.add(Mesh::from(shape::Circle::default())).into(),
+            mesh: meshes.add(Circle::default()).into(),
             transform: Transform::default().with_scale(Vec3::splat(128.)),
             material: materials.add(ColorMaterial::from(Color::PURPLE)),
             ..default()
diff --git a/examples/mouse_picking_deferred.rs b/examples/mouse_picking_deferred.rs
index c6bfcfa..48c9e31 100644
--- a/examples/mouse_picking_deferred.rs
+++ b/examples/mouse_picking_deferred.rs
@@ -28,8 +28,8 @@ fn setup(
     commands.spawn(PointLightBundle::default());
     commands.spawn((
         PbrBundle {
-            mesh: meshes.add(Mesh::from(shape::UVSphere::default())),
-            material: materials.add(Color::GRAY.into()),
+            mesh: meshes.add(Sphere::default()),
+            material: materials.add(Color::GRAY),
             transform: Transform::from_xyz(0.0, 0.0, -5.0),
             ..default()
         },
diff --git a/examples/reflecting_laser.rs b/examples/reflecting_laser.rs
index c029bf4..625876e 100644
--- a/examples/reflecting_laser.rs
+++ b/examples/reflecting_laser.rs
@@ -8,7 +8,10 @@ use bevy_mod_raycast::prelude::*;
 
 fn main() {
     App::new()
-        .add_plugins((DefaultPlugins, DefaultRaycastingPlugin))
+        .add_plugins((
+            DefaultPlugins.set(bevy_mod_raycast::low_latency_window_plugin()),
+            DefaultRaycastingPlugin,
+        ))
         .add_systems(Startup, setup_scene)
         .add_systems(Update, bouncing_raycast)
         .insert_resource(ClearColor(Color::BLACK))
@@ -39,25 +42,20 @@ fn bouncing_raycast(
     }
 }
 
-fn bounce_ray(
-    mut ray: Ray3d,
-    raycast: &mut Raycast<'_, '_>,
-    gizmos: &mut Gizmos<'_>,
-    color: Color,
-) {
+fn bounce_ray(mut ray: Ray3d, raycast: &mut Raycast, gizmos: &mut Gizmos, color: Color) {
     let mut intersections = Vec::with_capacity(MAX_BOUNCES + 1);
-    intersections.push((ray.origin(), Color::rgb(30.0, 0.0, 0.0)));
+    intersections.push((ray.origin, Color::rgb(30.0, 0.0, 0.0)));
 
     for i in 0..MAX_BOUNCES {
         if let Some((_, hit)) = raycast.cast_ray(ray, &RaycastSettings::default()).first() {
             let bright = 1.0 + 10.0 * (1.0 - i as f32 / MAX_BOUNCES as f32);
             intersections.push((hit.position(), color * bright));
             gizmos.sphere(hit.position(), Quat::IDENTITY, 0.005, color * bright * 2.0);
-            let ray_dir = ray.direction();
+            let ray_dir = ray.direction;
             // reflect the ray
             let proj = (ray_dir.dot(hit.normal()) / hit.normal().dot(hit.normal())) * hit.normal();
-            ray.set_direction(ray_dir - 2.0 * proj);
-            ray.set_origin(hit.position() + ray.direction() * 1e-6);
+            ray.direction = Direction3d::new(*ray_dir - 2.0 * proj).unwrap();
+            ray.origin = hit.position() + ray.direction * 1e-6;
         } else {
             break;
         }
@@ -89,8 +87,8 @@ fn setup_scene(
     ));
     // Make a box of planes facing inward so the laser gets trapped inside:
     let plane = PbrBundle {
-        mesh: meshes.add(shape::Plane::default().into()),
-        material: materials.add(Color::GRAY.with_a(0.01).into()),
+        mesh: meshes.add(Plane3d::default()),
+        material: materials.add(Color::GRAY.with_a(0.01)),
         ..default()
     };
     let pbr_bundle = move |translation, rotation| PbrBundle {
diff --git a/examples/simplified_mesh.rs b/examples/simplified_mesh.rs
index 2a9bf1e..fff089a 100644
--- a/examples/simplified_mesh.rs
+++ b/examples/simplified_mesh.rs
@@ -36,17 +36,13 @@ fn setup_scene(
     commands.spawn((
         PbrBundle {
             // This is a very complex mesh that will be hard to raycast on
-            mesh: meshes.add(Mesh::from(shape::UVSphere {
-                radius: 1.0,
-                sectors: 1000,
-                stacks: 1000,
-            })),
-            material: materials.add(Color::rgb(1.0, 1.0, 1.0).into()),
+            mesh: meshes.add(Sphere::default().mesh().uv(1000, 1000)),
+            material: materials.add(Color::rgb(1.0, 1.0, 1.0)),
             transform: Transform::from_translation(Vec3::new(0.0, 0.0, -5.0)),
             ..default()
         },
         SimplifiedMesh {
-            mesh: meshes.add(Mesh::from(shape::UVSphere::default())),
+            mesh: meshes.add(Sphere::default()),
         },
     ));
     commands.spawn(PointLightBundle {
@@ -133,7 +129,7 @@ fn manage_simplified_mesh(
     mut commands: Commands,
     query: Query<(Entity, Option<&SimplifiedMesh>), With<Handle<Mesh>>>,
     mut status_query: Query<&mut Text, With<SimplifiedStatus>>,
-    keyboard: Res<Input<KeyCode>>,
+    keyboard: Res<ButtonInput<KeyCode>>,
     mut meshes: ResMut<Assets<Mesh>>,
 ) {
     if keyboard.just_pressed(KeyCode::Space) {
@@ -141,7 +137,7 @@ fn manage_simplified_mesh(
             if let Ok(mut text) = status_query.get_single_mut() {
                 if simplified_mesh.is_none() {
                     commands.entity(entity).insert(SimplifiedMesh {
-                        mesh: meshes.add(Mesh::from(shape::UVSphere::default())),
+                        mesh: meshes.add(Sphere::default()),
                     });
                     text.sections[1].value = "ON".to_string();
                     text.sections[1].style.color = Color::GREEN;
@@ -157,7 +153,7 @@ fn manage_simplified_mesh(
 
 fn update_fps(diagnostics: Res<DiagnosticsStore>, mut query: Query<&mut Text, With<FpsText>>) {
     for mut text in &mut query {
-        if let Some(fps) = diagnostics.get(FrameTimeDiagnosticsPlugin::FPS) {
+        if let Some(fps) = diagnostics.get(&FrameTimeDiagnosticsPlugin::FPS) {
             if let Some(average) = fps.average() {
                 // Update the value of the second section
                 text.sections[1].value = format!("{:.2}", average);
diff --git a/examples/stress_test.rs b/examples/stress_test.rs
index fd809bc..e920d88 100644
--- a/examples/stress_test.rs
+++ b/examples/stress_test.rs
@@ -127,7 +127,7 @@ struct FpsText;
 // Insert or remove aabb components from the meshes being raycasted on.
 fn update_status(
     mut commands: Commands,
-    keyboard: Res<Input<KeyCode>>,
+    keyboard: Res<ButtonInput<KeyCode>>,
     mut enabled: Local<Option<(bool, bool)>>,
     // Bounding toggle
     mut bound_status: Query<&mut Text, (With<BoundVolStatus>, Without<EarlyExitStatus>)>,
@@ -151,7 +151,7 @@ fn update_status(
         }
     };
 
-    if keyboard.just_pressed(KeyCode::Key1) {
+    if keyboard.just_pressed(KeyCode::Digit1) {
         enabled.0 = !enabled.0;
         for (entity, mut aabb) in &mut aabbs {
             if enabled.0 {
@@ -165,7 +165,7 @@ fn update_status(
     }
     bool_to_text(enabled.0, bound_status.single_mut().as_mut());
 
-    if keyboard.just_pressed(KeyCode::Key2) {
+    if keyboard.just_pressed(KeyCode::Digit2) {
         enabled.1 = !enabled.1;
         for mut source in &mut sources {
             source.should_early_exit = enabled.1;
@@ -176,7 +176,7 @@ fn update_status(
 
 fn update_fps(diagnostics: Res<DiagnosticsStore>, mut query: Query<&mut Text, With<FpsText>>) {
     for mut text in &mut query {
-        if let Some(fps) = diagnostics.get(FrameTimeDiagnosticsPlugin::FPS) {
+        if let Some(fps) = diagnostics.get(&FrameTimeDiagnosticsPlugin::FPS) {
             if let Some(average) = fps.smoothed() {
                 // Update the value of the second section
                 text.sections[1].value = format!("{:.2}", average);
diff --git a/src/deferred.rs b/src/deferred.rs
index 49a1eff..69f85bd 100644
--- a/src/deferred.rs
+++ b/src/deferred.rs
@@ -23,7 +23,7 @@ use std::{
 
 use bevy_app::prelude::*;
 use bevy_ecs::prelude::*;
-use bevy_math::{Mat4, Vec2};
+use bevy_math::{Mat4, Ray3d, Vec2};
 use bevy_reflect::{Reflect, TypePath};
 use bevy_render::camera::Camera;
 use bevy_transform::components::GlobalTransform;
@@ -207,7 +207,7 @@ pub struct RaycastSource<T: TypePath> {
     pub should_early_exit: bool,
     /// Determines how raycasting should consider entity visibility.
     pub visibility: RaycastVisibility,
-    #[reflect(skip_serializing)]
+    #[reflect(ignore)]
     pub ray: Option<Ray3d>,
     #[reflect(ignore)]
     intersections: Vec<(Entity, IntersectionData)>,
@@ -257,7 +257,7 @@ impl<T: TypePath> RaycastSource<T> {
     ) -> Self {
         RaycastSource {
             cast_method: RaycastMethod::Screenspace(cursor_pos_screen),
-            ray: Ray3d::from_screenspace(cursor_pos_screen, camera, camera_transform, window),
+            ray: ray_from_screenspace(cursor_pos_screen, camera, camera_transform, window),
             ..self
         }
     }
@@ -265,7 +265,7 @@ impl<T: TypePath> RaycastSource<T> {
     pub fn with_ray_transform(self, transform: Mat4) -> Self {
         RaycastSource {
             cast_method: RaycastMethod::Transform,
-            ray: Some(Ray3d::from_transform(transform)),
+            ray: Some(ray_from_transform(transform)),
             ..self
         }
     }
@@ -352,7 +352,7 @@ impl<T: TypePath> RaycastSource<T> {
 
     /// Run an intersection check between this [`RaycastSource`] and a 3D primitive [`Primitive3d`].
     pub fn intersect_primitive(&self, shape: Primitive3d) -> Option<IntersectionData> {
-        Some(self.ray?.intersects_primitive(shape)?.into())
+        Some(intersects_primitive(self.ray?, shape)?.into())
     }
 
     /// Get a copy of the ray cast source's ray.
@@ -405,18 +405,18 @@ pub fn build_rays<T: TypePath>(
             RaycastMethod::Cursor => {
                 query_window(&window, camera, transform).and_then(|(window, camera, transform)| {
                     window.cursor_position().and_then(|cursor_pos| {
-                        Ray3d::from_screenspace(cursor_pos, camera, transform, window)
+                        ray_from_screenspace(cursor_pos, camera, transform, window)
                     })
                 })
             }
             RaycastMethod::Screenspace(cursor_pos_screen) => {
                 query_window(&window, camera, transform).and_then(|(window, camera, transform)| {
-                    Ray3d::from_screenspace(*cursor_pos_screen, camera, transform, window)
+                    ray_from_screenspace(*cursor_pos_screen, camera, transform, window)
                 })
             }
             RaycastMethod::Transform => transform
                 .map(|t| t.compute_matrix())
-                .map(Ray3d::from_transform),
+                .map(ray_from_transform),
         };
     }
 }
@@ -506,7 +506,7 @@ pub mod debug {
 
     use bevy_ecs::system::{Commands, Query};
     use bevy_gizmos::gizmos::Gizmos;
-    use bevy_math::{Quat, Vec3};
+    use bevy_math::{primitives::Direction3d, Quat, Vec3};
     use bevy_reflect::TypePath;
     use bevy_render::color::Color;
     use bevy_utils::tracing::info;
@@ -522,9 +522,9 @@ pub mod debug {
         mut gizmos: Gizmos,
     ) {
         for ray in sources.iter().filter_map(|s| s.ray) {
-            let orientation = Quat::from_rotation_arc(Vec3::NEG_Z, ray.direction());
-            gizmos.ray(ray.origin(), ray.direction(), Color::BLUE);
-            gizmos.sphere(ray.origin(), orientation, 0.1, Color::BLUE);
+            let orientation = Quat::from_rotation_arc(Vec3::NEG_Z, *ray.direction);
+            gizmos.ray(ray.origin, *ray.direction, Color::BLUE);
+            gizmos.sphere(ray.origin, orientation, 0.1, Color::BLUE);
         }
 
         for (is_first, intersection) in sources.iter().flat_map(|m| {
@@ -539,7 +539,12 @@ pub mod debug {
                 false => Color::PINK,
             };
             gizmos.ray(intersection.position(), intersection.normal(), color);
-            gizmos.circle(intersection.position(), intersection.normal(), 0.1, color);
+            gizmos.circle(
+                intersection.position(),
+                Direction3d::new_unchecked(intersection.normal().normalize()),
+                0.1,
+                color,
+            );
             gizmos.circle_2d(intersection.position().truncate(), 10.0, color);
         }
     }
diff --git a/src/immediate.rs b/src/immediate.rs
index 995dbed..9b7fa94 100644
--- a/src/immediate.rs
+++ b/src/immediate.rs
@@ -9,6 +9,7 @@
 
 use bevy_asset::{Assets, Handle};
 use bevy_ecs::{prelude::*, system::lifetimeless::Read, system::SystemParam};
+use bevy_math::Ray3d;
 use bevy_reflect::Reflect;
 use bevy_render::{prelude::*, primitives::Aabb};
 use bevy_transform::components::GlobalTransform;
@@ -121,7 +122,7 @@ type MeshFilter = With<Handle<Mesh>>;
 /// # use bevy::prelude::*;
 /// # #[derive(Component)]
 /// # struct Foo;
-/// fn raycast_system(mut raycast: Raycast, foo_query: Query<With<Foo>>) {
+/// fn raycast_system(mut raycast: Raycast, foo_query: Query<(), With<Foo>>) {
 ///     let ray = Ray3d::new(Vec3::ZERO, Vec3::X);
 ///
 ///     // Only raycast against entities with the `Foo` component.
@@ -195,9 +196,11 @@ impl<'w, 's> Raycast<'w, 's> {
         settings: &RaycastSettings,
         gizmos: &mut Gizmos,
     ) -> &[(Entity, IntersectionData)] {
-        let orientation = Quat::from_rotation_arc(Vec3::NEG_Z, ray.direction());
-        gizmos.ray(ray.origin(), ray.direction(), Color::BLUE);
-        gizmos.sphere(ray.origin(), orientation, 0.1, Color::BLUE);
+        use bevy_math::primitives::Direction3d;
+
+        let orientation = Quat::from_rotation_arc(Vec3::NEG_Z, *ray.direction);
+        gizmos.ray(ray.origin, *ray.direction, Color::BLUE);
+        gizmos.sphere(ray.origin, orientation, 0.1, Color::BLUE);
 
         let hits = self.cast_ray(ray, settings);
 
@@ -212,7 +215,12 @@ impl<'w, 's> Raycast<'w, 's> {
                 false => Color::PINK,
             };
             gizmos.ray(intersection.position(), intersection.normal(), color);
-            gizmos.circle(intersection.position(), intersection.normal(), 0.1, color);
+            gizmos.circle(
+                intersection.position(),
+                Direction3d::new_unchecked(intersection.normal().normalize()),
+                0.1,
+                color,
+            );
         }
 
         if let Some(hit) = hits.first() {
@@ -247,8 +255,7 @@ impl<'w, 's> Raycast<'w, 's> {
                     RaycastVisibility::MustBeVisibleAndInView => view_visibility.get(),
                 };
                 if should_raycast {
-                    if let Some([near, _]) = ray
-                        .intersects_aabb(aabb, &transform.compute_matrix())
+                    if let Some([near, _]) = intersects_aabb(ray, aabb, &transform.compute_matrix())
                         .filter(|[_, far]| *far >= 0.0)
                     {
                         aabb_hits_tx.send((FloatOrd(near), entity)).ok();
@@ -289,7 +296,7 @@ impl<'w, 's> Raycast<'w, 's> {
                         };
                         let transform = transform.compute_matrix();
                         let intersection =
-                            ray_intersection_over_mesh(mesh, &transform, &ray, backfaces);
+                            ray_intersection_over_mesh(mesh, &transform, ray, backfaces);
                         if let Some(intersection) = intersection {
                             let distance = FloatOrd(intersection.distance());
                             if (settings.early_exit_test)(*entity)
diff --git a/src/lib.rs b/src/lib.rs
index 127423b..ff4acff 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -61,6 +61,7 @@ pub mod raycast;
 use bevy_app::prelude::*;
 use bevy_derive::Deref;
 use bevy_ecs::prelude::*;
+use bevy_math::Ray3d;
 use bevy_render::camera::Camera;
 use bevy_transform::components::GlobalTransform;
 use bevy_utils::default;
@@ -125,7 +126,7 @@ pub fn update_cursor_ray(
         .filter_map(|(cam, window_entity)| windows.get(window_entity).ok().map(|w| (cam, w)))
         .filter_map(|(cam, window)| window.cursor_position().map(|pos| (cam, window, pos)))
         .filter_map(|((camera, transform), window, cursor)| {
-            Ray3d::from_screenspace(cursor, camera, transform, window)
+            ray_from_screenspace(cursor, camera, transform, window)
         })
         .next();
 }
diff --git a/src/primitives.rs b/src/primitives.rs
index 79a5b15..8598b4b 100644
--- a/src/primitives.rs
+++ b/src/primitives.rs
@@ -14,7 +14,7 @@ pub struct IntersectionData {
     normal: Vec3,
     barycentric_coord: Vec3,
     distance: f32,
-    triangle: Option<Triangle>,
+    triangle: Option<[Vec3A; 3]>,
     triangle_index: Option<usize>,
 }
 
@@ -37,7 +37,7 @@ impl IntersectionData {
         normal: Vec3,
         barycentric: Vec3,
         distance: f32,
-        triangle: Option<Triangle>,
+        triangle: Option<[Vec3A; 3]>,
         triangle_index: Option<usize>,
     ) -> Self {
         Self {
@@ -76,7 +76,7 @@ impl IntersectionData {
 
     /// Get the intersection data's triangle.
     #[must_use]
-    pub fn triangle(&self) -> Option<Triangle> {
+    pub fn triangle(&self) -> Option<[Vec3A; 3]> {
         self.triangle
     }
 
@@ -91,8 +91,7 @@ impl IntersectionData {
 /// the `Ray3d` direction is normalized, because it can only be instantiated with the constructor.
 pub mod rays {
     use super::Primitive3d;
-    use bevy_math::{prelude::*, Vec3A};
-    use bevy_reflect::Reflect;
+    use bevy_math::{prelude::*, Ray3d, Vec3A};
     use bevy_render::{camera::Camera, primitives::Aabb};
     use bevy_transform::components::GlobalTransform;
     use bevy_window::Window;
@@ -131,185 +130,106 @@ pub mod rays {
         }
     }
 
-    /// A 3D ray, with an origin and direction. The direction is guaranteed to be normalized.
-    #[derive(Reflect, Debug, PartialEq, Copy, Clone, Default)]
-    pub struct Ray3d {
-        pub(crate) origin: Vec3A,
-        pub(crate) direction: Vec3A,
+    pub fn to_transform(ray: Ray3d) -> Mat4 {
+        to_aligned_transform(ray, [0., 1., 0.].into())
     }
 
-    impl Ray3d {
-        /// Constructs a `Ray3d`, normalizing the direction vector.
-        pub fn new(origin: Vec3, direction: Vec3) -> Self {
-            Ray3d {
-                origin: origin.into(),
-                direction: direction.normalize().into(),
-            }
-        }
+    /// Create a transform whose origin is at the origin of the ray and
+    /// whose up-axis is aligned with the direction of the ray. Use `up` to
+    /// specify which axis of the transform should align with the ray.
+    pub fn to_aligned_transform(ray: Ray3d, up: Vec3) -> Mat4 {
+        let position = ray.origin;
+        let normal = ray.direction;
+        let new_rotation = Quat::from_rotation_arc(up, *normal);
+        Mat4::from_rotation_translation(new_rotation, position)
+    }
 
-        /// Position vector describing the ray origin
-        pub fn origin(&self) -> Vec3 {
-            self.origin.into()
-        }
+    pub fn ray_from_transform(transform: Mat4) -> Ray3d {
+        let pick_position_ndc = Vec3::from([0.0, 0.0, -1.0]);
+        let pick_position = transform.project_point3(pick_position_ndc);
+        let (_, _, source_origin) = transform.to_scale_rotation_translation();
+        let ray_direction = pick_position - source_origin;
+        Ray3d::new(source_origin, ray_direction)
+    }
 
-        /// Unit vector describing the ray direction
-        pub fn direction(&self) -> Vec3 {
-            self.direction.into()
+    pub fn ray_from_screenspace(
+        cursor_pos_screen: Vec2,
+        camera: &Camera,
+        camera_transform: &GlobalTransform,
+        window: &Window,
+    ) -> Option<Ray3d> {
+        let mut viewport_pos = cursor_pos_screen;
+        if let Some(viewport) = &camera.viewport {
+            viewport_pos -= viewport.physical_position.as_vec2() / window.scale_factor();
         }
+        camera
+            .viewport_to_world(camera_transform, viewport_pos)
+            .map(Ray3d::from)
+    }
 
-        pub fn position(&self, distance: f32) -> Vec3 {
-            (self.origin + self.direction * distance).into()
-        }
+    /// Checks if the ray intersects with an AABB of a mesh, returning `[near, far]` if it does.
+    pub fn intersects_aabb(ray: Ray3d, aabb: &Aabb, model_to_world: &Mat4) -> Option<[f32; 2]> {
+        // Transform the ray to model space
+        let world_to_model = model_to_world.inverse();
+        let ray_dir: Vec3A = world_to_model.transform_vector3(*ray.direction).into();
+        let ray_origin: Vec3A = world_to_model.transform_point3(ray.origin).into();
+        // Check if the ray intersects the mesh's AABB. It's useful to work in model space
+        // because we can do an AABB intersection test, instead of an OBB intersection test.
 
-        pub fn to_transform(self) -> Mat4 {
-            self.to_aligned_transform([0., 1., 0.].into())
-        }
+        let t_0: Vec3A = (aabb.min() - ray_origin) / ray_dir;
+        let t_1: Vec3A = (aabb.max() - ray_origin) / ray_dir;
+        let t_min: Vec3A = t_0.min(t_1);
+        let t_max: Vec3A = t_0.max(t_1);
 
-        /// Create a transform whose origin is at the origin of the ray and
-        /// whose up-axis is aligned with the direction of the ray. Use `up` to
-        /// specify which axis of the transform should align with the ray.
-        pub fn to_aligned_transform(self, up: Vec3) -> Mat4 {
-            let position = self.origin();
-            let normal = self.direction();
-            let new_rotation = Quat::from_rotation_arc(up, normal);
-            Mat4::from_rotation_translation(new_rotation, position)
-        }
+        let mut hit_near = t_min.x;
+        let mut hit_far = t_max.x;
 
-        pub fn from_transform(transform: Mat4) -> Self {
-            let pick_position_ndc = Vec3::from([0.0, 0.0, -1.0]);
-            let pick_position = transform.project_point3(pick_position_ndc);
-            let (_, _, source_origin) = transform.to_scale_rotation_translation();
-            let ray_direction = pick_position - source_origin;
-            Ray3d::new(source_origin, ray_direction)
+        if hit_near > t_max.y || t_min.y > hit_far {
+            return None;
         }
 
-        pub fn from_screenspace(
-            cursor_pos_screen: Vec2,
-            camera: &Camera,
-            camera_transform: &GlobalTransform,
-            window: &Window,
-        ) -> Option<Self> {
-            let mut viewport_pos = cursor_pos_screen;
-            if let Some(viewport) = &camera.viewport {
-                viewport_pos -= viewport.physical_position.as_vec2() / window.scale_factor() as f32;
-            }
-            camera
-                .viewport_to_world(camera_transform, viewport_pos)
-                .map(Ray3d::from)
+        if t_min.y > hit_near {
+            hit_near = t_min.y;
         }
-
-        /// Checks if the ray intersects with an AABB of a mesh, returning `[near, far]` if it does.
-        pub fn intersects_aabb(&self, aabb: &Aabb, model_to_world: &Mat4) -> Option<[f32; 2]> {
-            // Transform the ray to model space
-            let world_to_model = model_to_world.inverse();
-            let ray_dir: Vec3A = world_to_model.transform_vector3(self.direction()).into();
-            let ray_origin: Vec3A = world_to_model.transform_point3(self.origin()).into();
-            // Check if the ray intersects the mesh's AABB. It's useful to work in model space
-            // because we can do an AABB intersection test, instead of an OBB intersection test.
-
-            let t_0: Vec3A = (aabb.min() - ray_origin) / ray_dir;
-            let t_1: Vec3A = (aabb.max() - ray_origin) / ray_dir;
-            let t_min: Vec3A = t_0.min(t_1);
-            let t_max: Vec3A = t_0.max(t_1);
-
-            let mut hit_near = t_min.x;
-            let mut hit_far = t_max.x;
-
-            if hit_near > t_max.y || t_min.y > hit_far {
-                return None;
-            }
-
-            if t_min.y > hit_near {
-                hit_near = t_min.y;
-            }
-            if t_max.y < hit_far {
-                hit_far = t_max.y;
-            }
-
-            if (hit_near > t_max.z) || (t_min.z > hit_far) {
-                return None;
-            }
-
-            if t_min.z > hit_near {
-                hit_near = t_min.z;
-            }
-            if t_max.z < hit_far {
-                hit_far = t_max.z;
-            }
-            Some([hit_near, hit_far])
-        }
-
-        /// Checks if the ray intersects with a primitive shape
-        pub fn intersects_primitive(&self, shape: Primitive3d) -> Option<PrimitiveIntersection> {
-            match shape {
-                Primitive3d::Plane {
-                    point: plane_origin,
-                    normal: plane_normal,
-                } => {
-                    // assuming vectors are all normalized
-                    let denominator = self.direction().dot(plane_normal);
-                    if denominator.abs() > f32::EPSILON {
-                        let point_to_point = plane_origin - self.origin();
-                        let intersect_dist = plane_normal.dot(point_to_point) / denominator;
-                        let intersect_position = self.direction() * intersect_dist + self.origin();
-                        Some(PrimitiveIntersection::new(
-                            intersect_position,
-                            plane_normal,
-                            intersect_dist,
-                        ))
-                    } else {
-                        None
-                    }
-                }
-            }
+        if t_max.y < hit_far {
+            hit_far = t_max.y;
         }
 
-        pub fn set_origin(&mut self, origin: Vec3) {
-            self.origin = origin.into();
+        if (hit_near > t_max.z) || (t_min.z > hit_far) {
+            return None;
         }
 
-        pub fn set_direction(&mut self, direction: Vec3) {
-            self.direction = direction.normalize().into();
+        if t_min.z > hit_near {
+            hit_near = t_min.z;
         }
-    }
-
-    impl From<Ray> for Ray3d {
-        fn from(ray: Ray) -> Self {
-            Ray3d::new(ray.origin, ray.direction)
+        if t_max.z < hit_far {
+            hit_far = t_max.z;
         }
+        Some([hit_near, hit_far])
     }
-}
 
-#[derive(Debug, PartialEq, Copy, Clone, Reflect)]
-pub struct Triangle {
-    pub v0: Vec3A,
-    pub v1: Vec3A,
-    pub v2: Vec3A,
-}
-impl From<(Vec3A, Vec3A, Vec3A)> for Triangle {
-    fn from(vertices: (Vec3A, Vec3A, Vec3A)) -> Self {
-        Triangle {
-            v0: vertices.0,
-            v1: vertices.1,
-            v2: vertices.2,
-        }
-    }
-}
-impl From<Vec<Vec3A>> for Triangle {
-    fn from(vertices: Vec<Vec3A>) -> Self {
-        Triangle {
-            v0: *vertices.get(0).unwrap(),
-            v1: *vertices.get(1).unwrap(),
-            v2: *vertices.get(2).unwrap(),
-        }
-    }
-}
-impl From<[Vec3A; 3]> for Triangle {
-    fn from(vertices: [Vec3A; 3]) -> Self {
-        Triangle {
-            v0: vertices[0],
-            v1: vertices[1],
-            v2: vertices[2],
+    /// Checks if the ray intersects with a primitive shape
+    pub fn intersects_primitive(ray: Ray3d, shape: Primitive3d) -> Option<PrimitiveIntersection> {
+        match shape {
+            Primitive3d::Plane {
+                point: plane_origin,
+                normal: plane_normal,
+            } => {
+                // assuming vectors are all normalized
+                let denominator = ray.direction.dot(plane_normal);
+                if denominator.abs() > f32::EPSILON {
+                    let point_to_point = plane_origin - ray.origin;
+                    let intersect_dist = plane_normal.dot(point_to_point) / denominator;
+                    let intersect_position = ray.direction * intersect_dist + ray.origin;
+                    Some(PrimitiveIntersection::new(
+                        intersect_position,
+                        plane_normal,
+                        intersect_dist,
+                    ))
+                } else {
+                    None
+                }
+            }
         }
     }
 }
diff --git a/src/raycast.rs b/src/raycast.rs
index bf928af..0043461 100644
--- a/src/raycast.rs
+++ b/src/raycast.rs
@@ -1,6 +1,6 @@
 use std::f32::EPSILON;
 
-use bevy_math::{Mat4, Vec3, Vec3A};
+use bevy_math::{Mat4, Ray3d, Vec3, Vec3A};
 use bevy_render::{
     mesh::{Indices, Mesh, VertexAttributeValues},
     render_resource::PrimitiveTopology,
@@ -13,7 +13,7 @@ use crate::primitives::*;
 pub fn ray_intersection_over_mesh(
     mesh: &Mesh,
     mesh_transform: &Mat4,
-    ray: &Ray3d,
+    ray: Ray3d,
     backface_culling: Backfaces,
 ) -> Option<IntersectionData> {
     if mesh.primitive_topology() != PrimitiveTopology::TriangleList {
@@ -91,7 +91,7 @@ pub fn ray_mesh_intersection(
     mesh_transform: &Mat4,
     vertex_positions: &[[f32; 3]],
     vertex_normals: Option<&[[f32; 3]]>,
-    ray: &Ray3d,
+    ray: Ray3d,
     indices: Option<&Vec<impl IntoUsize>>,
     backface_culling: Backfaces,
 ) -> Option<IntersectionData> {
@@ -103,8 +103,8 @@ pub fn ray_mesh_intersection(
     let world_to_mesh = mesh_transform.inverse();
 
     let mesh_space_ray = Ray3d::new(
-        world_to_mesh.transform_point3(ray.origin()),
-        world_to_mesh.transform_vector3(ray.direction()),
+        world_to_mesh.transform_point3(ray.origin),
+        world_to_mesh.transform_vector3(*ray.direction),
     );
 
     if let Some(indices) = indices {
@@ -134,7 +134,7 @@ pub fn ray_mesh_intersection(
                 tri_vertex_positions,
                 tri_normals,
                 min_pick_distance,
-                mesh_space_ray,
+                &mesh_space_ray,
                 backface_culling,
             );
             if let Some(i) = intersection {
@@ -143,14 +143,14 @@ pub fn ray_mesh_intersection(
                     mesh_transform.transform_vector3(i.normal()),
                     i.barycentric_coord(),
                     mesh_transform
-                        .transform_vector3(mesh_space_ray.direction() * i.distance())
+                        .transform_vector3(mesh_space_ray.direction * i.distance())
                         .length(),
                     i.triangle().map(|tri| {
-                        Triangle::from([
-                            mesh_transform.transform_point3a(tri.v0),
-                            mesh_transform.transform_point3a(tri.v1),
-                            mesh_transform.transform_point3a(tri.v2),
-                        ])
+                        [
+                            mesh_transform.transform_point3a(tri[0]),
+                            mesh_transform.transform_point3a(tri[1]),
+                            mesh_transform.transform_point3a(tri[2]),
+                        ]
                     }),
                     triangle_index,
                 ));
@@ -176,7 +176,7 @@ pub fn ray_mesh_intersection(
                 tri_vertex_positions,
                 tri_normals,
                 min_pick_distance,
-                mesh_space_ray,
+                &mesh_space_ray,
                 backface_culling,
             );
             if let Some(i) = intersection {
@@ -185,14 +185,14 @@ pub fn ray_mesh_intersection(
                     mesh_transform.transform_vector3(i.normal()),
                     i.barycentric_coord(),
                     mesh_transform
-                        .transform_vector3(mesh_space_ray.direction() * i.distance())
+                        .transform_vector3(mesh_space_ray.direction * i.distance())
                         .length(),
                     i.triangle().map(|tri| {
-                        Triangle::from([
-                            mesh_transform.transform_point3a(tri.v0),
-                            mesh_transform.transform_point3a(tri.v1),
-                            mesh_transform.transform_point3a(tri.v2),
-                        ])
+                        [
+                            mesh_transform.transform_point3a(tri[0]),
+                            mesh_transform.transform_point3a(tri[1]),
+                            mesh_transform.transform_point3a(tri[2]),
+                        ]
                     }),
                     triangle_index,
                 ));
@@ -203,85 +203,40 @@ pub fn ray_mesh_intersection(
     pick_intersection
 }
 
+#[inline(always)]
 fn triangle_intersection(
     tri_vertices: [Vec3A; 3],
     tri_normals: Option<[Vec3A; 3]>,
     max_distance: f32,
-    ray: Ray3d,
+    ray: &Ray3d,
     backface_culling: Backfaces,
 ) -> Option<IntersectionData> {
-    if tri_vertices
-        .iter()
-        .any(|&vertex| (vertex - ray.origin).length_squared() < max_distance.powi(2))
-    {
-        // Run the raycast on the ray and triangle
-        if let Some(ray_hit) = ray_triangle_intersection(&ray, &tri_vertices, backface_culling) {
-            let distance = *ray_hit.distance();
-            if distance > 0.0 && distance < max_distance {
-                let position = ray.position(distance);
-                let u = ray_hit.uv_coords().0;
-                let v = ray_hit.uv_coords().1;
-                let w = 1.0 - u - v;
-                let barycentric = Vec3::new(u, v, w);
-                let normal = if let Some(normals) = tri_normals {
-                    normals[1] * u + normals[2] * v + normals[0] * w
-                } else {
-                    (tri_vertices.v1() - tri_vertices.v0())
-                        .cross(tri_vertices.v2() - tri_vertices.v0())
-                        .normalize()
-                };
-                let intersection = IntersectionData::new(
-                    position,
-                    normal.into(),
-                    barycentric,
-                    distance,
-                    Some(tri_vertices.to_triangle()),
-                    None,
-                );
-                return Some(intersection);
-            }
-        }
-    }
-    None
-}
-
-pub trait TriangleTrait {
-    fn v0(&self) -> Vec3A;
-    fn v1(&self) -> Vec3A;
-    fn v2(&self) -> Vec3A;
-    fn to_triangle(self) -> Triangle;
-}
-impl TriangleTrait for [Vec3A; 3] {
-    fn v0(&self) -> Vec3A {
-        self[0]
-    }
-    fn v1(&self) -> Vec3A {
-        self[1]
-    }
-    fn v2(&self) -> Vec3A {
-        self[2]
-    }
-
-    fn to_triangle(self) -> Triangle {
-        Triangle::from(self)
-    }
-}
-impl TriangleTrait for Triangle {
-    fn v0(&self) -> Vec3A {
-        self.v0
-    }
-
-    fn v1(&self) -> Vec3A {
-        self.v1
-    }
-
-    fn v2(&self) -> Vec3A {
-        self.v2
-    }
-
-    fn to_triangle(self) -> Triangle {
-        self
-    }
+    // Run the raycast on the ray and triangle
+    let ray_hit = ray_triangle_intersection(ray, &tri_vertices, backface_culling)?;
+    let distance = *ray_hit.distance();
+    if distance < 0.0 || distance > max_distance {
+        return None;
+    };
+    let position = ray.get_point(distance);
+    let u = ray_hit.uv_coords().0;
+    let v = ray_hit.uv_coords().1;
+    let w = 1.0 - u - v;
+    let barycentric = Vec3::new(u, v, w);
+    let normal = if let Some(normals) = tri_normals {
+        normals[1] * u + normals[2] * v + normals[0] * w
+    } else {
+        (tri_vertices[1] - tri_vertices[0])
+            .cross(tri_vertices[2] - tri_vertices[0])
+            .normalize()
+    };
+    Some(IntersectionData::new(
+        position,
+        normal.into(),
+        barycentric,
+        distance,
+        Some(tri_vertices),
+        None,
+    ))
 }
 
 #[derive(Copy, Clone, Default)]
@@ -295,40 +250,13 @@ pub enum Backfaces {
 #[inline(always)]
 pub fn ray_triangle_intersection(
     ray: &Ray3d,
-    triangle: &impl TriangleTrait,
-    backface_culling: Backfaces,
-) -> Option<RayHit> {
-    raycast_moller_trumbore(ray, triangle, backface_culling)
-}
-
-#[derive(Default, Debug)]
-pub struct RayHit {
-    distance: f32,
-    uv_coords: (f32, f32),
-}
-
-impl RayHit {
-    /// Get a reference to the intersection's uv coords.
-    pub fn uv_coords(&self) -> &(f32, f32) {
-        &self.uv_coords
-    }
-
-    /// Get a reference to the intersection's distance.
-    pub fn distance(&self) -> &f32 {
-        &self.distance
-    }
-}
-
-/// Implementation of the Möller-Trumbore ray-triangle intersection test
-pub fn raycast_moller_trumbore(
-    ray: &Ray3d,
-    triangle: &impl TriangleTrait,
+    triangle: &[Vec3A; 3],
     backface_culling: Backfaces,
 ) -> Option<RayHit> {
     // Source: https://www.scratchapixel.com/lessons/3d-basic-rendering/ray-tracing-rendering-a-triangle/moller-trumbore-ray-triangle-intersection
-    let vector_v0_to_v1: Vec3A = triangle.v1() - triangle.v0();
-    let vector_v0_to_v2: Vec3A = triangle.v2() - triangle.v0();
-    let p_vec: Vec3A = ray.direction.cross(vector_v0_to_v2);
+    let vector_v0_to_v1: Vec3A = triangle[1] - triangle[0];
+    let vector_v0_to_v2: Vec3A = triangle[2] - triangle[0];
+    let p_vec: Vec3A = (Vec3A::from(*ray.direction)).cross(vector_v0_to_v2);
     let determinant: f32 = vector_v0_to_v1.dot(p_vec);
 
     match backface_culling {
@@ -350,14 +278,14 @@ pub fn raycast_moller_trumbore(
 
     let determinant_inverse = 1.0 / determinant;
 
-    let t_vec = ray.origin - triangle.v0();
+    let t_vec = Vec3A::from(ray.origin) - triangle[0];
     let u = t_vec.dot(p_vec) * determinant_inverse;
     if !(0.0..=1.0).contains(&u) {
         return None;
     }
 
     let q_vec = t_vec.cross(vector_v0_to_v1);
-    let v = ray.direction.dot(q_vec) * determinant_inverse;
+    let v = Vec3A::from(*ray.direction).dot(q_vec) * determinant_inverse;
     if v < 0.0 || u + v > 1.0 {
         return None;
     }
@@ -371,6 +299,24 @@ pub fn raycast_moller_trumbore(
     })
 }
 
+#[derive(Default, Debug)]
+pub struct RayHit {
+    distance: f32,
+    uv_coords: (f32, f32),
+}
+
+impl RayHit {
+    /// Get a reference to the intersection's uv coords.
+    pub fn uv_coords(&self) -> &(f32, f32) {
+        &self.uv_coords
+    }
+
+    /// Get a reference to the intersection's distance.
+    pub fn distance(&self) -> &f32 {
+        &self.distance
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use bevy::math::Vec3;
@@ -384,7 +330,7 @@ mod tests {
 
     #[test]
     fn raycast_triangle_mt() {
-        let triangle = Triangle::from([V0.into(), V1.into(), V2.into()]);
+        let triangle = [V0.into(), V1.into(), V2.into()];
         let ray = Ray3d::new(Vec3::ZERO, Vec3::X);
         let result = ray_triangle_intersection(&ray, &triangle, Backfaces::Include);
         assert!(result.unwrap().distance - 1.0 <= f32::EPSILON);
@@ -392,7 +338,7 @@ mod tests {
 
     #[test]
     fn raycast_triangle_mt_culling() {
-        let triangle = Triangle::from([V2.into(), V1.into(), V0.into()]);
+        let triangle = [V2.into(), V1.into(), V0.into()];
         let ray = Ray3d::new(Vec3::ZERO, Vec3::X);
         let result = ray_triangle_intersection(&ray, &triangle, Backfaces::Cull);
         assert!(result.is_none());