Struct TransformInterpolationPlugin

pub struct TransformInterpolationPlugin {
    pub interpolate_translation_all: bool,
    pub interpolate_rotation_all: bool,
    pub interpolate_scale_all: bool,
}

A plugin for Transform interpolation, making movement in FixedUpdate appear smooth.

Transform interpolation applies easing between the old and current Transform in between fixed timesteps. This results in movement that looks smooth and accurate, at the cost of rendered positions being slightly behind the “true” gameplay positions.

This plugin requires the TransformEasingPlugin to function. It is automatically added if not already present in the app.

Usage

Transform interpolation can be enabled for a given entity by adding the TransformInterpolation component.

use bevy::prelude::*;
use bevy_transform_interpolation::prelude::*;

fn setup(mut commands: Commands) {
    // Interpolate the entire transform: translation, rotation, and scale.
    commands.spawn((
        Transform::default(),
        TransformInterpolation,
    ));
}

Now, any changes made to the Transform of the entity in FixedPreUpdate, FixedUpdate, or FixedPostUpdate will automatically be smoothed in between fixed timesteps.

Transform properties can also be interpolated individually by adding the TranslationInterpolation, RotationInterpolation, and ScaleInterpolation components.

fn setup(mut commands: Commands) {
    // Only interpolate translation.
    commands.spawn((Transform::default(), TranslationInterpolation));
     
    // Only interpolate rotation.
    commands.spawn((Transform::default(), RotationInterpolation));
     
    // Only interpolate scale.
    commands.spawn((Transform::default(), ScaleInterpolation));
     
    // Interpolate translation and rotation, but not scale.
    commands.spawn((
        Transform::default(),
        TranslationInterpolation,
        RotationInterpolation,
    ));
}

If you want all entities with a Transform to be interpolated by default, you can use TransformInterpolationPlugin::interpolate_all(), or set the interpolate_translation_all, interpolate_rotation_all, and interpolate_scale_all fields.

fn main() {
   App::new()
      .add_plugins(TransformInterpolationPlugin {
          // Interpolate translation and rotation by default, but not scale.
          interpolate_translation_all: true,
          interpolate_rotation_all: true,
          interpolate_scale_all: false,
      })
      // ...
      .run();
}

When interpolation is enabled for all entities by default, you can still opt out of it for individual entities by adding the NoTransformEasing component, or the individual NoTranslationEasing, NoRotationEasing, and NoScaleEasing components.

Note that changing Transform manually in any schedule that doesn’t use a fixed timestep is also supported, but it is equivalent to teleporting, and disables interpolation for the entity for the remainder of that fixed timestep.

Alternatives

For games where low latency is crucial for gameplay, such as in some first-person shooters or racing games, the small delay introduced by interpolation may be undesirable. In those cases, one option is to use the TransformExtrapolationPlugin instea.

Transform extrapolation predicts future positions based on velocity, and applies easing between the current and predicted Transform. This results in movement that looks smooth and feels responsive, but can stutter when the prediction is incorrect, such as when velocity changes abruptly.

Easing Backends

By default, transform interpolation uses linear interpolation (lerp) for easing translation and scale, and spherical linear interpolation (slerp) for easing rotation.

If the previous and current velocities are also available, it is possible to use [Hermite interpolation] with the TransformHermiteEasingPlugin to get smoother and more accurate easing. To enable Hermite interpolation, add the TransformHermiteEasing component to the entity in addition to the core interpolation components.

Fields

interpolate_translation_all: bool

If true, translation will be interpolated for all entities with the Transform component by default.

This can be overridden for individual entities by adding the NoTranslationEasing or NoTransformEasing component.

interpolate_rotation_all: bool

If true, rotation will be interpolated for all entities with the Transform component by default.

This can be overridden for individual entities by adding the NoRotationEasing or NoTransformEasing component.

interpolate_scale_all: bool

If true, scale will be interpolated for all entities with the Transform component by default.

This can be overridden for individual entities by adding the NoScaleEasing or NoTransformEasing component.

Implementations

impl TransformInterpolationPlugin

pub const fn interpolate_all() -> Self

Enables interpolation for translation, rotation, and scale for all entities with the Transform component.

This can be overridden for individual entities by adding the NoTransformEasing component, or the individual NoTranslationEasing, NoRotationEasing, and NoScaleEasing components.

Trait Implementations

impl Debug for TransformInterpolationPlugin

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TransformInterpolationPlugin

fn default() -> TransformInterpolationPlugin

Returns the “default value” for a type.

impl Plugin for TransformInterpolationPlugin

fn build(&self, app: &mut App)

Configures the App to which this plugin is added.

fn finish(&self, app: &mut App)

Finish adding this plugin to the App, once all plugins registered are ready. This can be useful for plugins that depends on another plugin asynchronous setup, like the renderer.

fn ready(&self, _app: &App) -> bool

Has the plugin finished its setup? This can be useful for plugins that need something asynchronous to happen before they can finish their setup, like the initialization of a renderer. Once the plugin is ready, finish should be called.

fn cleanup(&self, _app: &mut App)

Runs after all plugins are built and finished, but before the app schedule is executed. This can be useful if you have some resource that other plugins need during their build step, but after build you want to remove it and send it to another thread.

fn name(&self) -> &str

Configures a name for the Plugin which is primarily used for checking plugin uniqueness and debugging.

fn is_unique(&self) -> bool

If the plugin can be meaningfully instantiated several times in an App, override this method to return false.