Make `Resource` trait opt-in, requiring `#[derive(Resource)]` V2 (#5577)
*This PR description is an edited copy of #5007, written by @alice-i-cecile.*
# Objective
Follow-up to https://github.com/bevyengine/bevy/pull/2254. The `Resource` trait currently has a blanket implementation for all types that meet its bounds.
While ergonomic, this results in several drawbacks:
* it is possible to make confusing, silent mistakes such as inserting a function pointer (Foo) rather than a value (Foo::Bar) as a resource
* it is challenging to discover if a type is intended to be used as a resource
* we cannot later add customization options (see the [RFC](https://github.com/bevyengine/rfcs/blob/main/rfcs/27-derive-component.md) for the equivalent choice for Component).
* dependencies can use the same Rust type as a resource in invisibly conflicting ways
* raw Rust types used as resources cannot preserve privacy appropriately, as anyone able to access that type can read and write to internal values
* we cannot capture a definitive list of possible resources to display to users in an editor
## Notes to reviewers
* Review this commit-by-commit; there's effectively no back-tracking and there's a lot of churn in some of these commits.
*ira: My commits are not as well organized :')*
* I've relaxed the bound on Local to Send + Sync + 'static: I don't think these concerns apply there, so this can keep things simple. Storing e.g. a u32 in a Local is fine, because there's a variable name attached explaining what it does.
* I think this is a bad place for the Resource trait to live, but I've left it in place to make reviewing easier. IMO that's best tackled with https://github.com/bevyengine/bevy/issues/4981.
## Changelog
`Resource` is no longer automatically implemented for all matching types. Instead, use the new `#[derive(Resource)]` macro.
## Migration Guide
Add `#[derive(Resource)]` to all types you are using as a resource.
If you are using a third party type as a resource, wrap it in a tuple struct to bypass orphan rules. Consider deriving `Deref` and `DerefMut` to improve ergonomics.
`ClearColor` no longer implements `Component`. Using `ClearColor` as a component in 0.8 did nothing.
Use the `ClearColorConfig` in the `Camera3d` and `Camera2d` components instead.
Co-authored-by: Alice <alice.i.cecile@gmail.com>
Co-authored-by: Alice Cecile <alice.i.cecile@gmail.com>
Co-authored-by: devil-ira <justthecooldude@gmail.com>
Co-authored-by: Carter Anderson <mcanders1@gmail.com>
2022-08-08 21:36:35 +00:00
|
|
|
use bevy_ecs::system::Resource;
|
bevy_reflect: `FromReflect` Ergonomics Implementation (#6056)
# Objective
**This implementation is based on
https://github.com/bevyengine/rfcs/pull/59.**
---
Resolves #4597
Full details and motivation can be found in the RFC, but here's a brief
summary.
`FromReflect` is a very powerful and important trait within the
reflection API. It allows Dynamic types (e.g., `DynamicList`, etc.) to
be formed into Real ones (e.g., `Vec<i32>`, etc.).
This mainly comes into play concerning deserialization, where the
reflection deserializers both return a `Box<dyn Reflect>` that almost
always contain one of these Dynamic representations of a Real type. To
convert this to our Real type, we need to use `FromReflect`.
It also sneaks up in other ways. For example, it's a required bound for
`T` in `Vec<T>` so that `Vec<T>` as a whole can be made `FromReflect`.
It's also required by all fields of an enum as it's used as part of the
`Reflect::apply` implementation.
So in other words, much like `GetTypeRegistration` and `Typed`, it is
very much a core reflection trait.
The problem is that it is not currently treated like a core trait and is
not automatically derived alongside `Reflect`. This makes using it a bit
cumbersome and easy to forget.
## Solution
Automatically derive `FromReflect` when deriving `Reflect`.
Users can then choose to opt-out if needed using the
`#[reflect(from_reflect = false)]` attribute.
```rust
#[derive(Reflect)]
struct Foo;
#[derive(Reflect)]
#[reflect(from_reflect = false)]
struct Bar;
fn test<T: FromReflect>(value: T) {}
test(Foo); // <-- OK
test(Bar); // <-- Panic! Bar does not implement trait `FromReflect`
```
#### `ReflectFromReflect`
This PR also automatically adds the `ReflectFromReflect` (introduced in
#6245) registration to the derived `GetTypeRegistration` impl— if the
type hasn't opted out of `FromReflect` of course.
<details>
<summary><h4>Improved Deserialization</h4></summary>
> **Warning**
> This section includes changes that have since been descoped from this
PR. They will likely be implemented again in a followup PR. I am mainly
leaving these details in for archival purposes, as well as for reference
when implementing this logic again.
And since we can do all the above, we might as well improve
deserialization. We can now choose to deserialize into a Dynamic type or
automatically convert it using `FromReflect` under the hood.
`[Un]TypedReflectDeserializer::new` will now perform the conversion and
return the `Box`'d Real type.
`[Un]TypedReflectDeserializer::new_dynamic` will work like what we have
now and simply return the `Box`'d Dynamic type.
```rust
// Returns the Real type
let reflect_deserializer = UntypedReflectDeserializer::new(®istry);
let mut deserializer = ron::de::Deserializer::from_str(input)?;
let output: SomeStruct = reflect_deserializer.deserialize(&mut deserializer)?.take()?;
// Returns the Dynamic type
let reflect_deserializer = UntypedReflectDeserializer::new_dynamic(®istry);
let mut deserializer = ron::de::Deserializer::from_str(input)?;
let output: DynamicStruct = reflect_deserializer.deserialize(&mut deserializer)?.take()?;
```
</details>
---
## Changelog
* `FromReflect` is now automatically derived within the `Reflect` derive
macro
* This includes auto-registering `ReflectFromReflect` in the derived
`GetTypeRegistration` impl
* ~~Renamed `TypedReflectDeserializer::new` and
`UntypedReflectDeserializer::new` to
`TypedReflectDeserializer::new_dynamic` and
`UntypedReflectDeserializer::new_dynamic`, respectively~~ **Descoped**
* ~~Changed `TypedReflectDeserializer::new` and
`UntypedReflectDeserializer::new` to automatically convert the
deserialized output using `FromReflect`~~ **Descoped**
## Migration Guide
* `FromReflect` is now automatically derived within the `Reflect` derive
macro. Items with both derives will need to remove the `FromReflect`
one.
```rust
// OLD
#[derive(Reflect, FromReflect)]
struct Foo;
// NEW
#[derive(Reflect)]
struct Foo;
```
If using a manual implementation of `FromReflect` and the `Reflect`
derive, users will need to opt-out of the automatic implementation.
```rust
// OLD
#[derive(Reflect)]
struct Foo;
impl FromReflect for Foo {/* ... */}
// NEW
#[derive(Reflect)]
#[reflect(from_reflect = false)]
struct Foo;
impl FromReflect for Foo {/* ... */}
```
<details>
<summary><h4>Removed Migrations</h4></summary>
> **Warning**
> This section includes changes that have since been descoped from this
PR. They will likely be implemented again in a followup PR. I am mainly
leaving these details in for archival purposes, as well as for reference
when implementing this logic again.
* The reflect deserializers now perform a `FromReflect` conversion
internally. The expected output of `TypedReflectDeserializer::new` and
`UntypedReflectDeserializer::new` is no longer a Dynamic (e.g.,
`DynamicList`), but its Real counterpart (e.g., `Vec<i32>`).
```rust
let reflect_deserializer =
UntypedReflectDeserializer::new_dynamic(®istry);
let mut deserializer = ron::de::Deserializer::from_str(input)?;
// OLD
let output: DynamicStruct = reflect_deserializer.deserialize(&mut
deserializer)?.take()?;
// NEW
let output: SomeStruct = reflect_deserializer.deserialize(&mut
deserializer)?.take()?;
```
Alternatively, if this behavior isn't desired, use the
`TypedReflectDeserializer::new_dynamic` and
`UntypedReflectDeserializer::new_dynamic` methods instead:
```rust
// OLD
let reflect_deserializer = UntypedReflectDeserializer::new(®istry);
// NEW
let reflect_deserializer =
UntypedReflectDeserializer::new_dynamic(®istry);
```
</details>
---------
Co-authored-by: Carter Anderson <mcanders1@gmail.com>
2023-06-29 01:31:34 +00:00
|
|
|
use bevy_reflect::{std_traits::ReflectDefault, Reflect};
|
2020-08-29 00:08:51 +00:00
|
|
|
use bevy_utils::HashSet;
|
|
|
|
use std::hash::Hash;
|
2020-06-05 05:48:53 +00:00
|
|
|
|
2021-04-13 03:13:48 +00:00
|
|
|
// unused import, but needed for intra doc link to work
|
|
|
|
#[allow(unused_imports)]
|
2023-02-06 18:44:40 +00:00
|
|
|
use bevy_ecs::schedule::State;
|
2021-04-13 03:13:48 +00:00
|
|
|
|
|
|
|
/// A "press-able" input of type `T`.
|
|
|
|
///
|
2022-04-25 13:16:21 +00:00
|
|
|
/// ## Usage
|
|
|
|
///
|
2021-04-13 03:13:48 +00:00
|
|
|
/// This type can be used as a resource to keep the current state of an input, by reacting to
|
|
|
|
/// events from the input. For a given input value:
|
|
|
|
///
|
|
|
|
/// * [`Input::pressed`] will return `true` between a press and a release event.
|
|
|
|
/// * [`Input::just_pressed`] will return `true` for one frame after a press event.
|
|
|
|
/// * [`Input::just_released`] will return `true` for one frame after a release event.
|
|
|
|
///
|
2022-04-25 13:16:21 +00:00
|
|
|
/// ## Multiple systems
|
|
|
|
///
|
2021-04-13 03:13:48 +00:00
|
|
|
/// In case multiple systems are checking for [`Input::just_pressed`] or [`Input::just_released`]
|
|
|
|
/// but only one should react, for example in the case of triggering
|
2023-02-06 18:44:40 +00:00
|
|
|
/// [`State`](bevy_ecs::schedule::State) change, you should consider clearing the input state, either by:
|
2021-04-13 03:13:48 +00:00
|
|
|
///
|
2021-04-25 17:24:09 +00:00
|
|
|
/// * Using [`Input::clear_just_pressed`] or [`Input::clear_just_released`] instead.
|
2021-04-13 03:13:48 +00:00
|
|
|
/// * Calling [`Input::clear`] or [`Input::reset`] immediately after the state change.
|
|
|
|
///
|
2022-04-25 13:16:21 +00:00
|
|
|
/// ## Note
|
2021-04-13 03:13:48 +00:00
|
|
|
///
|
|
|
|
/// When adding this resource for a new input type, you should:
|
|
|
|
///
|
|
|
|
/// * Call the [`Input::press`] method for each press event.
|
|
|
|
/// * Call the [`Input::release`] method for each release event.
|
|
|
|
/// * Call the [`Input::clear`] method at each frame start, before processing events.
|
2022-12-11 18:22:09 +00:00
|
|
|
///
|
|
|
|
/// Note: Calling `clear` from a [`ResMut`] will trigger change detection.
|
2023-01-11 15:41:54 +00:00
|
|
|
/// It may be preferable to use [`DetectChangesMut::bypass_change_detection`]
|
2022-12-11 18:22:09 +00:00
|
|
|
/// to avoid causing the resource to always be marked as changed.
|
|
|
|
///
|
|
|
|
///[`ResMut`]: bevy_ecs::system::ResMut
|
2023-01-11 15:41:54 +00:00
|
|
|
///[`DetectChangesMut::bypass_change_detection`]: bevy_ecs::change_detection::DetectChangesMut::bypass_change_detection
|
bevy_reflect: `FromReflect` Ergonomics Implementation (#6056)
# Objective
**This implementation is based on
https://github.com/bevyengine/rfcs/pull/59.**
---
Resolves #4597
Full details and motivation can be found in the RFC, but here's a brief
summary.
`FromReflect` is a very powerful and important trait within the
reflection API. It allows Dynamic types (e.g., `DynamicList`, etc.) to
be formed into Real ones (e.g., `Vec<i32>`, etc.).
This mainly comes into play concerning deserialization, where the
reflection deserializers both return a `Box<dyn Reflect>` that almost
always contain one of these Dynamic representations of a Real type. To
convert this to our Real type, we need to use `FromReflect`.
It also sneaks up in other ways. For example, it's a required bound for
`T` in `Vec<T>` so that `Vec<T>` as a whole can be made `FromReflect`.
It's also required by all fields of an enum as it's used as part of the
`Reflect::apply` implementation.
So in other words, much like `GetTypeRegistration` and `Typed`, it is
very much a core reflection trait.
The problem is that it is not currently treated like a core trait and is
not automatically derived alongside `Reflect`. This makes using it a bit
cumbersome and easy to forget.
## Solution
Automatically derive `FromReflect` when deriving `Reflect`.
Users can then choose to opt-out if needed using the
`#[reflect(from_reflect = false)]` attribute.
```rust
#[derive(Reflect)]
struct Foo;
#[derive(Reflect)]
#[reflect(from_reflect = false)]
struct Bar;
fn test<T: FromReflect>(value: T) {}
test(Foo); // <-- OK
test(Bar); // <-- Panic! Bar does not implement trait `FromReflect`
```
#### `ReflectFromReflect`
This PR also automatically adds the `ReflectFromReflect` (introduced in
#6245) registration to the derived `GetTypeRegistration` impl— if the
type hasn't opted out of `FromReflect` of course.
<details>
<summary><h4>Improved Deserialization</h4></summary>
> **Warning**
> This section includes changes that have since been descoped from this
PR. They will likely be implemented again in a followup PR. I am mainly
leaving these details in for archival purposes, as well as for reference
when implementing this logic again.
And since we can do all the above, we might as well improve
deserialization. We can now choose to deserialize into a Dynamic type or
automatically convert it using `FromReflect` under the hood.
`[Un]TypedReflectDeserializer::new` will now perform the conversion and
return the `Box`'d Real type.
`[Un]TypedReflectDeserializer::new_dynamic` will work like what we have
now and simply return the `Box`'d Dynamic type.
```rust
// Returns the Real type
let reflect_deserializer = UntypedReflectDeserializer::new(®istry);
let mut deserializer = ron::de::Deserializer::from_str(input)?;
let output: SomeStruct = reflect_deserializer.deserialize(&mut deserializer)?.take()?;
// Returns the Dynamic type
let reflect_deserializer = UntypedReflectDeserializer::new_dynamic(®istry);
let mut deserializer = ron::de::Deserializer::from_str(input)?;
let output: DynamicStruct = reflect_deserializer.deserialize(&mut deserializer)?.take()?;
```
</details>
---
## Changelog
* `FromReflect` is now automatically derived within the `Reflect` derive
macro
* This includes auto-registering `ReflectFromReflect` in the derived
`GetTypeRegistration` impl
* ~~Renamed `TypedReflectDeserializer::new` and
`UntypedReflectDeserializer::new` to
`TypedReflectDeserializer::new_dynamic` and
`UntypedReflectDeserializer::new_dynamic`, respectively~~ **Descoped**
* ~~Changed `TypedReflectDeserializer::new` and
`UntypedReflectDeserializer::new` to automatically convert the
deserialized output using `FromReflect`~~ **Descoped**
## Migration Guide
* `FromReflect` is now automatically derived within the `Reflect` derive
macro. Items with both derives will need to remove the `FromReflect`
one.
```rust
// OLD
#[derive(Reflect, FromReflect)]
struct Foo;
// NEW
#[derive(Reflect)]
struct Foo;
```
If using a manual implementation of `FromReflect` and the `Reflect`
derive, users will need to opt-out of the automatic implementation.
```rust
// OLD
#[derive(Reflect)]
struct Foo;
impl FromReflect for Foo {/* ... */}
// NEW
#[derive(Reflect)]
#[reflect(from_reflect = false)]
struct Foo;
impl FromReflect for Foo {/* ... */}
```
<details>
<summary><h4>Removed Migrations</h4></summary>
> **Warning**
> This section includes changes that have since been descoped from this
PR. They will likely be implemented again in a followup PR. I am mainly
leaving these details in for archival purposes, as well as for reference
when implementing this logic again.
* The reflect deserializers now perform a `FromReflect` conversion
internally. The expected output of `TypedReflectDeserializer::new` and
`UntypedReflectDeserializer::new` is no longer a Dynamic (e.g.,
`DynamicList`), but its Real counterpart (e.g., `Vec<i32>`).
```rust
let reflect_deserializer =
UntypedReflectDeserializer::new_dynamic(®istry);
let mut deserializer = ron::de::Deserializer::from_str(input)?;
// OLD
let output: DynamicStruct = reflect_deserializer.deserialize(&mut
deserializer)?.take()?;
// NEW
let output: SomeStruct = reflect_deserializer.deserialize(&mut
deserializer)?.take()?;
```
Alternatively, if this behavior isn't desired, use the
`TypedReflectDeserializer::new_dynamic` and
`UntypedReflectDeserializer::new_dynamic` methods instead:
```rust
// OLD
let reflect_deserializer = UntypedReflectDeserializer::new(®istry);
// NEW
let reflect_deserializer =
UntypedReflectDeserializer::new_dynamic(®istry);
```
</details>
---------
Co-authored-by: Carter Anderson <mcanders1@gmail.com>
2023-06-29 01:31:34 +00:00
|
|
|
#[derive(Debug, Clone, Resource, Reflect)]
|
|
|
|
#[reflect(Default)]
|
2022-09-07 15:59:50 +00:00
|
|
|
pub struct Input<T: Copy + Eq + Hash + Send + Sync + 'static> {
|
2022-04-25 13:16:21 +00:00
|
|
|
/// A collection of every button that is currently being pressed.
|
2020-06-05 06:34:21 +00:00
|
|
|
pressed: HashSet<T>,
|
2022-04-25 13:16:21 +00:00
|
|
|
/// A collection of every button that has just been pressed.
|
2020-06-05 06:34:21 +00:00
|
|
|
just_pressed: HashSet<T>,
|
2022-04-25 13:16:21 +00:00
|
|
|
/// A collection of every button that has just been released.
|
2020-06-05 06:34:21 +00:00
|
|
|
just_released: HashSet<T>,
|
2020-06-05 05:48:53 +00:00
|
|
|
}
|
|
|
|
|
2022-09-07 15:59:50 +00:00
|
|
|
impl<T: Copy + Eq + Hash + Send + Sync + 'static> Default for Input<T> {
|
2020-06-05 06:34:21 +00:00
|
|
|
fn default() -> Self {
|
|
|
|
Self {
|
|
|
|
pressed: Default::default(),
|
|
|
|
just_pressed: Default::default(),
|
|
|
|
just_released: Default::default(),
|
2020-06-05 05:48:53 +00:00
|
|
|
}
|
|
|
|
}
|
2020-06-05 06:34:21 +00:00
|
|
|
}
|
2020-06-05 05:48:53 +00:00
|
|
|
|
2020-06-05 06:34:21 +00:00
|
|
|
impl<T> Input<T>
|
|
|
|
where
|
2022-09-07 15:59:50 +00:00
|
|
|
T: Copy + Eq + Hash + Send + Sync + 'static,
|
2020-06-05 06:34:21 +00:00
|
|
|
{
|
2022-04-25 13:16:21 +00:00
|
|
|
/// Registers a press for the given `input`.
|
2020-06-05 06:34:21 +00:00
|
|
|
pub fn press(&mut self, input: T) {
|
2022-03-29 22:39:16 +00:00
|
|
|
// Returns `true` if the `input` wasn't pressed.
|
|
|
|
if self.pressed.insert(input) {
|
2020-06-05 06:34:21 +00:00
|
|
|
self.just_pressed.insert(input);
|
|
|
|
}
|
2020-06-05 05:48:53 +00:00
|
|
|
}
|
|
|
|
|
2022-04-25 13:16:21 +00:00
|
|
|
/// Returns `true` if the `input` has been pressed.
|
2020-06-05 06:34:21 +00:00
|
|
|
pub fn pressed(&self, input: T) -> bool {
|
|
|
|
self.pressed.contains(&input)
|
2020-06-05 05:48:53 +00:00
|
|
|
}
|
|
|
|
|
2022-04-25 13:16:21 +00:00
|
|
|
/// Returns `true` if any item in `inputs` has been pressed.
|
2021-09-01 21:21:41 +00:00
|
|
|
pub fn any_pressed(&self, inputs: impl IntoIterator<Item = T>) -> bool {
|
|
|
|
inputs.into_iter().any(|it| self.pressed(it))
|
|
|
|
}
|
|
|
|
|
2022-04-25 13:16:21 +00:00
|
|
|
/// Registers a release for the given `input`.
|
2020-06-05 06:34:21 +00:00
|
|
|
pub fn release(&mut self, input: T) {
|
2022-03-29 22:39:16 +00:00
|
|
|
// Returns `true` if the `input` was pressed.
|
|
|
|
if self.pressed.remove(&input) {
|
2022-03-20 21:54:09 +00:00
|
|
|
self.just_released.insert(input);
|
|
|
|
}
|
2020-06-05 05:48:53 +00:00
|
|
|
}
|
|
|
|
|
2022-06-20 17:35:56 +00:00
|
|
|
/// Registers a release for all currently pressed inputs.
|
|
|
|
pub fn release_all(&mut self) {
|
|
|
|
// Move all items from pressed into just_released
|
|
|
|
self.just_released.extend(self.pressed.drain());
|
|
|
|
}
|
|
|
|
|
2022-04-25 13:16:21 +00:00
|
|
|
/// Returns `true` if the `input` has just been pressed.
|
2020-06-05 06:34:21 +00:00
|
|
|
pub fn just_pressed(&self, input: T) -> bool {
|
|
|
|
self.just_pressed.contains(&input)
|
2020-06-05 05:48:53 +00:00
|
|
|
}
|
|
|
|
|
2022-04-25 13:16:21 +00:00
|
|
|
/// Returns `true` if any item in `inputs` has just been pressed.
|
2021-09-01 21:21:41 +00:00
|
|
|
pub fn any_just_pressed(&self, inputs: impl IntoIterator<Item = T>) -> bool {
|
|
|
|
inputs.into_iter().any(|it| self.just_pressed(it))
|
|
|
|
}
|
|
|
|
|
2022-04-25 13:16:21 +00:00
|
|
|
/// Clears the `just_pressed` state of the `input` and returns `true` if the `input` has just been pressed.
|
|
|
|
///
|
|
|
|
/// Future calls to [`Input::just_pressed`] for the given input will return false until a new press event occurs.
|
2021-04-13 03:13:48 +00:00
|
|
|
pub fn clear_just_pressed(&mut self, input: T) -> bool {
|
|
|
|
self.just_pressed.remove(&input)
|
|
|
|
}
|
|
|
|
|
2022-04-25 13:16:21 +00:00
|
|
|
/// Returns `true` if the `input` has just been released.
|
2020-06-05 06:34:21 +00:00
|
|
|
pub fn just_released(&self, input: T) -> bool {
|
|
|
|
self.just_released.contains(&input)
|
|
|
|
}
|
2020-06-05 05:48:53 +00:00
|
|
|
|
2022-04-25 13:16:21 +00:00
|
|
|
/// Returns `true` if any item in `inputs` has just been released.
|
2021-09-01 21:21:41 +00:00
|
|
|
pub fn any_just_released(&self, inputs: impl IntoIterator<Item = T>) -> bool {
|
|
|
|
inputs.into_iter().any(|it| self.just_released(it))
|
|
|
|
}
|
|
|
|
|
2022-04-25 13:16:21 +00:00
|
|
|
/// Clears the `just_released` state of the `input` and returns `true` if the `input` has just been released.
|
|
|
|
///
|
|
|
|
/// Future calls to [`Input::just_released`] for the given input will return false until a new release event occurs.
|
2021-04-13 03:13:48 +00:00
|
|
|
pub fn clear_just_released(&mut self, input: T) -> bool {
|
|
|
|
self.just_released.remove(&input)
|
|
|
|
}
|
|
|
|
|
2022-04-25 13:16:21 +00:00
|
|
|
/// Clears the `pressed`, `just_pressed` and `just_released` data of the `input`.
|
2020-09-18 21:43:47 +00:00
|
|
|
pub fn reset(&mut self, input: T) {
|
|
|
|
self.pressed.remove(&input);
|
|
|
|
self.just_pressed.remove(&input);
|
|
|
|
self.just_released.remove(&input);
|
|
|
|
}
|
|
|
|
|
2022-06-20 18:31:46 +00:00
|
|
|
/// Clears the `pressed`, `just_pressed`, and `just_released` data for every input.
|
|
|
|
///
|
|
|
|
/// See also [`Input::clear`] for simulating elapsed time steps.
|
|
|
|
pub fn reset_all(&mut self) {
|
|
|
|
self.pressed.clear();
|
|
|
|
self.just_pressed.clear();
|
|
|
|
self.just_released.clear();
|
|
|
|
}
|
|
|
|
|
2022-04-25 13:16:21 +00:00
|
|
|
/// Clears the `just pressed` and `just released` data for every input.
|
2022-06-20 18:31:46 +00:00
|
|
|
///
|
|
|
|
/// See also [`Input::reset_all`] for a full reset.
|
2021-04-13 03:13:48 +00:00
|
|
|
pub fn clear(&mut self) {
|
2020-06-05 06:34:21 +00:00
|
|
|
self.just_pressed.clear();
|
|
|
|
self.just_released.clear();
|
2020-06-05 05:48:53 +00:00
|
|
|
}
|
2020-09-04 00:32:17 +00:00
|
|
|
|
2022-04-25 13:16:21 +00:00
|
|
|
/// An iterator visiting every pressed input in arbitrary order.
|
2020-09-04 00:32:17 +00:00
|
|
|
pub fn get_pressed(&self) -> impl ExactSizeIterator<Item = &T> {
|
|
|
|
self.pressed.iter()
|
|
|
|
}
|
|
|
|
|
2022-04-25 13:16:21 +00:00
|
|
|
/// An iterator visiting every just pressed input in arbitrary order.
|
2020-09-04 00:32:17 +00:00
|
|
|
pub fn get_just_pressed(&self) -> impl ExactSizeIterator<Item = &T> {
|
|
|
|
self.just_pressed.iter()
|
|
|
|
}
|
|
|
|
|
2022-04-25 13:16:21 +00:00
|
|
|
/// An iterator visiting every just released input in arbitrary order.
|
2020-09-04 00:32:17 +00:00
|
|
|
pub fn get_just_released(&self) -> impl ExactSizeIterator<Item = &T> {
|
|
|
|
self.just_released.iter()
|
|
|
|
}
|
2020-06-05 05:48:53 +00:00
|
|
|
}
|
2020-12-01 06:58:49 +00:00
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod test {
|
2023-06-05 20:31:20 +00:00
|
|
|
use bevy_reflect::TypePath;
|
|
|
|
|
2022-04-25 13:16:24 +00:00
|
|
|
use crate::Input;
|
|
|
|
|
|
|
|
/// Used for testing the functionality of [`Input`].
|
2023-06-05 20:31:20 +00:00
|
|
|
#[derive(TypePath, Copy, Clone, Eq, PartialEq, Hash)]
|
2022-04-25 13:16:24 +00:00
|
|
|
enum DummyInput {
|
|
|
|
Input1,
|
|
|
|
Input2,
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_press() {
|
|
|
|
let mut input = Input::default();
|
|
|
|
assert!(!input.pressed.contains(&DummyInput::Input1));
|
|
|
|
assert!(!input.just_pressed.contains(&DummyInput::Input1));
|
|
|
|
input.press(DummyInput::Input1);
|
|
|
|
assert!(input.just_pressed.contains(&DummyInput::Input1));
|
|
|
|
assert!(input.pressed.contains(&DummyInput::Input1));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_pressed() {
|
|
|
|
let mut input = Input::default();
|
|
|
|
assert!(!input.pressed(DummyInput::Input1));
|
|
|
|
input.press(DummyInput::Input1);
|
|
|
|
assert!(input.pressed(DummyInput::Input1));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_any_pressed() {
|
|
|
|
let mut input = Input::default();
|
|
|
|
assert!(!input.any_pressed([DummyInput::Input1]));
|
|
|
|
assert!(!input.any_pressed([DummyInput::Input2]));
|
|
|
|
assert!(!input.any_pressed([DummyInput::Input1, DummyInput::Input2]));
|
|
|
|
input.press(DummyInput::Input1);
|
|
|
|
assert!(input.any_pressed([DummyInput::Input1]));
|
|
|
|
assert!(!input.any_pressed([DummyInput::Input2]));
|
|
|
|
assert!(input.any_pressed([DummyInput::Input1, DummyInput::Input2]));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_release() {
|
|
|
|
let mut input = Input::default();
|
|
|
|
input.press(DummyInput::Input1);
|
|
|
|
assert!(input.pressed.contains(&DummyInput::Input1));
|
|
|
|
assert!(!input.just_released.contains(&DummyInput::Input1));
|
|
|
|
input.release(DummyInput::Input1);
|
|
|
|
assert!(!input.pressed.contains(&DummyInput::Input1));
|
|
|
|
assert!(input.just_released.contains(&DummyInput::Input1));
|
|
|
|
}
|
|
|
|
|
2022-06-20 17:35:56 +00:00
|
|
|
#[test]
|
|
|
|
fn test_release_all() {
|
|
|
|
let mut input = Input::default();
|
|
|
|
input.press(DummyInput::Input1);
|
|
|
|
input.press(DummyInput::Input2);
|
|
|
|
input.release_all();
|
|
|
|
assert!(input.pressed.is_empty());
|
|
|
|
assert!(input.just_released.contains(&DummyInput::Input1));
|
|
|
|
assert!(input.just_released.contains(&DummyInput::Input2));
|
|
|
|
}
|
|
|
|
|
2022-04-25 13:16:24 +00:00
|
|
|
#[test]
|
|
|
|
fn test_just_pressed() {
|
|
|
|
let mut input = Input::default();
|
|
|
|
assert!(!input.just_pressed(DummyInput::Input1));
|
|
|
|
input.press(DummyInput::Input1);
|
|
|
|
assert!(input.just_pressed(DummyInput::Input1));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_any_just_pressed() {
|
|
|
|
let mut input = Input::default();
|
|
|
|
assert!(!input.any_just_pressed([DummyInput::Input1]));
|
|
|
|
assert!(!input.any_just_pressed([DummyInput::Input2]));
|
|
|
|
assert!(!input.any_just_pressed([DummyInput::Input1, DummyInput::Input2]));
|
|
|
|
input.press(DummyInput::Input1);
|
|
|
|
assert!(input.any_just_pressed([DummyInput::Input1]));
|
|
|
|
assert!(!input.any_just_pressed([DummyInput::Input2]));
|
|
|
|
assert!(input.any_just_pressed([DummyInput::Input1, DummyInput::Input2]));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_clear_just_pressed() {
|
|
|
|
let mut input = Input::default();
|
|
|
|
input.press(DummyInput::Input1);
|
|
|
|
assert!(input.just_pressed(DummyInput::Input1));
|
|
|
|
input.clear_just_pressed(DummyInput::Input1);
|
|
|
|
assert!(!input.just_pressed(DummyInput::Input1));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_just_released() {
|
|
|
|
let mut input = Input::default();
|
|
|
|
input.press(DummyInput::Input1);
|
|
|
|
assert!(!input.just_released(DummyInput::Input1));
|
|
|
|
input.release(DummyInput::Input1);
|
|
|
|
assert!(input.just_released(DummyInput::Input1));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_any_just_released() {
|
|
|
|
let mut input = Input::default();
|
|
|
|
input.press(DummyInput::Input1);
|
|
|
|
assert!(!input.any_just_released([DummyInput::Input1]));
|
|
|
|
assert!(!input.any_just_released([DummyInput::Input2]));
|
|
|
|
assert!(!input.any_just_released([DummyInput::Input1, DummyInput::Input2]));
|
|
|
|
input.release(DummyInput::Input1);
|
|
|
|
assert!(input.any_just_released([DummyInput::Input1]));
|
|
|
|
assert!(!input.any_just_released([DummyInput::Input2]));
|
|
|
|
assert!(input.any_just_released([DummyInput::Input1, DummyInput::Input2]));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_clear_just_released() {
|
|
|
|
let mut input = Input::default();
|
|
|
|
input.press(DummyInput::Input1);
|
|
|
|
input.release(DummyInput::Input1);
|
|
|
|
assert!(input.just_released(DummyInput::Input1));
|
|
|
|
input.clear_just_released(DummyInput::Input1);
|
|
|
|
assert!(!input.just_released(DummyInput::Input1));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_reset() {
|
|
|
|
let mut input = Input::default();
|
|
|
|
|
|
|
|
// Pressed
|
|
|
|
input.press(DummyInput::Input1);
|
|
|
|
assert!(input.pressed(DummyInput::Input1));
|
|
|
|
assert!(input.just_pressed(DummyInput::Input1));
|
|
|
|
assert!(!input.just_released(DummyInput::Input1));
|
|
|
|
input.reset(DummyInput::Input1);
|
|
|
|
assert!(!input.pressed(DummyInput::Input1));
|
|
|
|
assert!(!input.just_pressed(DummyInput::Input1));
|
|
|
|
assert!(!input.just_released(DummyInput::Input1));
|
|
|
|
|
|
|
|
// Released
|
|
|
|
input.press(DummyInput::Input1);
|
|
|
|
input.release(DummyInput::Input1);
|
|
|
|
assert!(!input.pressed(DummyInput::Input1));
|
|
|
|
assert!(input.just_pressed(DummyInput::Input1));
|
|
|
|
assert!(input.just_released(DummyInput::Input1));
|
|
|
|
input.reset(DummyInput::Input1);
|
|
|
|
assert!(!input.pressed(DummyInput::Input1));
|
|
|
|
assert!(!input.just_pressed(DummyInput::Input1));
|
|
|
|
assert!(!input.just_released(DummyInput::Input1));
|
|
|
|
}
|
2020-12-01 06:58:49 +00:00
|
|
|
|
2022-06-20 18:31:46 +00:00
|
|
|
#[test]
|
|
|
|
fn test_reset_all() {
|
|
|
|
let mut input = Input::default();
|
|
|
|
|
|
|
|
input.press(DummyInput::Input1);
|
|
|
|
input.press(DummyInput::Input2);
|
|
|
|
input.release(DummyInput::Input2);
|
|
|
|
assert!(input.pressed.contains(&DummyInput::Input1));
|
|
|
|
assert!(input.just_pressed.contains(&DummyInput::Input1));
|
|
|
|
assert!(input.just_released.contains(&DummyInput::Input2));
|
|
|
|
input.reset_all();
|
|
|
|
assert!(input.pressed.is_empty());
|
|
|
|
assert!(input.just_pressed.is_empty());
|
|
|
|
assert!(input.just_released.is_empty());
|
|
|
|
}
|
|
|
|
|
2020-12-01 06:58:49 +00:00
|
|
|
#[test]
|
2022-04-25 13:16:24 +00:00
|
|
|
fn test_clear() {
|
|
|
|
let mut input = Input::default();
|
2020-12-01 06:58:49 +00:00
|
|
|
|
2022-04-25 13:16:24 +00:00
|
|
|
// Pressed
|
|
|
|
input.press(DummyInput::Input1);
|
|
|
|
assert!(input.pressed(DummyInput::Input1));
|
|
|
|
assert!(input.just_pressed(DummyInput::Input1));
|
|
|
|
assert!(!input.just_released(DummyInput::Input1));
|
|
|
|
input.clear();
|
|
|
|
assert!(input.pressed(DummyInput::Input1));
|
|
|
|
assert!(!input.just_pressed(DummyInput::Input1));
|
|
|
|
assert!(!input.just_released(DummyInput::Input1));
|
|
|
|
|
|
|
|
// Released
|
|
|
|
input.press(DummyInput::Input1);
|
|
|
|
input.release(DummyInput::Input1);
|
|
|
|
assert!(!input.pressed(DummyInput::Input1));
|
|
|
|
assert!(!input.just_pressed(DummyInput::Input1));
|
|
|
|
assert!(input.just_released(DummyInput::Input1));
|
|
|
|
input.clear();
|
|
|
|
assert!(!input.pressed(DummyInput::Input1));
|
|
|
|
assert!(!input.just_pressed(DummyInput::Input1));
|
|
|
|
assert!(!input.just_released(DummyInput::Input1));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_get_pressed() {
|
|
|
|
let mut input = Input::default();
|
|
|
|
input.press(DummyInput::Input1);
|
|
|
|
input.press(DummyInput::Input2);
|
|
|
|
let pressed = input.get_pressed();
|
|
|
|
assert_eq!(pressed.len(), 2);
|
|
|
|
for pressed_input in pressed {
|
|
|
|
assert!(input.pressed.contains(pressed_input));
|
2020-12-01 06:58:49 +00:00
|
|
|
}
|
2022-04-25 13:16:24 +00:00
|
|
|
}
|
2020-12-01 06:58:49 +00:00
|
|
|
|
2022-04-25 13:16:24 +00:00
|
|
|
#[test]
|
|
|
|
fn test_get_just_pressed() {
|
|
|
|
let mut input = Input::default();
|
|
|
|
input.press(DummyInput::Input1);
|
|
|
|
input.press(DummyInput::Input2);
|
|
|
|
let just_pressed = input.get_just_pressed();
|
|
|
|
assert_eq!(just_pressed.len(), 2);
|
|
|
|
for just_pressed_input in just_pressed {
|
|
|
|
assert!(input.just_pressed.contains(just_pressed_input));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_get_just_released() {
|
|
|
|
let mut input = Input::default();
|
|
|
|
input.press(DummyInput::Input1);
|
|
|
|
input.press(DummyInput::Input2);
|
|
|
|
input.release(DummyInput::Input1);
|
|
|
|
input.release(DummyInput::Input2);
|
|
|
|
let just_released = input.get_just_released();
|
|
|
|
assert_eq!(just_released.len(), 2);
|
|
|
|
for just_released_input in just_released {
|
|
|
|
assert!(input.just_released.contains(just_released_input));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_general_input_handling() {
|
2020-12-01 06:58:49 +00:00
|
|
|
let mut input = Input::default();
|
|
|
|
|
|
|
|
// Test pressing
|
|
|
|
input.press(DummyInput::Input1);
|
|
|
|
input.press(DummyInput::Input2);
|
|
|
|
|
2022-04-25 13:16:24 +00:00
|
|
|
// Check if they were `just_pressed` (pressed on this update)
|
2020-12-01 06:58:49 +00:00
|
|
|
assert!(input.just_pressed(DummyInput::Input1));
|
|
|
|
assert!(input.just_pressed(DummyInput::Input2));
|
|
|
|
|
|
|
|
// Check if they are also marked as pressed
|
|
|
|
assert!(input.pressed(DummyInput::Input1));
|
|
|
|
assert!(input.pressed(DummyInput::Input2));
|
|
|
|
|
2022-04-25 13:16:24 +00:00
|
|
|
// Clear the `input`, removing `just_pressed` and `just_released`
|
2021-04-13 03:13:48 +00:00
|
|
|
input.clear();
|
2020-12-01 06:58:49 +00:00
|
|
|
|
2022-04-25 13:16:24 +00:00
|
|
|
// Check if they're marked `just_pressed`
|
2020-12-01 06:58:49 +00:00
|
|
|
assert!(!input.just_pressed(DummyInput::Input1));
|
|
|
|
assert!(!input.just_pressed(DummyInput::Input2));
|
|
|
|
|
|
|
|
// Check if they're marked as pressed
|
2022-04-04 22:10:00 +00:00
|
|
|
assert!(input.pressed(DummyInput::Input1));
|
|
|
|
assert!(input.pressed(DummyInput::Input2));
|
2020-12-01 06:58:49 +00:00
|
|
|
|
|
|
|
// Release the inputs and check state
|
|
|
|
input.release(DummyInput::Input1);
|
|
|
|
input.release(DummyInput::Input2);
|
|
|
|
|
2022-04-25 13:16:24 +00:00
|
|
|
// Check if they're marked as `just_released` (released on this update)
|
2020-12-01 06:58:49 +00:00
|
|
|
assert!(input.just_released(DummyInput::Input1));
|
|
|
|
assert!(input.just_released(DummyInput::Input2));
|
|
|
|
|
|
|
|
// Check that they're not incorrectly marked as pressed
|
|
|
|
assert!(!input.pressed(DummyInput::Input1));
|
|
|
|
assert!(!input.pressed(DummyInput::Input2));
|
|
|
|
|
2021-04-13 03:13:48 +00:00
|
|
|
// Clear the `Input` and check for removal from `just_released`
|
|
|
|
input.clear();
|
2020-12-01 06:58:49 +00:00
|
|
|
|
|
|
|
// Check that they're not incorrectly marked as just released
|
|
|
|
assert!(!input.just_released(DummyInput::Input1));
|
|
|
|
assert!(!input.just_released(DummyInput::Input2));
|
|
|
|
|
2022-04-25 13:16:24 +00:00
|
|
|
// Set up an `Input` to test resetting
|
2020-12-01 06:58:49 +00:00
|
|
|
let mut input = Input::default();
|
|
|
|
|
|
|
|
input.press(DummyInput::Input1);
|
|
|
|
input.release(DummyInput::Input2);
|
|
|
|
|
2022-04-25 13:16:24 +00:00
|
|
|
// Reset the `Input` and test if it was reset correctly
|
2020-12-01 06:58:49 +00:00
|
|
|
input.reset(DummyInput::Input1);
|
|
|
|
input.reset(DummyInput::Input2);
|
|
|
|
|
|
|
|
assert!(!input.just_pressed(DummyInput::Input1));
|
|
|
|
assert!(!input.pressed(DummyInput::Input1));
|
|
|
|
assert!(!input.just_released(DummyInput::Input2));
|
|
|
|
}
|
|
|
|
}
|