diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5555e54..870aefa 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,8 @@
+# 0.19.0
+
+- Changed: updated to Bevy 0.15.
+- Use `Dir3` instead of `Vec3` for normalized directions in `Ray3d::new`
+
 # 0.18.0
 
 - Changed: updated to Bevy 0.14.
diff --git a/Cargo.toml b/Cargo.toml
index b5ac823..a969f4b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_mod_raycast"
-version = "0.18.0"
+version = "0.19.0"
 authors = ["Aevyrie <aevyrie@gmail.com>"]
 edition = "2021"
 license = "MIT"
@@ -11,23 +11,23 @@ categories = ["game-engines", "rendering"]
 resolver = "2"
 
 [dependencies]
-bevy_app = { version = "0.14.0", default-features = false }
-bevy_asset = { version = "0.14.0", default-features = false }
-bevy_derive = { version = "0.14.0", default-features = false }
-bevy_ecs = { version = "0.14.0", default-features = false }
-bevy_gizmos = { version = "0.14.0", optional = true, default-features = false }
-bevy_math = { version = "0.14.0", default-features = false }
-bevy_reflect = { version = "0.14.0", default-features = false }
-bevy_render = { version = "0.14.0", default-features = false }
-bevy_sprite = { version = "0.14.0", optional = true, default-features = false }
-bevy_transform = { version = "0.14.0", default-features = false }
-bevy_utils = { version = "0.14.0", default-features = false }
-bevy_window = { version = "0.14.0", default-features = false }
-bevy_color = { version = "0.14.0", default-features = false }
+bevy_app = { version = "0.15.0", default-features = false }
+bevy_asset = { version = "0.15.0", default-features = false }
+bevy_derive = { version = "0.15.0", default-features = false }
+bevy_ecs = { version = "0.15.0", default-features = false }
+bevy_gizmos = { version = "0.15.0", optional = true, default-features = false }
+bevy_math = { version = "0.15.0", default-features = false }
+bevy_reflect = { version = "0.15.0", default-features = false }
+bevy_render = { version = "0.15.0", default-features = false }
+bevy_sprite = { version = "0.15.0", optional = true, default-features = false }
+bevy_transform = { version = "0.15.0", default-features = false }
+bevy_utils = { version = "0.15.0", default-features = false }
+bevy_window = { version = "0.15.0", default-features = false }
+bevy_color = { version = "0.15.0", default-features = false }
 crossbeam-channel = "0.5"
 
 [dev-dependencies]
-bevy = { version = "0.14.0", default-features = true, features = [
+bevy = { version = "0.15.0", default-features = true, features = [
     "default_font",
     "ktx2",
     "tonemapping_luts",
diff --git a/README.md b/README.md
index 9bc2877..b3e79c2 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.15 | 0.19             |
 | 0.14 | 0.18             |
 | 0.13 | 0.17             |
 | 0.12 | 0.16             |
diff --git a/benches/ray_mesh_intersection.rs b/benches/ray_mesh_intersection.rs
index ddbb05e..f6237ad 100644
--- a/benches/ray_mesh_intersection.rs
+++ b/benches/ray_mesh_intersection.rs
@@ -1,121 +1,130 @@
-use bevy::math::{Mat4, Vec3};
-use bevy_math::Ray3d;
-use bevy_mod_raycast::prelude::*;
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
-
-fn ptoxznorm(p: u32, size: u32) -> (f32, f32) {
-    let ij = (p / (size), p % (size));
-    (ij.0 as f32 / size as f32, ij.1 as f32 / size as f32)
-}
-
-struct SimpleMesh {
-    positions: Vec<[f32; 3]>,
-    normals: Vec<[f32; 3]>,
-    indices: Vec<u32>,
-}
-
-fn mesh_creation(vertices_per_side: u32) -> SimpleMesh {
-    let mut positions = Vec::new();
-    let mut normals = Vec::new();
-    for p in 0..vertices_per_side.pow(2) {
-        let xz = ptoxznorm(p, vertices_per_side);
-        positions.push([xz.0 - 0.5, 0.0, xz.1 - 0.5]);
-        normals.push([0.0, 1.0, 0.0]);
-    }
-
-    let mut indices = vec![];
-    for p in 0..vertices_per_side.pow(2) {
-        if p % (vertices_per_side) != vertices_per_side - 1
-            && p / (vertices_per_side) != vertices_per_side - 1
-        {
-            indices.extend_from_slice(&[p, p + 1, p + vertices_per_side]);
-            indices.extend_from_slice(&[p + vertices_per_side, p + 1, p + vertices_per_side + 1]);
-        }
-    }
-
-    SimpleMesh {
-        positions,
-        normals,
-        indices,
-    }
-}
-
-fn ray_mesh_intersection(c: &mut Criterion) {
-    let mut group = c.benchmark_group("ray_mesh_intersection");
-    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::Cull,
-                ));
-            });
-        });
-    }
-}
-
-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));
-
-    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(1.0, 0.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::Cull,
-                ));
-            });
-        });
-    }
-}
-
-criterion_group!(
-    benches,
-    ray_mesh_intersection,
-    ray_mesh_intersection_no_cull,
-    ray_mesh_intersection_no_intersection
-);
-criterion_main!(benches);
+use bevy::math::{Mat4, Vec3};
+use bevy_math::{Dir3, Ray3d};
+use bevy_mod_raycast::prelude::*;
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
+fn ptoxznorm(p: u32, size: u32) -> (f32, f32) {
+    let ij = (p / (size), p % (size));
+    (ij.0 as f32 / size as f32, ij.1 as f32 / size as f32)
+}
+
+struct SimpleMesh {
+    positions: Vec<[f32; 3]>,
+    normals: Vec<[f32; 3]>,
+    indices: Vec<u32>,
+}
+
+fn mesh_creation(vertices_per_side: u32) -> SimpleMesh {
+    let mut positions = Vec::new();
+    let mut normals = Vec::new();
+    for p in 0..vertices_per_side.pow(2) {
+        let xz = ptoxznorm(p, vertices_per_side);
+        positions.push([xz.0 - 0.5, 0.0, xz.1 - 0.5]);
+        normals.push([0.0, 1.0, 0.0]);
+    }
+
+    let mut indices = vec![];
+    for p in 0..vertices_per_side.pow(2) {
+        if p % (vertices_per_side) != vertices_per_side - 1
+            && p / (vertices_per_side) != vertices_per_side - 1
+        {
+            indices.extend_from_slice(&[p, p + 1, p + vertices_per_side]);
+            indices.extend_from_slice(&[p + vertices_per_side, p + 1, p + vertices_per_side + 1]);
+        }
+    }
+
+    SimpleMesh {
+        positions,
+        normals,
+        indices,
+    }
+}
+
+fn ray_mesh_intersection(c: &mut Criterion) {
+    let mut group = c.benchmark_group("ray_mesh_intersection");
+    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),
+                Dir3::from_xyz_unchecked(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::Cull,
+                ));
+            });
+        });
+    }
+}
+
+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),
+                Dir3::from_xyz_unchecked(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));
+
+    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),
+                Dir3::from_xyz_unchecked(1.0, 0.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::Cull,
+                ));
+            });
+        });
+    }
+}
+
+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 861027f..ba57255 100644
--- a/examples/minimal.rs
+++ b/examples/minimal.rs
@@ -16,9 +16,9 @@ fn main() {
 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 t = time.elapsed_secs();
     let pos = Vec3::new(t.sin(), (t * 1.5).cos() * 2.0, t.cos()) * 1.5 + RAY_DIST;
-    let dir = (RAY_DIST - pos).normalize();
+    let dir = Dir3::new(RAY_DIST - pos).unwrap();
     // 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);
@@ -29,12 +29,11 @@ fn setup(
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
-    commands.spawn(Camera3dBundle::default());
-    commands.spawn(PointLightBundle::default());
-    commands.spawn(PbrBundle {
-        mesh: meshes.add(Capsule3d::default()),
-        material: materials.add(Color::srgb(1.0, 1.0, 1.0)),
-        transform: Transform::from_translation(RAY_DIST),
-        ..default()
-    });
+    commands.spawn(Camera3d::default());
+    commands.spawn(PointLight::default());
+    commands.spawn((
+        Mesh3d(meshes.add(Capsule3d::default())),
+        MeshMaterial3d(materials.add(Color::srgb(1.0, 1.0, 1.0))),
+        Transform::from_translation(RAY_DIST),
+    ));
 }
diff --git a/examples/minimal_deferred.rs b/examples/minimal_deferred.rs
index 6b8602a..8342049 100644
--- a/examples/minimal_deferred.rs
+++ b/examples/minimal_deferred.rs
@@ -25,7 +25,7 @@ struct MyRaycastSet; // Groups raycast sources with meshes, can use `()` instead
 struct MovingRaycaster;
 
 fn move_ray(time: Res<Time>, mut query: Query<&mut Transform, With<MovingRaycaster>>) {
-    let t = time.elapsed_seconds();
+    let t = time.elapsed_secs();
     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);
@@ -36,22 +36,20 @@ fn setup(
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
-    commands.spawn(Camera3dBundle::default());
-    commands.spawn(PointLightBundle::default());
+    commands.spawn(Camera3d::default());
+    commands.spawn(PointLight::default());
     // Unlike the immediate mode API where the raycast is built every frame in a system, instead we
     // spawn an entity and mark it as a raycasting source, using its `GlobalTransform`.
     commands.spawn((
         MovingRaycaster,
-        SpatialBundle::default(),
+        Transform::default(),
+        Visibility::default(),
         RaycastSource::<MyRaycastSet>::new_transform_empty(),
     ));
     commands.spawn((
-        PbrBundle {
-            mesh: meshes.add(Capsule3d::default()),
-            material: materials.add(Color::srgb(1.0, 1.0, 1.0)),
-            transform: Transform::from_translation(RAY_DIST),
-            ..default()
-        },
+        Mesh3d(meshes.add(Capsule3d::default())),
+        MeshMaterial3d(materials.add(Color::srgb(1.0, 1.0, 1.0))),
+        Transform::from_translation(RAY_DIST),
         RaycastMesh::<MyRaycastSet>::default(), // Make this mesh ray cast-able
     ));
 }
diff --git a/examples/mouse_picking.rs b/examples/mouse_picking.rs
index cc51681..8d6d8d8 100644
--- a/examples/mouse_picking.rs
+++ b/examples/mouse_picking.rs
@@ -25,12 +25,11 @@ fn setup(
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
-    commands.spawn(Camera3dBundle::default());
-    commands.spawn(PointLightBundle::default());
-    commands.spawn(PbrBundle {
-        mesh: meshes.add(Sphere::default()),
-        material: materials.add(Color::from(css::GRAY)),
-        transform: Transform::from_xyz(0.0, 0.0, -5.0),
-        ..default()
-    });
+    commands.spawn(Camera3d::default());
+    commands.spawn(PointLight::default());
+    commands.spawn((
+        Mesh3d(meshes.add(Sphere::default())),
+        MeshMaterial3d(materials.add(Color::from(css::GRAY))),
+        Transform::from_xyz(0.0, 0.0, -5.0),
+    ));
 }
diff --git a/examples/mouse_picking_2d.rs b/examples/mouse_picking_2d.rs
index b76072c..2adec12 100644
--- a/examples/mouse_picking_2d.rs
+++ b/examples/mouse_picking_2d.rs
@@ -1,4 +1,4 @@
-use bevy::{color::palettes::css, prelude::*, sprite::MaterialMesh2dBundle};
+use bevy::{color::palettes::css, prelude::*};
 use bevy_mod_raycast::prelude::*;
 
 fn main() {
@@ -16,16 +16,13 @@ fn main() {
 fn setup(
     mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
-    mut materials: ResMut<Assets<ColorMaterial>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
-    commands.spawn((Camera2dBundle::default(), RaycastSource::<()>::new_cursor()));
+    commands.spawn((Camera2d::default(), RaycastSource::<()>::new_cursor()));
     commands.spawn((
-        MaterialMesh2dBundle {
-            mesh: meshes.add(Circle::default()).into(),
-            transform: Transform::default().with_scale(Vec3::splat(128.)),
-            material: materials.add(ColorMaterial::from(Color::from(css::PURPLE))),
-            ..default()
-        },
+        Mesh3d(meshes.add(Circle::default()).into()),
+        MeshMaterial3d(materials.add(Color::from(css::PURPLE))),
+        Transform::default().with_scale(Vec3::splat(128.)),
         RaycastMesh::<()>::default(), // Make this mesh ray cast-able;
     ));
 }
diff --git a/examples/mouse_picking_deferred.rs b/examples/mouse_picking_deferred.rs
index 072fba5..4748b61 100644
--- a/examples/mouse_picking_deferred.rs
+++ b/examples/mouse_picking_deferred.rs
@@ -22,17 +22,14 @@ fn setup(
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
     commands.spawn((
-        Camera3dBundle::default(),
+        Camera3d::default(),
         RaycastSource::<()>::new_cursor(), // Set this camera as a raycaster using the mouse cursor
     ));
-    commands.spawn(PointLightBundle::default());
+    commands.spawn(PointLight::default());
     commands.spawn((
-        PbrBundle {
-            mesh: meshes.add(Sphere::default()),
-            material: materials.add(Color::from(css::GRAY)),
-            transform: Transform::from_xyz(0.0, 0.0, -5.0),
-            ..default()
-        },
+        Mesh3d(meshes.add(Sphere::default())),
+        MeshMaterial3d(materials.add(Color::from(css::GRAY))),
+        Transform::from_xyz(0.0, 0.0, -5.0),
         RaycastMesh::<()>::default(), // Make this mesh ray cast-able;
     ));
 }
diff --git a/examples/reflecting_laser.rs b/examples/reflecting_laser.rs
index 5e2fcbb..15a9287 100644
--- a/examples/reflecting_laser.rs
+++ b/examples/reflecting_laser.rs
@@ -3,7 +3,7 @@
 
 use std::f32::consts::{FRAC_PI_2, PI};
 
-use bevy::{color::palettes::css, core_pipeline::bloom::BloomSettings, math::vec3, prelude::*};
+use bevy::{color::palettes::css, core_pipeline::tonemapping::Tonemapping, math::vec3, prelude::*};
 use bevy_mod_raycast::prelude::*;
 
 fn main() {
@@ -30,11 +30,11 @@ fn bouncing_raycast(
     time: Res<Time>,
     cursor_ray: Res<CursorRay>,
 ) {
-    let t = ((time.elapsed_seconds() - 4.0).max(0.0) * LASER_SPEED).cos() * std::f32::consts::PI;
+    let t = ((time.elapsed_secs() - 4.0).max(0.0) * LASER_SPEED).cos() * std::f32::consts::PI;
     let ray_pos = Vec3::new(t.sin(), (3.0 * t).cos() * 0.5, t.cos()) * 0.5;
-    let ray_dir = (-ray_pos).normalize();
+    let ray_dir = Dir3::new(-ray_pos).unwrap();
     let ray = Ray3d::new(ray_pos, ray_dir);
-    gizmos.sphere(ray_pos, Quat::IDENTITY, 0.1, Color::WHITE);
+    gizmos.sphere(Isometry3d::from_translation(ray_pos), 0.1, Color::WHITE);
     bounce_ray(ray, &mut raycast, &mut gizmos, Color::from(css::RED));
 
     if let Some(cursor_ray) = **cursor_ray {
@@ -56,8 +56,7 @@ fn bounce_ray(mut ray: Ray3d, raycast: &mut Raycast, gizmos: &mut Gizmos, color:
             let bright = 1.0 + 10.0 * (1.0 - i as f32 / MAX_BOUNCES as f32);
             intersections.push((hit.position(), Color::BLACK.mix(&color, bright)));
             gizmos.sphere(
-                hit.position(),
-                Quat::IDENTITY,
+                Isometry3d::from_translation(hit.position()),
                 0.005,
                 Color::BLACK.mix(&color, bright * 2.0),
             );
@@ -79,32 +78,30 @@ fn setup_scene(
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
-    commands.spawn(DirectionalLightBundle {
-        transform: Transform::from_rotation(Quat::from_euler(EulerRot::XYZ, -0.1, 0.2, 0.0)),
-        ..default()
-    });
     commands.spawn((
-        Camera3dBundle {
-            transform: Transform::from_xyz(1.5, 1.5, 1.5).looking_at(Vec3::ZERO, Vec3::Y),
-            camera: Camera {
-                hdr: true,
-                ..default()
-            },
-            tonemapping: bevy::core_pipeline::tonemapping::Tonemapping::TonyMcMapface,
+        DirectionalLight::default(),
+        Transform::from_rotation(Quat::from_euler(EulerRot::XYZ, -0.1, 0.2, 0.0)),
+    ));
+    commands.spawn((
+        Transform::from_xyz(1.5, 1.5, 1.5).looking_at(Vec3::ZERO, Vec3::Y),
+        Camera3d::default(),
+        Camera {
+            hdr: true,
             ..default()
         },
-        BloomSettings::default(),
+        Tonemapping::TonyMcMapface,
     ));
     // Make a box of planes facing inward so the laser gets trapped inside:
-    let plane = PbrBundle {
-        mesh: meshes.add(Plane3d::default()),
-        material: materials.add(Color::from(css::GRAY).with_alpha(0.01)),
-        ..default()
-    };
-    let pbr_bundle = move |translation, rotation| PbrBundle {
-        transform: Transform::from_translation(translation)
-            .with_rotation(Quat::from_scaled_axis(rotation)),
-        ..plane.clone()
+    let plane = (
+        Mesh3d(meshes.add(Plane3d::default())),
+        MeshMaterial3d(materials.add(Color::from(css::GRAY).with_alpha(0.01))),
+    );
+    let pbr_bundle = move |translation, rotation| {
+        (
+            Transform::from_translation(translation)
+                .with_rotation(Quat::from_scaled_axis(rotation)),
+            plane.clone(),
+        )
     };
     commands.spawn(pbr_bundle(vec3(0.0, 0.5, 0.0), Vec3::X * PI));
     commands.spawn(pbr_bundle(vec3(0.0, -0.5, 0.0), Vec3::ZERO));
diff --git a/examples/simplified_mesh.rs b/examples/simplified_mesh.rs
index e1fbe02..a5cc23e 100644
--- a/examples/simplified_mesh.rs
+++ b/examples/simplified_mesh.rs
@@ -33,89 +33,57 @@ fn setup_scene(
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
-    commands.spawn(Camera3dBundle::default());
+    commands.spawn(Camera3d::default());
     commands.spawn((
-        PbrBundle {
-            // This is a very complex mesh that will be hard to raycast on
-            mesh: meshes.add(Sphere::default().mesh().uv(1000, 1000)),
-            material: materials.add(Color::srgb(1.0, 1.0, 1.0)),
-            transform: Transform::from_translation(Vec3::new(0.0, 0.0, -5.0)),
-            ..default()
-        },
+        // This is a very complex mesh that will be hard to raycast on
+        Mesh3d(meshes.add(Sphere::default().mesh().uv(1000, 1000))),
+        MeshMaterial3d(materials.add(Color::srgb(1.0, 1.0, 1.0))),
+        Transform::from_translation(Vec3::new(0.0, 0.0, -5.0)),
         SimplifiedMesh {
             mesh: meshes.add(Sphere::default()),
         },
     ));
-    commands.spawn(PointLightBundle {
-        transform: Transform::from_translation(Vec3::new(4.0, 8.0, 4.0)),
-        ..default()
-    });
+    commands.spawn((
+        PointLight::default(),
+        Transform::from_translation(Vec3::new(4.0, 8.0, 4.0)),
+    ));
 }
 
 // Set up UI to show status of simplified mesh
 fn setup_ui(mut commands: Commands) {
     commands
-        .spawn(NodeBundle {
-            style: Style {
+        .spawn((
+            Node {
                 align_self: AlignSelf::FlexStart,
                 flex_direction: FlexDirection::Column,
                 ..default()
             },
-            background_color: Color::NONE.into(),
-            ..default()
-        })
+            BackgroundColor(Color::NONE.into()),
+        ))
         .with_children(|ui| {
-            ui.spawn(TextBundle {
-                text: Text {
-                    sections: vec![
-                        TextSection {
-                            value: "Press spacebar to toggle - FPS: ".to_string(),
-                            style: TextStyle {
-                                font_size: 30.0,
-                                color: Color::WHITE,
-                                ..default()
-                            },
-                        },
-                        TextSection {
-                            value: "".to_string(),
-                            style: TextStyle {
-                                font_size: 30.0,
-                                color: Color::WHITE,
-                                ..default()
-                            },
-                        },
-                    ],
+            ui.spawn((
+                Text::new("Press spacebar to toggle - FPS: "),
+                TextFont {
+                    font_size: 30.0,
                     ..default()
                 },
-                ..default()
-            })
-            .insert(FpsText);
+                TextColor(Color::WHITE.into()),
+            ))
+            .with_child((FpsText, TextSpan::new("")));
 
-            ui.spawn(TextBundle {
-                text: Text {
-                    sections: vec![
-                        TextSection {
-                            value: "Simplified Mesh: ".to_string(),
-                            style: TextStyle {
-                                font_size: 30.0,
-                                color: Color::WHITE,
-                                ..default()
-                            },
-                        },
-                        TextSection {
-                            value: "ON".to_string(),
-                            style: TextStyle {
-                                font_size: 30.0,
-                                color: css::GREEN.into(),
-                                ..default()
-                            },
-                        },
-                    ],
+            ui.spawn((
+                Text::new("Simplified Mesh: "),
+                TextFont {
+                    font_size: 30.0,
                     ..default()
                 },
-                ..default()
-            })
-            .insert(SimplifiedStatus);
+                TextColor(Color::WHITE.into()),
+            ))
+            .with_child((
+                SimplifiedStatus,
+                TextSpan::new("ON"),
+                TextColor(css::GREEN.into()),
+            ));
         });
 }
 
@@ -128,36 +96,36 @@ struct FpsText;
 // Insert or remove SimplifiedMesh component from the mesh being raycasted on.
 fn manage_simplified_mesh(
     mut commands: Commands,
-    query: Query<(Entity, Option<&SimplifiedMesh>), With<Handle<Mesh>>>,
-    mut status_query: Query<&mut Text, With<SimplifiedStatus>>,
+    query: Query<(Entity, Option<&SimplifiedMesh>), With<Mesh3d>>,
+    mut status_query: Query<(&mut TextSpan, &mut TextColor), With<SimplifiedStatus>>,
     keyboard: Res<ButtonInput<KeyCode>>,
     mut meshes: ResMut<Assets<Mesh>>,
 ) {
     if keyboard.just_pressed(KeyCode::Space) {
         if let Ok((entity, simplified_mesh)) = query.get_single() {
-            if let Ok(mut text) = status_query.get_single_mut() {
+            if let Ok((mut text, mut color)) = status_query.get_single_mut() {
                 if simplified_mesh.is_none() {
                     commands.entity(entity).insert(SimplifiedMesh {
                         mesh: meshes.add(Sphere::default()),
                     });
-                    text.sections[1].value = "ON".to_string();
-                    text.sections[1].style.color = css::GREEN.into();
+                    text.0 = "ON".to_string();
+                    color.0 = css::GREEN.into();
                 } else {
                     commands.entity(entity).remove::<SimplifiedMesh>();
-                    text.sections[1].value = "OFF".to_string();
-                    text.sections[1].style.color = css::RED.into();
+                    text.0 = "OFF".to_string();
+                    color.0 = css::RED.into();
                 }
             }
         }
     }
 }
 
-fn update_fps(diagnostics: Res<DiagnosticsStore>, mut query: Query<&mut Text, With<FpsText>>) {
+fn update_fps(diagnostics: Res<DiagnosticsStore>, mut query: Query<&mut TextSpan, With<FpsText>>) {
     for mut text in &mut query {
         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);
+                text.0 = format!("{:.2}", average);
             }
         }
     }
diff --git a/examples/stress_test.rs b/examples/stress_test.rs
index bd2f23b..e80174f 100644
--- a/examples/stress_test.rs
+++ b/examples/stress_test.rs
@@ -31,30 +31,28 @@ struct MyRaycastSet;
 
 fn setup_scene(mut commands: Commands, asset_server: Res<AssetServer>) {
     commands.insert_resource(RaycastPluginState::<MyRaycastSet>::default().with_debug_cursor());
-    commands.spawn(DirectionalLightBundle {
-        transform: Transform::from_rotation(Quat::from_euler(EulerRot::XYZ, 20.0, 20.0, 0.0)),
-        directional_light: DirectionalLight::default(),
-        ..default()
-    });
+    commands.spawn((
+        Transform::from_rotation(Quat::from_euler(EulerRot::XYZ, 20.0, 20.0, 0.0)),
+        DirectionalLight::default(),
+    ));
 
     commands.spawn((
-        Camera3dBundle::default(),
+        Camera3d::default(),
         RaycastSource::<MyRaycastSet>::new_cursor(),
     ));
 
     let mut i = 0;
     for x in -2..=2 {
         for k in -210..-10 {
-            commands.spawn((bevy::prelude::SceneBundle {
-                scene: asset_server.load("models/monkey/Monkey.gltf#Scene0"),
-                transform: Transform::from_translation(Vec3::new(
+            commands.spawn((
+                SceneRoot(asset_server.load("models/monkey/Monkey.gltf#Scene0")),
+                Transform::from_translation(Vec3::new(
                     x as f32 * k as f32 * -2.0,
                     0.0,
                     k as f32 * 3.0,
                 ))
                 .with_scale(Vec3::splat((k as f32).abs().sub(5.0)) * 0.6),
-                ..default()
-            },));
+            ));
             i += 1;
         }
     }
@@ -64,7 +62,7 @@ fn setup_scene(mut commands: Commands, asset_server: Res<AssetServer>) {
 #[allow(clippy::type_complexity)]
 fn make_scene_pickable(
     mut commands: Commands,
-    mesh_query: Query<Entity, (With<Handle<Mesh>>, Without<RaycastMesh<MyRaycastSet>>)>,
+    mesh_query: Query<Entity, (With<Mesh3d>, Without<RaycastMesh<MyRaycastSet>>)>,
 ) {
     for entity in &mesh_query {
         commands
@@ -75,44 +73,54 @@ fn make_scene_pickable(
 
 // Set up UI to show status of bounding volume
 fn setup_ui(mut commands: Commands) {
-    let text_section = |text: &'static str| TextSection {
-        value: text.into(),
-        style: TextStyle {
-            font_size: 40.0,
-            color: Color::WHITE,
-            ..default()
-        },
-    };
-
     commands
-        .spawn(NodeBundle {
-            style: Style {
+        .spawn((
+            Node {
                 align_self: AlignSelf::FlexStart,
                 flex_direction: FlexDirection::Column,
                 ..default()
             },
-            background_color: Color::NONE.into(),
-            ..default()
-        })
+            BackgroundColor(Color::NONE.into()),
+        ))
         .with_children(|ui| {
-            ui.spawn(TextBundle::from_sections([text_section(
-                "Toggle with number keys",
-            )]));
-            ui.spawn(TextBundle::from_sections([
-                text_section("(1) AABB Culling: "),
-                text_section(""),
-            ]))
-            .insert(BoundVolStatus);
-            ui.spawn(TextBundle::from_sections([
-                text_section("(2) Early Exit: "),
-                text_section(""),
-            ]))
-            .insert(EarlyExitStatus);
-            ui.spawn(TextBundle::from_sections([
-                text_section("FPS: "),
-                text_section(""),
-            ]))
-            .insert(FpsText);
+            ui.spawn((
+                Text::new("Toggle with number keys"),
+                TextFont {
+                    font_size: 40.0,
+                    ..default()
+                },
+                TextColor(Color::WHITE.into()),
+            ));
+
+            ui.spawn((
+                Text::new("(1) AABB Culling: "),
+                TextFont {
+                    font_size: 40.0,
+                    ..default()
+                },
+                TextColor(Color::WHITE.into()),
+            ))
+            .with_child((TextSpan::new(""), BoundVolStatus));
+
+            ui.spawn((
+                Text::new("(2) Early Exit: "),
+                TextFont {
+                    font_size: 40.0,
+                    ..default()
+                },
+                TextColor(Color::WHITE.into()),
+            ))
+            .with_child((TextSpan::new(""), EarlyExitStatus));
+
+            ui.spawn((
+                Text::new("FPS: "),
+                TextFont {
+                    font_size: 40.0,
+                    ..default()
+                },
+                TextColor(Color::WHITE.into()),
+            ))
+            .with_child((TextSpan::new(""), FpsText));
         });
 }
 
@@ -131,10 +139,16 @@ fn update_status(
     keyboard: Res<ButtonInput<KeyCode>>,
     mut enabled: Local<Option<(bool, bool)>>,
     // Bounding toggle
-    mut bound_status: Query<&mut Text, (With<BoundVolStatus>, Without<EarlyExitStatus>)>,
+    mut bound_status: Query<
+        (&mut TextSpan, &mut TextColor),
+        (With<BoundVolStatus>, Without<EarlyExitStatus>),
+    >,
     mut aabbs: Query<(Entity, &mut Aabb), With<RaycastMesh<MyRaycastSet>>>,
     // Early exit toggle
-    mut exit_status: Query<&mut Text, (Without<BoundVolStatus>, With<EarlyExitStatus>)>,
+    mut exit_status: Query<
+        (&mut TextSpan, &mut TextColor),
+        (Without<BoundVolStatus>, With<EarlyExitStatus>),
+    >,
     mut sources: Query<&mut RaycastSource<MyRaycastSet>>,
 ) {
     if enabled.is_none() {
@@ -142,13 +156,14 @@ fn update_status(
     }
     let enabled = enabled.as_mut().unwrap();
 
-    let bool_to_text = |is_enabled: bool, text: &mut Text| {
+    let bool_to_text = |is_enabled: bool, status: (Mut<'_, TextSpan>, Mut<'_, TextColor>)| {
+        let (mut text, mut color) = status;
         if is_enabled {
-            text.sections[1].value = "ON".to_string();
-            text.sections[1].style.color = css::GREEN.into();
+            text.0 = "ON".to_string();
+            color.0 = css::GREEN.into();
         } else {
-            text.sections[1].value = "OFF".to_string();
-            text.sections[1].style.color = css::RED.into();
+            text.0 = "OFF".to_string();
+            color.0 = css::RED.into();
         }
     };
 
@@ -164,7 +179,7 @@ fn update_status(
             }
         }
     }
-    bool_to_text(enabled.0, bound_status.single_mut().as_mut());
+    bool_to_text(enabled.0, bound_status.single_mut());
 
     if keyboard.just_pressed(KeyCode::Digit2) {
         enabled.1 = !enabled.1;
@@ -172,15 +187,15 @@ fn update_status(
             source.should_early_exit = enabled.1;
         }
     }
-    bool_to_text(enabled.1, exit_status.single_mut().as_mut());
+    bool_to_text(enabled.1, exit_status.single_mut());
 }
 
-fn update_fps(diagnostics: Res<DiagnosticsStore>, mut query: Query<&mut Text, With<FpsText>>) {
+fn update_fps(diagnostics: Res<DiagnosticsStore>, mut query: Query<&mut TextSpan, With<FpsText>>) {
     for mut text in &mut query {
         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);
+                text.0 = format!("{:.2}", average);
             }
         }
     }
diff --git a/src/deferred.rs b/src/deferred.rs
index ae1bf84..53e3a3f 100644
--- a/src/deferred.rs
+++ b/src/deferred.rs
@@ -519,7 +519,8 @@ pub mod debug {
         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, css::BLUE);
-            gizmos.sphere(ray.origin, orientation, 0.1, css::BLUE);
+            let point = bevy_math::Isometry3d::new(ray.origin, orientation);
+            gizmos.sphere(point, 0.1, css::BLUE);
         }
 
         for (is_first, intersection) in sources.iter().flat_map(|m| {
@@ -534,12 +535,10 @@ pub mod debug {
                 false => css::PINK,
             };
             gizmos.ray(intersection.position(), intersection.normal(), color);
-            gizmos.circle(
-                intersection.position(),
-                Dir3::new_unchecked(intersection.normal().normalize()),
-                0.1,
-                color,
-            );
+            let orientation =
+                Quat::from_rotation_arc(Vec3::NEG_Z, intersection.normal().normalize());
+            let point = bevy_math::Isometry3d::new(intersection.position(), orientation);
+            gizmos.circle(point, 0.1, color);
             gizmos.circle_2d(intersection.position().truncate(), 10.0, color);
         }
     }
diff --git a/src/immediate.rs b/src/immediate.rs
index a90ac7a..6198de8 100644
--- a/src/immediate.rs
+++ b/src/immediate.rs
@@ -78,7 +78,7 @@ impl<'a> RaycastSettings<'a> {
     }
 }
 
-impl<'a> Default for RaycastSettings<'a> {
+impl Default for RaycastSettings<'_> {
     fn default() -> Self {
         Self {
             visibility: RaycastVisibility::MustBeVisibleAndInView,
@@ -89,9 +89,9 @@ impl<'a> Default for RaycastSettings<'a> {
 }
 
 #[cfg(feature = "2d")]
-type MeshFilter = Or<(With<Handle<Mesh>>, With<bevy_sprite::Mesh2dHandle>)>;
+type MeshFilter = Or<(With<Mesh3d>, With<Mesh2d>)>;
 #[cfg(not(feature = "2d"))]
-type MeshFilter = With<Handle<Mesh>>;
+type MeshFilter = With<Mesh3d>;
 
 /// Add this raycasting [`SystemParam`] to your system to raycast into the world with an
 /// immediate-mode API. Call `cast_ray` to immediately perform a raycast and get a result. Under the
@@ -107,7 +107,7 @@ type MeshFilter = With<Handle<Mesh>>;
 /// # use bevy_mod_raycast::prelude::*;
 /// # use bevy::prelude::*;
 /// fn raycast_system(mut raycast: Raycast) {
-///     let ray = Ray3d::new(Vec3::ZERO, Vec3::X);
+///     let ray = Ray3d::new(Vec3::ZERO, Dir3::X);
 ///     let hits = raycast.cast_ray(ray, &RaycastSettings::default());
 /// }
 /// ```
@@ -123,7 +123,7 @@ type MeshFilter = With<Handle<Mesh>>;
 /// # #[derive(Component)]
 /// # struct Foo;
 /// fn raycast_system(mut raycast: Raycast, foo_query: Query<(), With<Foo>>) {
-///     let ray = Ray3d::new(Vec3::ZERO, Vec3::X);
+///     let ray = Ray3d::new(Vec3::ZERO, Dir3::X);
 ///
 ///     // Only raycast against entities with the `Foo` component.
 ///     let filter = |entity| foo_query.contains(entity);
@@ -168,7 +168,7 @@ pub struct Raycast<'w, 's> {
         'w,
         's,
         (
-            Read<Handle<Mesh>>,
+            Read<Mesh3d>,
             Option<Read<SimplifiedMesh>>,
             Option<Read<NoBackfaceCulling>>,
             Read<GlobalTransform>,
@@ -180,14 +180,14 @@ pub struct Raycast<'w, 's> {
         'w,
         's,
         (
-            Read<bevy_sprite::Mesh2dHandle>,
+            Read<Mesh2d>,
             Option<Read<SimplifiedMesh>>,
             Read<GlobalTransform>,
         ),
     >,
 }
 
-impl<'w, 's> Raycast<'w, 's> {
+impl Raycast<'_, '_> {
     #[cfg(feature = "debug")]
     /// Like [`Raycast::cast_ray`], but debug-draws the ray and intersection.
     pub fn debug_cast_ray(
@@ -197,11 +197,11 @@ impl<'w, 's> Raycast<'w, 's> {
         gizmos: &mut Gizmos,
     ) -> &[(Entity, IntersectionData)] {
         use bevy_color::palettes::css;
-        use bevy_math::Dir3;
 
         let orientation = Quat::from_rotation_arc(Vec3::NEG_Z, *ray.direction);
         gizmos.ray(ray.origin, *ray.direction, css::BLUE);
-        gizmos.sphere(ray.origin, orientation, 0.1, css::BLUE);
+        let point = bevy_math::Isometry3d::new(ray.origin, orientation);
+        gizmos.sphere(point, 0.1, css::BLUE);
 
         let hits = self.cast_ray(ray, settings);
 
@@ -216,12 +216,10 @@ impl<'w, 's> Raycast<'w, 's> {
                 false => css::PINK,
             };
             gizmos.ray(intersection.position(), intersection.normal(), color);
-            gizmos.circle(
-                intersection.position(),
-                Dir3::new_unchecked(intersection.normal().normalize()),
-                0.1,
-                color,
-            );
+            let orientation =
+                Quat::from_rotation_arc(Vec3::NEG_Z, intersection.normal().normalize());
+            let point = bevy_math::Isometry3d::new(intersection.position(), orientation);
+            gizmos.circle(point, 0.1, color);
         }
 
         if let Some(hit) = hits.first() {
diff --git a/src/lib.rs b/src/lib.rs
index 2b4df68..14f48cb 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -5,7 +5,7 @@
 //! use bevy_mod_raycast::prelude::*;
 //!
 //! fn raycast_system(mut raycast: Raycast) {
-//!     let ray = Ray3d::new(Vec3::ZERO, Vec3::X);
+//!     let ray = Ray3d::new(Vec3::ZERO, Dir3::X);
 //!     let hits = raycast.cast_ray(ray, &RaycastSettings::default());
 //! }
 //! ```
diff --git a/src/primitives.rs b/src/primitives.rs
index 68d9aa6..807a151 100644
--- a/src/primitives.rs
+++ b/src/primitives.rs
@@ -143,7 +143,7 @@ pub mod rays {
         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)
+        Ray3d::new(source_origin, Dir3::new(ray_direction).unwrap())
     }
 
     pub fn ray_from_screenspace(
@@ -159,6 +159,7 @@ pub mod rays {
         camera
             .viewport_to_world(camera_transform, viewport_pos)
             .map(Ray3d::from)
+            .ok()
     }
 
     /// Checks if the ray intersects with an AABB of a mesh, returning `[near, far]` if it does.
diff --git a/src/raycast.rs b/src/raycast.rs
index 83bdef9..26d81ad 100644
--- a/src/raycast.rs
+++ b/src/raycast.rs
@@ -1,4 +1,4 @@
-use bevy_math::{Mat4, Ray3d, Vec3, Vec3A};
+use bevy_math::{Dir3, Mat4, Ray3d, Vec3, Vec3A};
 use bevy_render::{
     mesh::{Indices, Mesh, VertexAttributeValues},
     render_resource::PrimitiveTopology,
@@ -102,7 +102,7 @@ pub fn ray_mesh_intersection(
 
     let mesh_space_ray = Ray3d::new(
         world_to_mesh.transform_point3(ray.origin),
-        world_to_mesh.transform_vector3(*ray.direction),
+        Dir3::new(world_to_mesh.transform_vector3(*ray.direction)).unwrap(),
     );
 
     if let Some(indices) = indices {
@@ -329,7 +329,7 @@ mod tests {
     #[test]
     fn raycast_triangle_mt() {
         let triangle = [V0.into(), V1.into(), V2.into()];
-        let ray = Ray3d::new(Vec3::ZERO, Vec3::X);
+        let ray = Ray3d::new(Vec3::ZERO, Dir3::X);
         let result = ray_triangle_intersection(&ray, &triangle, Backfaces::Include);
         assert!(result.unwrap().distance - 1.0 <= f32::EPSILON);
     }
@@ -337,7 +337,7 @@ mod tests {
     #[test]
     fn raycast_triangle_mt_culling() {
         let triangle = [V2.into(), V1.into(), V0.into()];
-        let ray = Ray3d::new(Vec3::ZERO, Vec3::X);
+        let ray = Ray3d::new(Vec3::ZERO, Dir3::X);
         let result = ray_triangle_intersection(&ray, &triangle, Backfaces::Cull);
         assert!(result.is_none());
     }