97909df6c0
# Objective The way `Curve` presently achieves dyn-compatibility involves shoving `Self: Sized` bounds on a bunch of methods to forbid them from appearing in vtables. (This is called *explicit non-dispatchability*.) The `Curve` trait probably also just has way too many methods on its own. In the past, using extension traits instead to achieve similar functionality has been discussed. The upshot is that this would allow the "core" of the curve trait, on which all the automatic methods rely, to live in a very simple dyn-compatible trait, while other functionality is implemented by extensions. For instance, `dyn Curve<T>` cannot use the `Sized` methods, but `Box<dyn Curve<T>>` is `Sized`, hence would automatically implement the extension trait, containing the methods which are currently non-dispatchable. Other motivations for this include modularity and code organization: the `Curve` trait itself has grown quite large with the addition of numerous adaptors, and refactoring it to demonstrate the separation of functionality that is already present makes a lot of sense. Furthermore, resampling behavior in particular is dependent on special traits that may be mimicked or analogized in user-space, and creating extension traits to achieve similar behavior in user-space is something we ought to encourage by example. ## Solution `Curve` now contains only `domain` and the `sample` methods. `CurveExt` has been created, and it contains all adaptors, along with the other sampling convenience methods (`samples`, `sample_iter`, etc.). It is implemented for all `C` where `C: Curve<T> + Sized`. `CurveResampleExt` has been created, and it contains all resampling methods. It is implemented for all `C` where `C: Curve<T> + ?Sized`. ## Testing It compiles and `cargo doc` succeeds. --- ## Future work - Consider writing extension traits for resampling curves in related domains (e.g. resampling for `Curve<T>` where `T: Animatable` into an `AnimatableKeyframeCurve`). - `CurveExt` might be further broken down to separate the adaptor and sampling methods. --- ## Migration Guide `Curve` has been refactored so that much of its functionality is now in extension traits. Adaptors such as `map`, `reparametrize`, `reverse`, and so on now require importing `CurveExt`, while the resampling methods `resample_*` require importing `CurveResampleExt`. Both of these new traits are exported through `bevy::math::curve` and through `bevy::math::prelude`.
179 lines
6.6 KiB
Rust
179 lines
6.6 KiB
Rust
//! Additional [`GizmoBuffer`] Functions -- Curves
|
|
//!
|
|
//! Includes the implementation of [`GizmoBuffer::curve_2d`],
|
|
//! [`GizmoBuffer::curve_3d`] and assorted support items.
|
|
|
|
use bevy_color::Color;
|
|
use bevy_math::{
|
|
curve::{Curve, CurveExt},
|
|
Vec2, Vec3,
|
|
};
|
|
|
|
use crate::{gizmos::GizmoBuffer, prelude::GizmoConfigGroup};
|
|
|
|
impl<Config, Clear> GizmoBuffer<Config, Clear>
|
|
where
|
|
Config: GizmoConfigGroup,
|
|
Clear: 'static + Send + Sync,
|
|
{
|
|
/// Draw a curve, at the given time points, sampling in 2D.
|
|
///
|
|
/// This should be called for each frame the curve needs to be rendered.
|
|
///
|
|
/// Samples of time points outside of the curve's domain will be filtered out and won't
|
|
/// contribute to the rendering. If you wish to render the curve outside of its domain you need
|
|
/// to create a new curve with an extended domain.
|
|
///
|
|
/// # Arguments
|
|
/// - `curve_2d` some type that implements the [`Curve`] trait and samples `Vec2`s
|
|
/// - `times` some iterable type yielding `f32` which will be used for sampling the curve
|
|
/// - `color` the color of the curve
|
|
///
|
|
/// # Example
|
|
/// ```
|
|
/// # use bevy_gizmos::prelude::*;
|
|
/// # use bevy_math::prelude::*;
|
|
/// # use bevy_color::palettes::basic::{RED};
|
|
/// fn system(mut gizmos: Gizmos) {
|
|
/// let domain = Interval::UNIT;
|
|
/// let curve = FunctionCurve::new(domain, |t| Vec2::from(t.sin_cos()));
|
|
/// gizmos.curve_2d(curve, (0..=100).map(|n| n as f32 / 100.0), RED);
|
|
/// }
|
|
/// # bevy_ecs::system::assert_is_system(system);
|
|
/// ```
|
|
pub fn curve_2d(
|
|
&mut self,
|
|
curve_2d: impl Curve<Vec2>,
|
|
times: impl IntoIterator<Item = f32>,
|
|
color: impl Into<Color>,
|
|
) {
|
|
self.linestrip_2d(curve_2d.sample_iter(times).flatten(), color);
|
|
}
|
|
|
|
/// Draw a curve, at the given time points, sampling in 3D.
|
|
///
|
|
/// This should be called for each frame the curve needs to be rendered.
|
|
///
|
|
/// Samples of time points outside of the curve's domain will be filtered out and won't
|
|
/// contribute to the rendering. If you wish to render the curve outside of its domain you need
|
|
/// to create a new curve with an extended domain.
|
|
///
|
|
/// # Arguments
|
|
/// - `curve_3d` some type that implements the [`Curve`] trait and samples `Vec3`s
|
|
/// - `times` some iterable type yielding `f32` which will be used for sampling the curve
|
|
/// - `color` the color of the curve
|
|
///
|
|
/// # Example
|
|
/// ```
|
|
/// # use bevy_gizmos::prelude::*;
|
|
/// # use bevy_math::prelude::*;
|
|
/// # use bevy_color::palettes::basic::{RED};
|
|
/// fn system(mut gizmos: Gizmos) {
|
|
/// let domain = Interval::UNIT;
|
|
/// let curve = FunctionCurve::new(domain, |t| {
|
|
/// let (x,y) = t.sin_cos();
|
|
/// Vec3::new(x, y, t)
|
|
/// });
|
|
/// gizmos.curve_3d(curve, (0..=100).map(|n| n as f32 / 100.0), RED);
|
|
/// }
|
|
/// # bevy_ecs::system::assert_is_system(system);
|
|
/// ```
|
|
pub fn curve_3d(
|
|
&mut self,
|
|
curve_3d: impl Curve<Vec3>,
|
|
times: impl IntoIterator<Item = f32>,
|
|
color: impl Into<Color>,
|
|
) {
|
|
self.linestrip(curve_3d.sample_iter(times).flatten(), color);
|
|
}
|
|
|
|
/// Draw a curve, at the given time points, sampling in 2D, with a color gradient.
|
|
///
|
|
/// This should be called for each frame the curve needs to be rendered.
|
|
///
|
|
/// Samples of time points outside of the curve's domain will be filtered out and won't
|
|
/// contribute to the rendering. If you wish to render the curve outside of its domain you need
|
|
/// to create a new curve with an extended domain.
|
|
///
|
|
/// # Arguments
|
|
/// - `curve_2d` some type that implements the [`Curve`] trait and samples `Vec2`s
|
|
/// - `times_with_colors` some iterable type yielding `f32` which will be used for sampling
|
|
/// the curve together with the color at this position
|
|
///
|
|
/// # Example
|
|
/// ```
|
|
/// # use bevy_gizmos::prelude::*;
|
|
/// # use bevy_math::prelude::*;
|
|
/// # use bevy_color::{Mix, palettes::basic::{GREEN, RED}};
|
|
/// fn system(mut gizmos: Gizmos) {
|
|
/// let domain = Interval::UNIT;
|
|
/// let curve = FunctionCurve::new(domain, |t| Vec2::from(t.sin_cos()));
|
|
/// gizmos.curve_gradient_2d(
|
|
/// curve,
|
|
/// (0..=100).map(|n| n as f32 / 100.0)
|
|
/// .map(|t| (t, GREEN.mix(&RED, t)))
|
|
/// );
|
|
/// }
|
|
/// # bevy_ecs::system::assert_is_system(system);
|
|
/// ```
|
|
pub fn curve_gradient_2d<C>(
|
|
&mut self,
|
|
curve_2d: impl Curve<Vec2>,
|
|
times_with_colors: impl IntoIterator<Item = (f32, C)>,
|
|
) where
|
|
C: Into<Color>,
|
|
{
|
|
self.linestrip_gradient_2d(
|
|
times_with_colors
|
|
.into_iter()
|
|
.filter_map(|(time, color)| curve_2d.sample(time).map(|sample| (sample, color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a curve, at the given time points, sampling in 3D, with a color gradient.
|
|
///
|
|
/// This should be called for each frame the curve needs to be rendered.
|
|
///
|
|
/// Samples of time points outside of the curve's domain will be filtered out and won't
|
|
/// contribute to the rendering. If you wish to render the curve outside of its domain you need
|
|
/// to create a new curve with an extended domain.
|
|
///
|
|
/// # Arguments
|
|
/// - `curve_3d` some type that implements the [`Curve`] trait and samples `Vec3`s
|
|
/// - `times_with_colors` some iterable type yielding `f32` which will be used for sampling
|
|
/// the curve together with the color at this position
|
|
///
|
|
/// # Example
|
|
/// ```
|
|
/// # use bevy_gizmos::prelude::*;
|
|
/// # use bevy_math::prelude::*;
|
|
/// # use bevy_color::{Mix, palettes::basic::{GREEN, RED}};
|
|
/// fn system(mut gizmos: Gizmos) {
|
|
/// let domain = Interval::UNIT;
|
|
/// let curve = FunctionCurve::new(domain, |t| {
|
|
/// let (x,y) = t.sin_cos();
|
|
/// Vec3::new(x, y, t)
|
|
/// });
|
|
/// gizmos.curve_gradient_3d(
|
|
/// curve,
|
|
/// (0..=100).map(|n| n as f32 / 100.0)
|
|
/// .map(|t| (t, GREEN.mix(&RED, t)))
|
|
/// );
|
|
/// }
|
|
/// # bevy_ecs::system::assert_is_system(system);
|
|
/// ```
|
|
pub fn curve_gradient_3d<C>(
|
|
&mut self,
|
|
curve_3d: impl Curve<Vec3>,
|
|
times_with_colors: impl IntoIterator<Item = (f32, C)>,
|
|
) where
|
|
C: Into<Color>,
|
|
{
|
|
self.linestrip_gradient(
|
|
times_with_colors
|
|
.into_iter()
|
|
.filter_map(|(time, color)| curve_3d.sample(time).map(|sample| (sample, color))),
|
|
);
|
|
}
|
|
}
|