0.18.0-rc.0 setup

CHANGELOG.md

@@ -1,3 +1,9 @@
+# 0.18.0
+
+- Changed: updated to Bevy 0.14.
+- Changed: `DefaultPlugin` renamed `CursorRayPlugin` to reflect what it actually does.
+- Removed: all primitive raycasts have been removed. Users should use `bevy_math` instead.
+
 # 0.17.0
 
 Raycasting is now 20-50% faster.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bevy_mod_raycast"
-version = "0.17.0"
+version = "0.18.0-rc.0"
 authors = ["Aevyrie <aevyrie@gmail.com>"]
 edition = "2021"
 license = "MIT"

examples/mouse_picking.rs

@@ -8,7 +8,7 @@ use bevy_mod_raycast::prelude::*;
 fn main() {
  App::new()
  .add_plugins(DefaultPlugins.set(bevy_mod_raycast::low_latency_window_plugin()))
- .add_plugins(DefaultRaycastingPlugin)
+ .add_plugins(CursorRayPlugin)
  .add_systems(Startup, setup)
  .add_systems(Update, raycast)
  .run();

examples/reflecting_laser.rs

@@ -10,7 +10,7 @@ fn main() {
  App::new()
  .add_plugins((
  DefaultPlugins.set(bevy_mod_raycast::low_latency_window_plugin()),
- DefaultRaycastingPlugin,
+ CursorRayPlugin,
  ))
  .add_systems(Startup, setup_scene)
  .add_systems(Update, bouncing_raycast)

examples/simplified_mesh.rs

@@ -13,7 +13,7 @@ fn main() {
  App::new()
  .add_plugins((
  DefaultPlugins.set(bevy_mod_raycast::low_latency_window_plugin()),
- DefaultRaycastingPlugin,
+ CursorRayPlugin,
  FrameTimeDiagnosticsPlugin,
  ))
  .add_systems(Startup, (setup_scene, setup_ui))

src/cursor.rs

@@ -0,0 +1,62 @@
+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_window::Window;
+
+use crate::ray_from_screenspace;
+
+/// Automatically generates a ray in world space corresponding to the mouse cursor, and stores it in
+/// [`CursorRay`].
+#[derive(Default)]
+pub struct CursorRayPlugin;
+impl Plugin for CursorRayPlugin {
+ fn build(&self, app: &mut App) {
+ app.add_systems(First, update_cursor_ray)
+ .add_systems(
+ PostUpdate,
+ update_cursor_ray.after(bevy_transform::TransformSystem::TransformPropagate),
+ )
+ .init_resource::<CursorRay>();
+ }
+}
+
+/// Holds the latest cursor position as a 3d ray.
+///
+/// Requires the [`CursorRayPlugin`] is added to your app. This is updated in both [`First`] and
+/// [`PostUpdate`]. The ray built in `First` will have the latest cursor position, but will not
+/// account for any updates to camera position done in [`Update`]. The ray built in `PostUpdate`
+/// will account for the camera position being updated and any camera transform propagation.
+#[derive(Resource, Default, Deref)]
+pub struct CursorRay(pub Option<Ray3d>);
+
+/// Updates the [`CursorRay`] every frame.
+pub fn update_cursor_ray(
+ primary_window: Query<Entity, With<bevy_window::PrimaryWindow>>,
+ windows: Query<&Window>,
+ cameras: Query<(&Camera, &GlobalTransform)>,
+ mut cursor_ray: ResMut<CursorRay>,
+) {
+ cursor_ray.0 = cameras
+ .iter()
+ .filter_map(|(camera, transform)| {
+ if let bevy_render::camera::RenderTarget::Window(window_ref) = camera.target {
+ Some(((camera, transform), window_ref))
+ } else {
+ None
+ }
+ })
+ .filter_map(|(cam, window_ref)| {
+ window_ref
+ .normalize(primary_window.get_single().ok())
+ .map(|window_ref| (cam, window_ref.entity()))
+ })
+ .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)| {
+ ray_from_screenspace(cursor, camera, transform, window)
+ })
+ .next();
+}

src/deferred.rs

@@ -350,11 +350,6 @@ 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(intersects_primitive(self.ray?, shape)?.into())
- }
-
  /// Get a copy of the ray cast source's ray.
  pub fn get_ray(&self) -> Option<Ray3d> {
  self.ray

src/lib.rs

@@ -17,15 +17,17 @@
 //! The plugin provides two ways of raycasting:
 //! - An [immediate-mode API](immediate), which allows you to raycast into the scene on-demand in
 //! any system. Intersections are returned immediately as a sorted `Vec`.
-//! - A [deferred API](deferred), where raycasts are performed once every frame based on
-//! entities tagged with specific components. Intersections can be queried from the ECS.
+//! - A [deferred API](deferred), where raycasts are performed once every frame based on entities
+//! tagged with specific components. Intersections can be queried from the ECS.
+//!
+//! The plugin also provides the [`CursorRayPlugin`] for automatically generating a world space 3D
+//! ray corresponding to the mouse cursor. This is useful for mouse picking.
 //!
 //! ## Choosing an API
 //!
-//! While the deferred API requires adding components on entities, in return it's generally
-//! more "hands-off". Once you add the components to entities, the plugin will run raycasts for you
-//! every frame, and you can query your [`RaycastSource`]s to see what they have intersected that
-//! frame.
+//! While the deferred API requires adding components on entities, in return it's generally more
+//! "hands-off". Once you add the components to entities, the plugin will run raycasts for you every
+//! frame, and you can query your [`RaycastSource`]s to see what they have intersected that frame.
 //!
 //! You can also think of this as being the "declarative" API. Instead of defining how the raycast
 //! happens, you instead describe what you want. For example, "this entity should cast rays in the
@@ -52,85 +54,25 @@
 
 #![allow(clippy::type_complexity)]
 
+pub mod cursor;
 pub mod deferred;
 pub mod immediate;
 pub mod markers;
 pub mod primitives;
 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;
-use bevy_window::Window;
 
 #[allow(unused_imports)] // Needed for docs
 use prelude::*;
 
 pub mod prelude {
- pub use crate::{
- deferred::*, immediate::*, markers::*, primitives::*, raycast::*, CursorRay,
- DefaultRaycastingPlugin,
- };
+ pub use crate::{cursor::*, deferred::*, immediate::*, markers::*, primitives::*, raycast::*};
 
  #[cfg(feature = "debug")]
  pub use crate::debug::*;
 }
 
-#[derive(Default)]
-pub struct DefaultRaycastingPlugin;
-impl Plugin for DefaultRaycastingPlugin {
- fn build(&self, app: &mut App) {
- app.add_systems(First, update_cursor_ray)
- .add_systems(
- PostUpdate,
- update_cursor_ray.after(bevy_transform::TransformSystem::TransformPropagate),
- )
- .init_resource::<CursorRay>();
- }
-}
-
-/// Holds the latest cursor position as a 3d ray.
-///
-/// Requires the [`DefaultRaycastingPlugin`] is added to your app. This is updated in both [`First`]
-/// and [`PostUpdate`]. The ray built in `First` will have the latest cursor position, but will not
-/// account for any updates to camera position done in [`Update`]. The ray built in `PostUpdate`
-/// will account for the camera position being updated and any camera transform propagation.
-#[derive(Resource, Default, Deref)]
-pub struct CursorRay(pub Option<Ray3d>);
-
-/// Updates the [`CursorRay`] every frame.
-pub fn update_cursor_ray(
- primary_window: Query<Entity, With<bevy_window::PrimaryWindow>>,
- windows: Query<&Window>,
- cameras: Query<(&Camera, &GlobalTransform)>,
- mut cursor_ray: ResMut<CursorRay>,
-) {
- cursor_ray.0 = cameras
- .iter()
- .filter_map(|(camera, transform)| {
- if let bevy_render::camera::RenderTarget::Window(window_ref) = camera.target {
- Some(((camera, transform), window_ref))
- } else {
- None
- }
- })
- .filter_map(|(cam, window_ref)| {
- window_ref
- .normalize(primary_window.get_single().ok())
- .map(|window_ref| (cam, window_ref.entity()))
- })
- .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)| {
- ray_from_screenspace(cursor, camera, transform, window)
- })
- .next();
-}
-
 /// Used for examples to reduce picking latency. Not relevant code for the examples.
 #[doc(hidden)]
 #[allow(dead_code)]

src/primitives.rs

@@ -3,11 +3,6 @@ use bevy_reflect::Reflect;
 
 pub use rays::*;
 
-#[non_exhaustive]
-pub enum Primitive3d {
- Plane { point: Vec3, normal: Vec3 },
-}
-
 #[derive(Debug, Clone, Reflect)]
 pub struct IntersectionData {
  position: Vec3,
@@ -90,7 +85,6 @@ impl IntersectionData {
 /// Encapsulates Ray3D, preventing use of struct literal syntax. This allows us to guarantee that
 /// the `Ray3d` direction is normalized, because it can only be instantiated with the constructor.
 pub mod rays {
- use super::Primitive3d;
  use bevy_math::{prelude::*, Ray3d, Vec3A};
  use bevy_render::{camera::Camera, primitives::Aabb};
  use bevy_transform::components::GlobalTransform;
@@ -207,29 +201,4 @@ pub mod rays {
  }
  Some([hit_near, hit_far])
  }
-
- /// 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
- }
- }
- }
- }
 }