dacha 0.18.0-alpha.9 → 0.18.0

package/build/contrib/components/index.d.ts

@@ -3,6 +3,7 @@ export { KeyboardControl, type KeyboardControlConfig, } from './keyboard-control
 export { Collider, type ColliderConfig, type ColliderShape, type ColliderType, type BoxColliderShape, type CircleColliderShape, type SegmentColliderShape, type CapsuleColliderShape, } from './collider';
 export { RigidBody, type RigidBodyConfig } from './rigid-body';
 export { CharacterBody, type CharacterBodyConfig } from './character-body';
+export { Interpolation, type InterpolationConfig, type InterpolationMode, } from './interpolation';
 export { Animatable, type AnimatableConfig } from './animatable';
 export { Sprite, type SpriteConfig } from './sprite';
 export { Transform, type TransformConfig } from './transform';

package/build/contrib/components/index.js

@@ -3,6 +3,7 @@ export { KeyboardControl, } from './keyboard-control';
 export { Collider, } from './collider';
 export { RigidBody } from './rigid-body';
 export { CharacterBody } from './character-body';
+export { Interpolation, } from './interpolation';
 export { Animatable } from './animatable';
 export { Sprite } from './sprite';
 export { Transform } from './transform';

package/build/contrib/components/interpolation/index.d.ts

@@ -0,0 +1,85 @@
+import { Component } from '../../../engine/component';
+export type InterpolationMode = 'interpolate' | 'extrapolate';
+export interface InterpolationConfig {
+    mode?: InterpolationMode;
+    snapThreshold?: number;
+    disabled?: boolean;
+}
+/**
+ * Component that smooths rendering of actors moved during fixed updates.
+ *
+ * Interpolator keeps local-space snapshots of the actor's Transform around
+ * each fixed step and blends them into the render-facing
+ * `renderX`/`renderY`/`renderRotation` values every render frame using
+ * `Time.alpha`. The renderer prefers these values over the Transform.
+ *
+ * The Transform component always holds the authoritative simulation state.
+ * Interpolated values are only visible to the renderer and to consumers of
+ * InterpolatorAPI, so simulation code can never accidentally read a
+ * visually smoothed but physically incorrect position.
+ *
+ * @example
+ * ```typescript
+ * actor.setComponent(new Interpolation({ mode: 'interpolate' }));
+ *
+ * // After teleporting the actor, skip smoothing for the jump:
+ * actor.getComponent(Transform).world.position.x = 500;
+ * actor.getComponent(Interpolation).snap();
+ * ```
+ *
+ * @category Components
+ */
+export declare class Interpolation extends Component {
+    /**
+     * How render values are produced. `interpolate` blends between the last
+     * two fixed steps (smooth, adds up to one fixed step of visual latency).
+     * `extrapolate` projects the latest step forward using the rigid body
+     * velocity (no added latency, may briefly overshoot on impacts).
+     *
+     * `extrapolate` uses the world-space rigid body velocity against
+     * local-space snapshots, so it is intended for root-level actors.
+     */
+    mode: InterpolationMode;
+    /**
+     * Maximum distance in world units treated as continuous movement between
+     * two fixed steps. Larger jumps snap instead of gliding. `0` disables
+     * the automatic snap detection.
+     */
+    snapThreshold: number;
+    /** Whether smoothing is turned off. The renderer falls back to Transform. */
+    disabled: boolean;
+    /** @internal Local-space position X from the previous fixed step */
+    _prevX: number;
+    /** @internal Local-space position Y from the previous fixed step */
+    _prevY: number;
+    /** @internal Local-space rotation from the previous fixed step */
+    _prevRotation: number;
+    /** @internal Local-space position X from the latest fixed step */
+    _currX: number;
+    /** @internal Local-space position Y from the latest fixed step */
+    _currY: number;
+    /** @internal Local-space rotation from the latest fixed step */
+    _currRotation: number;
+    /** @internal Whether snapshots have been initialized since (re)enabling */
+    _initialized: boolean;
+    /** @internal Whether smoothing should be skipped at the next opportunity */
+    _snapRequested: boolean;
+    /** Render-facing local-space position X, written by Interpolator */
+    renderX: number;
+    /** Render-facing local-space position Y, written by Interpolator */
+    renderY: number;
+    /** Render-facing local-space rotation, written by Interpolator */
+    renderRotation: number;
+    constructor(config?: InterpolationConfig);
+    /**
+     * Whether the render-facing values hold a valid snapshot yet. `false`
+     * until the Interpolator takes its first snapshot after the component is
+     * (re)enabled.
+     */
+    get initialized(): boolean;
+    /**
+     * Requests an immediate jump to the Transform instead of
+     * smoothing towards it. Call right after teleporting the actor.
+     */
+    snap(): void;
+}

package/build/contrib/components/interpolation/index.js

@@ -0,0 +1,101 @@
+import { Component } from '../../../engine/component';
+/**
+ * Component that smooths rendering of actors moved during fixed updates.
+ *
+ * Interpolator keeps local-space snapshots of the actor's Transform around
+ * each fixed step and blends them into the render-facing
+ * `renderX`/`renderY`/`renderRotation` values every render frame using
+ * `Time.alpha`. The renderer prefers these values over the Transform.
+ *
+ * The Transform component always holds the authoritative simulation state.
+ * Interpolated values are only visible to the renderer and to consumers of
+ * InterpolatorAPI, so simulation code can never accidentally read a
+ * visually smoothed but physically incorrect position.
+ *
+ * @example
+ * ```typescript
+ * actor.setComponent(new Interpolation({ mode: 'interpolate' }));
+ *
+ * // After teleporting the actor, skip smoothing for the jump:
+ * actor.getComponent(Transform).world.position.x = 500;
+ * actor.getComponent(Interpolation).snap();
+ * ```
+ *
+ * @category Components
+ */
+export class Interpolation extends Component {
+    /**
+     * How render values are produced. `interpolate` blends between the last
+     * two fixed steps (smooth, adds up to one fixed step of visual latency).
+     * `extrapolate` projects the latest step forward using the rigid body
+     * velocity (no added latency, may briefly overshoot on impacts).
+     *
+     * `extrapolate` uses the world-space rigid body velocity against
+     * local-space snapshots, so it is intended for root-level actors.
+     */
+    mode;
+    /**
+     * Maximum distance in world units treated as continuous movement between
+     * two fixed steps. Larger jumps snap instead of gliding. `0` disables
+     * the automatic snap detection.
+     */
+    snapThreshold;
+    /** Whether smoothing is turned off. The renderer falls back to Transform. */
+    disabled;
+    /** @internal Local-space position X from the previous fixed step */
+    _prevX;
+    /** @internal Local-space position Y from the previous fixed step */
+    _prevY;
+    /** @internal Local-space rotation from the previous fixed step */
+    _prevRotation;
+    /** @internal Local-space position X from the latest fixed step */
+    _currX;
+    /** @internal Local-space position Y from the latest fixed step */
+    _currY;
+    /** @internal Local-space rotation from the latest fixed step */
+    _currRotation;
+    /** @internal Whether snapshots have been initialized since (re)enabling */
+    _initialized;
+    /** @internal Whether smoothing should be skipped at the next opportunity */
+    _snapRequested;
+    /** Render-facing local-space position X, written by Interpolator */
+    renderX;
+    /** Render-facing local-space position Y, written by Interpolator */
+    renderY;
+    /** Render-facing local-space rotation, written by Interpolator */
+    renderRotation;
+    constructor(config = {}) {
+        super();
+        const { mode = 'interpolate', snapThreshold = 0, disabled = false, } = config;
+        this.mode = mode;
+        this.snapThreshold = snapThreshold;
+        this.disabled = disabled;
+        this._prevX = 0;
+        this._prevY = 0;
+        this._prevRotation = 0;
+        this._currX = 0;
+        this._currY = 0;
+        this._currRotation = 0;
+        this._initialized = false;
+        this._snapRequested = false;
+        this.renderX = 0;
+        this.renderY = 0;
+        this.renderRotation = 0;
+    }
+    /**
+     * Whether the render-facing values hold a valid snapshot yet. `false`
+     * until the Interpolator takes its first snapshot after the component is
+     * (re)enabled.
+     */
+    get initialized() {
+        return this._initialized;
+    }
+    /**
+     * Requests an immediate jump to the Transform instead of
+     * smoothing towards it. Call right after teleporting the actor.
+     */
+    snap() {
+        this._snapRequested = true;
+    }
+}
+Interpolation.componentName = 'Interpolation';

package/build/contrib/components/rigid-body/index.d.ts

@@ -31,6 +31,13 @@ interface PointImpulse {
  * impulses, gravity, collisions, and rotation. Static and kinematic bodies can
  * participate in collisions but are not moved by solver impulses.
  *
+ * Physics is simulated in world space.
+ *
+ * Rigid bodies may be parented only to actors with static transforms. A moving
+ * parent (for example, a dynamic or kinematic rigid body) and the physics
+ * simulation would both control the child's transform, so the result is
+ * undefined.
+ *
  * @example
  * ```typescript
  * // Create a dynamic rigid body
@@ -115,6 +122,7 @@ export declare class RigidBody extends Component {
     /**
      * Sets the mass used by dynamic bodies.
      *
+     * Mass is an authored, kilogram-like scalar.
      * Non-positive values make the body immovable by forces and impulses.
      */
     set mass(value: number);

package/build/contrib/components/rigid-body/index.js

@@ -7,6 +7,13 @@ import { Vector2 } from '../../../engine/math-lib';
  * impulses, gravity, collisions, and rotation. Static and kinematic bodies can
  * participate in collisions but are not moved by solver impulses.
  *
+ * Physics is simulated in world space.
+ *
+ * Rigid bodies may be parented only to actors with static transforms. A moving
+ * parent (for example, a dynamic or kinematic rigid body) and the physics
+ * simulation would both control the child's transform, so the result is
+ * undefined.
+ *
  * @example
  * ```typescript
  * // Create a dynamic rigid body
@@ -134,6 +141,7 @@ export class RigidBody extends Component {
     /**
      * Sets the mass used by dynamic bodies.
      *
+     * Mass is an authored, kilogram-like scalar.
      * Non-positive values make the body immovable by forces and impulses.
      */
     set mass(value) {

package/build/contrib/systems/index.d.ts

@@ -4,6 +4,8 @@ export { GameStatsMeter } from './game-stats-meter';
 export { KeyboardInputSystem } from './keyboard-input-system';
 export { KeyboardControlSystem } from './keyboard-control-system';
 export { CharacterController } from './character-controller';
+export { Interpolator, InterpolatorAPI } from './interpolator';
+export type { RenderTransform } from './interpolator';
 export { MouseControlSystem } from './mouse-control-system';
 export { MouseInputSystem } from './mouse-input-system';
 export { PhysicsSystem, PhysicsAPI } from './physics-system';

package/build/contrib/systems/index.js

@@ -4,6 +4,7 @@ export { GameStatsMeter } from './game-stats-meter';
 export { KeyboardInputSystem } from './keyboard-input-system';
 export { KeyboardControlSystem } from './keyboard-control-system';
 export { CharacterController } from './character-controller';
+export { Interpolator, InterpolatorAPI } from './interpolator';
 export { MouseControlSystem } from './mouse-control-system';
 export { MouseInputSystem } from './mouse-input-system';
 export { PhysicsSystem, PhysicsAPI } from './physics-system';

package/build/contrib/systems/interpolator/api.d.ts

@@ -0,0 +1,40 @@
+import type { Actor } from '../../../engine/actor';
+import type { Time } from '../../../engine/time';
+export interface RenderTransform {
+    x: number;
+    y: number;
+    rotation: number;
+}
+interface InterpolatorAPIOptions {
+    time: Time;
+}
+/**
+ * Public API for reading render-facing (visually smoothed) transforms.
+ *
+ * Retrieve it via `world.systemApi.get(InterpolatorAPI)`. Use it in
+ * systems and behaviors that position visuals against moving actors —
+ * e.g. a camera-follow script — instead of reading the authoritative
+ * Transform, which advances in fixed steps.
+ *
+ * Values are computed from the current `Time.alpha`, so this API is only
+ * meaningful during the update phase (not inside `fixedUpdate`).
+ *
+ * @category Systems
+ */
+export declare class InterpolatorAPI {
+    private time;
+    constructor(options: InterpolatorAPIOptions);
+    /**
+     * Returns the world-space transform the actor is rendered with this
+     * frame. Falls back to the Transform for actors (and
+     * ancestors) without an active Interpolation component.
+     */
+    getRenderTransform(actor: Actor): RenderTransform;
+    /**
+     * Requests an immediate visual jump to the actor's
+     * Transform. Call right after teleporting the actor.
+     */
+    snap(actor: Actor): void;
+    private composeRenderWorldMatrix;
+}
+export {};

package/build/contrib/systems/interpolator/api.js

@@ -0,0 +1,70 @@
+import { Matrix } from '../../../engine/math-lib';
+import { Interpolation } from '../../components/interpolation';
+import { Transform } from '../../components/transform';
+import { computeRenderValues } from './utils';
+/**
+ * Public API for reading render-facing (visually smoothed) transforms.
+ *
+ * Retrieve it via `world.systemApi.get(InterpolatorAPI)`. Use it in
+ * systems and behaviors that position visuals against moving actors —
+ * e.g. a camera-follow script — instead of reading the authoritative
+ * Transform, which advances in fixed steps.
+ *
+ * Values are computed from the current `Time.alpha`, so this API is only
+ * meaningful during the update phase (not inside `fixedUpdate`).
+ *
+ * @category Systems
+ */
+export class InterpolatorAPI {
+    time;
+    constructor(options) {
+        this.time = options.time;
+    }
+    /**
+     * Returns the world-space transform the actor is rendered with this
+     * frame. Falls back to the Transform for actors (and
+     * ancestors) without an active Interpolation component.
+     */
+    getRenderTransform(actor) {
+        const matrix = this.composeRenderWorldMatrix(actor);
+        return {
+            x: matrix.tx,
+            y: matrix.ty,
+            rotation: Math.atan2(matrix.b, matrix.a),
+        };
+    }
+    /**
+     * Requests an immediate visual jump to the actor's
+     * Transform. Call right after teleporting the actor.
+     */
+    snap(actor) {
+        const interpolation = actor.getComponent(Interpolation);
+        interpolation?.snap();
+    }
+    composeRenderWorldMatrix(actor) {
+        const transform = actor.getComponent(Transform);
+        const interpolation = actor.getComponent(Interpolation);
+        const useRender = interpolation !== undefined &&
+            !interpolation.disabled &&
+            interpolation.initialized;
+        if (useRender) {
+            computeRenderValues(actor, interpolation, this.time.alpha, this.time.fixedDeltaTime);
+        }
+        const x = useRender ? interpolation.renderX : transform.local.position.x;
+        const y = useRender ? interpolation.renderY : transform.local.position.y;
+        const rotation = useRender
+            ? interpolation.renderRotation
+            : transform.local.rotation;
+        const { scale } = transform.local;
+        const cos = Math.cos(rotation);
+        const sin = Math.sin(rotation);
+        const localMatrix = new Matrix(cos * scale.x, sin * scale.x, -sin * scale.y, cos * scale.y, x, y);
+        const parentTransform = transform.getParentComponent();
+        if (!parentTransform?.actor) {
+            return localMatrix;
+        }
+        const result = new Matrix(1, 0, 0, 1, 0, 0);
+        Matrix.multiply(result, this.composeRenderWorldMatrix(parentTransform.actor), localMatrix);
+        return result;
+    }
+}

package/build/contrib/systems/interpolator/index.d.ts

@@ -0,0 +1,3 @@
+export { Interpolator } from './system';
+export { InterpolatorAPI } from './api';
+export type { RenderTransform } from './api';

package/build/contrib/systems/interpolator/index.js

@@ -0,0 +1,2 @@
+export { Interpolator } from './system';
+export { InterpolatorAPI } from './api';

package/build/contrib/systems/interpolator/system.d.ts

@@ -0,0 +1,31 @@
+import { SceneSystem } from '../../../engine/system';
+import type { SceneSystemOptions } from '../../../engine/system';
+/**
+ * System that produces smooth render-facing transforms for actors moved
+ * during fixed updates.
+ *
+ * During `fixedUpdate` it snapshots the local Transform of every actor with
+ * an Interpolation component. During `update` it blends the last two
+ * snapshots using `Time.alpha` and writes the result into the component's
+ * `renderX`/`renderY`/`renderRotation`, which the renderer prefers over the
+ * Transform.
+ *
+ * Ordering: place this system AFTER every system that moves transforms in
+ * fixed updates (`PhysicsSystem`, `CharacterController`, behavior scripts
+ * that move actors in `fixedUpdate`) and BEFORE `Renderer` in the system
+ * configuration.
+ *
+ * @category Systems
+ */
+export declare class Interpolator extends SceneSystem {
+    private actorQuery;
+    private time;
+    private world;
+    private api;
+    constructor(options: SceneSystemOptions);
+    onSceneEnter(): void;
+    onSceneExit(): void;
+    onSceneDestroy(): void;
+    fixedUpdate(): void;
+    update(): void;
+}

package/build/contrib/systems/interpolator/system.js

@@ -0,0 +1,96 @@
+import { ActorQuery } from '../../../engine/actor';
+import { SceneSystem } from '../../../engine/system';
+import { Interpolation } from '../../components/interpolation';
+import { Transform } from '../../components/transform';
+import { InterpolatorAPI } from './api';
+import { snapToTransform, computeRenderValues } from './utils';
+/**
+ * System that produces smooth render-facing transforms for actors moved
+ * during fixed updates.
+ *
+ * During `fixedUpdate` it snapshots the local Transform of every actor with
+ * an Interpolation component. During `update` it blends the last two
+ * snapshots using `Time.alpha` and writes the result into the component's
+ * `renderX`/`renderY`/`renderRotation`, which the renderer prefers over the
+ * Transform.
+ *
+ * Ordering: place this system AFTER every system that moves transforms in
+ * fixed updates (`PhysicsSystem`, `CharacterController`, behavior scripts
+ * that move actors in `fixedUpdate`) and BEFORE `Renderer` in the system
+ * configuration.
+ *
+ * @category Systems
+ */
+export class Interpolator extends SceneSystem {
+    actorQuery;
+    time;
+    world;
+    api;
+    constructor(options) {
+        super();
+        this.time = options.time;
+        this.world = options.world;
+        this.actorQuery = new ActorQuery({
+            scene: options.scene,
+            filter: [Interpolation, Transform],
+        });
+        this.api = new InterpolatorAPI({ time: options.time });
+    }
+    onSceneEnter() {
+        this.world.systemApi.register(this.api);
+    }
+    onSceneExit() {
+        this.world.systemApi.unregister(InterpolatorAPI);
+    }
+    onSceneDestroy() {
+        this.actorQuery.destroy();
+    }
+    fixedUpdate() {
+        for (const actor of this.actorQuery.getActors()) {
+            const interpolation = actor.getComponent(Interpolation);
+            const { local } = actor.getComponent(Transform);
+            if (interpolation.disabled) {
+                interpolation._initialized = false;
+                continue;
+            }
+            if (!interpolation._initialized || interpolation._snapRequested) {
+                snapToTransform(interpolation, local);
+                continue;
+            }
+            interpolation._prevX = interpolation._currX;
+            interpolation._prevY = interpolation._currY;
+            interpolation._prevRotation = interpolation._currRotation;
+            interpolation._currX = local.position.x;
+            interpolation._currY = local.position.y;
+            interpolation._currRotation = local.rotation;
+            const threshold = interpolation.snapThreshold;
+            if (threshold > 0) {
+                const dx = interpolation._currX - interpolation._prevX;
+                const dy = interpolation._currY - interpolation._prevY;
+                if (dx * dx + dy * dy > threshold * threshold) {
+                    interpolation._prevX = interpolation._currX;
+                    interpolation._prevY = interpolation._currY;
+                    interpolation._prevRotation = interpolation._currRotation;
+                }
+            }
+        }
+    }
+    update() {
+        const { alpha, fixedDeltaTime } = this.time;
+        for (const actor of this.actorQuery.getActors()) {
+            const interpolation = actor.getComponent(Interpolation);
+            if (interpolation.disabled) {
+                continue;
+            }
+            if (interpolation._snapRequested) {
+                snapToTransform(interpolation, actor.getComponent(Transform).local);
+                continue;
+            }
+            if (!interpolation._initialized) {
+                continue;
+            }
+            computeRenderValues(actor, interpolation, alpha, fixedDeltaTime);
+        }
+    }
+}
+Interpolator.systemName = 'Interpolator';

package/build/contrib/systems/interpolator/tests/helpers.d.ts

@@ -0,0 +1,13 @@
+import { Actor } from '../../../../engine/actor';
+import { Scene } from '../../../../engine/scene';
+import { World } from '../../../../engine/world';
+import { Time } from '../../../../engine/time';
+import type { InterpolationConfig } from '../../../components/interpolation';
+import { Interpolator } from '../system';
+export declare const createScene: () => Scene;
+export declare const createInterpolator: (scene: Scene) => {
+    system: Interpolator;
+    world: World;
+    time: Time;
+};
+export declare const createInterpolatedActor: (id: string, x: number, y: number, config?: InterpolationConfig) => Actor;

package/build/contrib/systems/interpolator/tests/helpers.js

@@ -0,0 +1,45 @@
+import { Actor, ActorCreator, ActorSpawner } from '../../../../engine/actor';
+import { Scene } from '../../../../engine/scene';
+import { TemplateCollection } from '../../../../engine/template';
+import { World } from '../../../../engine/world';
+import { Time } from '../../../../engine/time';
+import { Interpolation } from '../../../components/interpolation';
+import { Transform } from '../../../components/transform';
+import { Interpolator } from '../system';
+export const createScene = () => {
+    const templateCollection = new TemplateCollection();
+    const actorCreator = new ActorCreator([], templateCollection);
+    return new Scene({
+        id: 'scene',
+        name: 'scene',
+        actors: [],
+        actorCreator,
+        templateCollection,
+    });
+};
+export const createInterpolator = (scene) => {
+    const world = new World({ id: 'world', name: 'world' });
+    const templateCollection = new TemplateCollection();
+    const actorCreator = new ActorCreator([], templateCollection);
+    const time = new Time();
+    time.fixedDeltaTime = 0.1;
+    world.appendChild(scene);
+    const system = new Interpolator({
+        scene,
+        world,
+        actorSpawner: new ActorSpawner(actorCreator),
+        globalOptions: {},
+        templateCollection,
+        time,
+    });
+    system.onSceneEnter?.();
+    return { system, world, time };
+};
+export const createInterpolatedActor = (id, x, y, config = {}) => {
+    const actor = new Actor({ id, name: id });
+    const transform = actor.getComponent(Transform);
+    transform.local.position.x = x;
+    transform.local.position.y = y;
+    actor.setComponent(new Interpolation(config));
+    return actor;
+};

package/build/contrib/systems/interpolator/utils.d.ts

@@ -0,0 +1,5 @@
+import type { Actor } from '../../../engine/actor';
+import type { Interpolation } from '../../components/interpolation';
+import type { LocalTransform } from '../../components/transform/local-transform';
+export declare const snapToTransform: (interpolation: Interpolation, local: LocalTransform) => void;
+export declare const computeRenderValues: (actor: Actor, interpolation: Interpolation, alpha: number, fixedDeltaTime: number) => void;

package/build/contrib/systems/interpolator/utils.js

@@ -0,0 +1,41 @@
+import { MathOps } from '../../../engine/math-lib';
+import { RigidBody } from '../../components/rigid-body';
+export const snapToTransform = (interpolation, local) => {
+    interpolation._prevX = local.position.x;
+    interpolation._prevY = local.position.y;
+    interpolation._prevRotation = local.rotation;
+    interpolation._currX = local.position.x;
+    interpolation._currY = local.position.y;
+    interpolation._currRotation = local.rotation;
+    interpolation.renderX = local.position.x;
+    interpolation.renderY = local.position.y;
+    interpolation.renderRotation = local.rotation;
+    interpolation._initialized = true;
+    interpolation._snapRequested = false;
+};
+export const computeRenderValues = (actor, interpolation, alpha, fixedDeltaTime) => {
+    if (interpolation.mode === 'extrapolate') {
+        const rigidBody = actor.getComponent(RigidBody);
+        if (rigidBody !== undefined && !rigidBody.disabled) {
+            const timeAhead = alpha * fixedDeltaTime;
+            interpolation.renderX =
+                interpolation._currX + rigidBody.linearVelocity.x * timeAhead;
+            interpolation.renderY =
+                interpolation._currY + rigidBody.linearVelocity.y * timeAhead;
+            interpolation.renderRotation = rigidBody.lockRotation
+                ? interpolation._currRotation
+                : interpolation._currRotation + rigidBody.angularVelocity * timeAhead;
+            return;
+        }
+    }
+    interpolation.renderX =
+        interpolation._prevX +
+            (interpolation._currX - interpolation._prevX) * alpha;
+    interpolation.renderY =
+        interpolation._prevY +
+            (interpolation._currY - interpolation._prevY) * alpha;
+    interpolation.renderRotation =
+        interpolation._prevRotation +
+            MathOps.getAngleDelta(interpolation._prevRotation, interpolation._currRotation) *
+                alpha;
+};