Mirrors/bevy

mirror of https://github.com/bevyengine/bevy synced 2024-11-24 21:53:07 +00:00

No description

Find a file

Joona Aalto 0e30b68b20 Add mesh picking backend and `MeshRayCast` system parameter (#15800 ) # Objective Closes #15545. `bevy_picking` supports UI and sprite picking, but not mesh picking. Being able to pick meshes would be extremely useful for various games, tools, and our own examples, as well as scene editors and inspectors. So, we need a mesh picking backend! Luckily, [`bevy_mod_picking`](https://github.com/aevyrie/bevy_mod_picking) (which `bevy_picking` is based on) by @aevyrie already has a [backend for it](`74f0c3c0fb/backends/bevy_picking_raycast/src/lib.rs`) using [`bevy_mod_raycast`](https://github.com/aevyrie/bevy_mod_raycast). As a side product of adding mesh picking, we also get support for performing ray casts on meshes! ## Solution Upstream a large chunk of the immediate-mode ray casting functionality from `bevy_mod_raycast`, and add a mesh picking backend based on `bevy_mod_picking`. Huge thanks to @aevyrie who did all the hard work on these incredible crates! All meshes are pickable by default. Picking can be disabled for individual entities by adding `PickingBehavior::IGNORE`, like normal. Or, if you want mesh picking to be entirely opt-in, you can set `MeshPickingBackendSettings::require_markers` to `true` and add a `RayCastPickable` component to the desired camera and target entities. You can also use the new `MeshRayCast` system parameter to cast rays into the world manually: ```rust fn ray_cast_system(mut ray_cast: MeshRayCast, foo_query: Query<(), With<Foo>>) { let ray = Ray3d::new(Vec3::ZERO, Dir3::X); // Only ray cast against entities with the `Foo` component. let filter = \|entity\| foo_query.contains(entity); // Never early-exit. Note that you can change behavior per-entity. let early_exit_test = \|_entity\| false; // Ignore the visibility of entities. This allows ray casting hidden entities. let visibility = RayCastVisibility::Any; let settings = RayCastSettings::default() .with_filter(&filter) .with_early_exit_test(&early_exit_test) .with_visibility(visibility); // Cast the ray with the settings, returning a list of intersections. let hits = ray_cast.cast_ray(ray, &settings); } ``` This is largely a direct port, but I did make several changes to match our APIs better, remove things we don't need or that I think are unnecessary, and do some general improvements to code quality and documentation. ### Changes Relative to `bevy_mod_raycast` and `bevy_mod_picking` - Every `Raycast` and "raycast" has been renamed to `RayCast` and "ray cast" (similar reasoning as the "Naming" section in #15724) - `Raycast` system param has been renamed to `MeshRayCast` to avoid naming conflicts and to be explicit that it is not for colliders - `RaycastBackend` has been renamed to `MeshPickingBackend` - `RayCastVisibility` variants are now `Any`, `Visible`, and `VisibleInView` instead of `Ignore`, `MustBeVisible`, and `MustBeVisibleAndInView` - `NoBackfaceCulling` has been renamed to `RayCastBackfaces`, to avoid implying that it affects the rendering of backfaces for meshes (it doesn't) - `SimplifiedMesh` and `RayCastBackfaces` live near other ray casting API types, not in their own 10 LoC module - All intersection logic and types are in the same `intersections` module, not split across several modules - Some intersection types have been renamed to be clearer and more consistent - `IntersectionData` -> `RayMeshHit` - `RayHit` -> `RayTriangleHit` - General documentation and code quality improvements ### Removed / Not Ported - Removed unused ray helpers and types, like `PrimitiveIntersection` - Removed getters on intersection types, and made their properties public - There is no `2d` feature, and `Raycast::mesh_query` and `Raycast::mesh2d_query` have been merged into `MeshRayCast::mesh_query`, which handles both 2D and 3D - I assume this existed previously because `Mesh2dHandle` used to be in `bevy_sprite`. Now both the 2D and 3D mesh are in `bevy_render`. - There is no `debug` feature or ray debug rendering - There is no deferred API (`RaycastSource`) - There is no `CursorRayPlugin` (the picking backend handles this) ### Note for Reviewers In case it's helpful, the [first commit](`281638ef10`) here is essentially a one-to-one port. The rest of the commits are primarily refactoring and cleaning things up in the ways listed earlier, as well as changes to the module structure. It may also be useful to compare the original [picking backend](`74f0c3c0fb/backends/bevy_picking_raycast/src/lib.rs`) and [`bevy_mod_raycast`](https://github.com/aevyrie/bevy_mod_raycast) to this PR. Feel free to mention if there are any changes that I should revert or something I should not include in this PR. ## Testing I tested mesh picking and relevant components in some examples, for both 2D and 3D meshes, and added a new `mesh_picking` example. I also ~~stole~~ ported over the [ray-mesh intersection benchmark](`dbc5ef32fe/benches/ray_mesh_intersection.rs`) from `bevy_mod_raycast`. --- ## Showcase Below is a version of the `2d_shapes` example modified to demonstrate 2D mesh picking. This is not included in this PR. https://github.com/user-attachments/assets/7742528c-8630-4c00-bacd-81576ac432bf And below is the new `mesh_picking` example: https://github.com/user-attachments/assets/b65c7a5a-fa3a-4c2d-8bbd-e7a2c772986e There is also a really cool new `mesh_ray_cast` example ported over from `bevy_mod_raycast`: https://github.com/user-attachments/assets/3c5eb6c0-bd94-4fb0-bec6-8a85668a06c9 --------- Co-authored-by: Aevyrie <aevyrie@gmail.com> Co-authored-by: Trent <2771466+tbillington@users.noreply.github.com> Co-authored-by: François Mockers <mockersf@gmail.com>		2024-10-13 17:24:19 +00:00
.cargo	Use lld for rustdoc on Linux in config_fast_builds.toml (#14839 )	2024-08-22 23:08:04 +00:00
.github	use previous ubuntu version for example validation (#15882 )	2024-10-13 16:36:25 +00:00
assets	Fix invalid scene file for `scene` example (#15829 )	2024-10-10 18:31:39 +00:00
benches	Add mesh picking backend and `MeshRayCast` system parameter (#15800 )	2024-10-13 17:24:19 +00:00
crates	Add mesh picking backend and `MeshRayCast` system parameter (#15800 )	2024-10-13 17:24:19 +00:00
docs	Add mesh picking backend and `MeshRayCast` system parameter (#15800 )	2024-10-13 17:24:19 +00:00
docs-template	Fix cargo-ndk build command (#15648 )	2024-10-04 19:20:25 +00:00
errors	split up `TextStyle` (#15857 )	2024-10-13 17:06:22 +00:00
examples	Add mesh picking backend and `MeshRayCast` system parameter (#15800 )	2024-10-13 17:24:19 +00:00
src	Fix common capitalization errors in documentation (#14562 )	2024-07-31 21:16:05 +00:00
tests	Fix `minimising` example minimizing every frame (#15850 )	2024-10-11 15:36:09 +00:00
tools	Add `compile-check-no-std` Command to CI Tool (#15843 )	2024-10-11 10:54:44 +00:00
.gitattributes	Enforce linux-style line endings for `.rs` and `.toml` (#3197 )	2021-11-26 21:05:35 +00:00
.gitignore	Improvements .gitignore (#15798 )	2024-10-09 21:13:27 +00:00
Cargo.toml	Add mesh picking backend and `MeshRayCast` system parameter (#15800 )	2024-10-13 17:24:19 +00:00
clippy.toml	Enable `clippy::check-private-items` so that `missing_safety_doc` will apply to private functions as well (#15161 )	2024-09-18 15:28:41 +00:00
CODE_OF_CONDUCT.md	Update CODE_OF_CONDUCT.md	2020-08-19 20:25:58 +01:00
CONTRIBUTING.md	Deprecate old contributing documentation / information (#14885 )	2024-08-23 11:47:02 +00:00
CREDITS.md	Programmed soundtrack example (#12774 )	2024-03-29 20:32:30 +00:00
deny.toml	Fix duplicate dependencies on raw-window-handle (#12309 )	2024-03-05 08:24:37 +00:00
LICENSE-APACHE	Let the project page support GitHub's new ability to display open source licenses (#4966 )	2022-06-08 17:55:57 +00:00
LICENSE-MIT	Let the project page support GitHub's new ability to display open source licenses (#4966 )	2022-06-08 17:55:57 +00:00
README.md	Update funding link (#12425 )	2024-03-11 21:46:04 +00:00
rustfmt.toml	Simpler lint fixes: makes `ci lints` work but disables a lint for now (#15376 )	2024-09-24 11:42:59 +00:00
typos.toml	Implement percentage-closer soft shadows (PCSS). (#13497 )	2024-09-18 18:07:17 +00:00

README.md

What is Bevy?

Bevy is a refreshingly simple data-driven game engine built in Rust. It is free and open-source forever!

WARNING

Bevy is still in the early stages of development. Important features are missing. Documentation is sparse. A new version of Bevy containing breaking changes to the API is released approximately once every 3 months. We provide migration guides, but we can't guarantee migrations will always be easy. Use only if you are willing to work in this environment.

MSRV: Bevy relies heavily on improvements in the Rust language and compiler. As a result, the Minimum Supported Rust Version (MSRV) is generally close to "the latest stable release" of Rust.

Design Goals

Capable: Offer a complete 2D and 3D feature set
Simple: Easy for newbies to pick up, but infinitely flexible for power users
Data Focused: Data-oriented architecture using the Entity Component System paradigm
Modular: Use only what you need. Replace what you don't like
Fast: App logic should run quickly, and when possible, in parallel
Productive: Changes should compile quickly ... waiting isn't fun

About

Features: A quick overview of Bevy's features.
News: A development blog that covers our progress, plans and shiny new features.

Docs

Quick Start Guide: Bevy's official Quick Start Guide. The best place to start learning Bevy.
Bevy Rust API Docs: Bevy's Rust API docs, which are automatically generated from the doc comments in this repo.
Official Examples: Bevy's dedicated, runnable examples, which are great for digging into specific concepts.
Community-Made Learning Resources: More tutorials, documentation, and examples made by the Bevy community.

Community

Before contributing or participating in discussions with the community, you should familiarize yourself with our Code of Conduct.

Discord: Bevy's official discord server.
Reddit: Bevy's official subreddit.
GitHub Discussions: The best place for questions about Bevy, answered right here!
Bevy Assets: A collection of awesome Bevy projects, tools, plugins and learning materials.

Contributing

If you'd like to help build Bevy, check out the Contributor's Guide. For simple problems, feel free to open an issue or PR and tackle it yourself!

For more complex architecture decisions and experimental mad science, please open an RFC (Request For Comments) so we can brainstorm together effectively!

Getting Started

We recommend checking out the Quick Start Guide for a brief introduction.

Follow the Setup guide to ensure your development environment is set up correctly. Once set up, you can quickly try out the examples by cloning this repo and running the following commands:

# Switch to the correct version (latest release, default is main development branch)
git checkout latest
# Runs the "breakout" example
cargo run --example breakout

To draw a window with standard functionality enabled, use:

use bevy::prelude::*;

fn main(){
  App::new()
    .add_plugins(DefaultPlugins)
    .run();
}

Fast Compiles

Bevy can be built just fine using default configuration on stable Rust. However for really fast iterative compiles, you should enable the "fast compiles" setup by following the instructions here.

Bevy Cargo Features

This list outlines the different cargo features supported by Bevy. These allow you to customize the Bevy feature set for your use-case.

Thanks

Bevy is the result of the hard work of many people. A huge thanks to all Bevy contributors, the many open source projects that have come before us, the Rust gamedev ecosystem, and the many libraries we build on.

A huge thanks to Bevy's generous sponsors. Bevy will always be free and open source, but it isn't free to make. Please consider sponsoring our work if you like what we're building.

This project is tested with BrowserStack.

License

Bevy is free, open source and permissively licensed! Except where noted (below and/or in individual files), all code in this repository is dual-licensed under either:

MIT License (LICENSE-MIT or http://opensource.org/licenses/MIT)
Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)

at your option. This means you can select the license you prefer! This dual-licensing approach is the de-facto standard in the Rust ecosystem and there are very good reasons to include both.

Some of the engine's code carries additional copyright notices and license terms due to their external origins. These are generally BSD-like, but exact details vary by crate: If the README of a crate contains a 'License' header (or similar), the additional copyright notices and license terms applicable to that crate will be listed. The above licensing requirement still applies to contributions to those crates, and sections of those crates will carry those license terms. The license field of each crate will also reflect this. For example, bevy_mikktspace has code under the Zlib license (as well as a copyright notice when choosing the MIT license).

The assets included in this repository (for our examples) typically fall under different open licenses. These will not be included in your game (unless copied in by you), and they are not distributed in the published bevy crates. See CREDITS.md for the details of the licenses of those files.

Your contributions

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.