A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.
TypeScript 2d-game-engine3d3d-game-engineandroidcppecsgame-editorgame-enginegamedeviostypescriptwebassemblywebglwebgpuwechat-minigame
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team
#include "../ecs/TransformSystem.hpp"
#include "TweenSystem.hpp"
#include "EasingFunctions.hpp"
#include "../ecs/components/Transform.hpp"
#include "../ecs/components/Sprite.hpp"
#include "../ecs/components/Camera.hpp"
#include "../ecs/components/UINode.hpp"
#include <glm/glm.hpp>
#include <cmath>
#include <algorithm>
#include <limits>
namespace esengine::animation {
void TweenSystem::update(ecs::Registry& registry, f32 deltaTime) {
pending_remove_.clear();
for (auto entity : ui_flagged_) {
if (auto* n = registry.tryGet<ecs::UINode>(entity)) {
n->anim_override_ = 0;
registry.markChanged<ecs::UINode>(entity);
}
}
ui_flagged_.clear();
for (auto entity : registry.view<TweenData>()) {
auto& tween = registry.get<TweenData>(entity);
if (tween.state != TweenState::Running) {
if (tween.state == TweenState::Completed || tween.state == TweenState::Cancelled) {
pending_remove_.push_back(entity);
}
continue;
}
if (!registry.isEntityActive(entity) || !registry.isEntityActive(tween.target_entity)) continue;
// A running tween moves its own clock every frame: its record is written whatever it drives.
registry.markChanged<TweenData>(entity);
f32 tweenDelta = deltaTime;
if (tween.delay > 0.0f) {
tween.delay -= deltaTime;
if (tween.delay > 0.0f) {
// HOLD the start value while waiting, rather than leaving the target
// wherever it was. `from` is what the caller said the tween starts at,
// and a delay is "start later", not "start elsewhere" — without this a
// staggered entrance sits in its final place and only then jumps out to
// animate in. It also keeps UI layout off the animated axis for the
// whole wait, since the override flag is set by the write.
applyValue(registry, tween, tween.from_value);
continue;
}
tweenDelta = -tween.delay;
tween.delay = 0.0f;
}
tween.elapsed = static_cast<f32>(std::min(
static_cast<double>(tween.elapsed) + tweenDelta,
static_cast<double>(std::numeric_limits<f32>::max())));
if (tween.loop_mode != LoopMode::None && tween.duration > 0.0f && tween.elapsed > tween.duration) {
const double elapsed = tween.elapsed;
const double duration = tween.duration;
const double remainder = std::fmod(elapsed, duration);
double skipped = std::floor(elapsed / duration) - (remainder == 0.0 ? 1.0 : 0.0);
bool reverse = (std::fmod(elapsed, duration * 2.0) >= duration) != (remainder == 0.0);
if (tween.loops_remaining > 0 && skipped >= tween.loops_remaining) {
skipped = tween.loops_remaining - 1;
reverse = static_cast<i32>(skipped) % 2 != 0;
tween.elapsed = tween.duration;
} else {
// Keep exact boundaries at the endpoint of the preceding cycle.
tween.elapsed = static_cast<f32>(remainder == 0.0 ? duration : remainder);
}
if (tween.loops_remaining > 0) tween.loops_remaining -= static_cast<i32>(skipped);
if (tween.loop_mode == LoopMode::PingPong && reverse) {
std::swap(tween.from_value, tween.to_value);
}
}
f32 rawT = (tween.duration > 0.0f)
? glm::clamp(tween.elapsed / tween.duration, 0.0f, 1.0f)
: 1.0f;
f32 easedT = evaluateEasing(tween, rawT);
f32 value = glm::mix(tween.from_value, tween.to_value, easedT);
applyValue(registry, tween, value);
if (rawT >= 1.0f) {
if (tween.loop_mode == LoopMode::None) {
tween.state = TweenState::Completed;
pending_remove_.push_back(entity);
} else if (tween.loop_mode == LoopMode::Restart) {
tween.elapsed = 0.0f;
if (tween.loops_remaining > 0) {
tween.loops_remaining--;
if (tween.loops_remaining == 0) {
tween.state = TweenState::Completed;
pending_remove_.push_back(entity);
}
}
} else if (tween.loop_mode == LoopMode::PingPong) {
tween.elapsed = 0.0f;
std::swap(tween.from_value, tween.to_value);
if (tween.loops_remaining > 0) {
tween.loops_remaining--;
if (tween.loops_remaining == 0) {
tween.state = TweenState::Completed;
pending_remove_.push_back(entity);
}
}
}
}
if (tween.state == TweenState::Completed && tween.sequence_next != INVALID_ENTITY) {
if (auto* next = registry.tryGet<TweenData>(tween.sequence_next);
next && next->state == TweenState::Paused) {
next->state = TweenState::Running;
registry.markChanged<TweenData>(tween.sequence_next);
}
}
}
for (auto entity : pending_remove_) {
registry.destroy(entity);
}
}
Entity TweenSystem::createTween(ecs::Registry& registry, Entity targetEntity,
TweenTarget property, f32 from, f32 to,
f32 duration, EasingType easing) {
Entity tweenEntity = registry.create();
auto& tween = registry.emplace<TweenData>(tweenEntity);
tween.target_entity = targetEntity;
tween.target_property = property;
tween.from_value = from;
tween.to_value = to;
tween.duration = duration;
tween.easing = easing;
tween.state = TweenState::Running;
// Take the start value NOW, not on the next update: a tween created after this
// frame's tween pass would otherwise leave one frame showing the target where it
// was — and for an entrance, where it was IS where the tween is taking it, so the
// motion appears to play, stop, and play again.
applyValue(registry, tween, from);
return tweenEntity;
}
void TweenSystem::cancelTween(ecs::Registry& registry, Entity tweenEntity) {
if (auto* tween = registry.tryGet<TweenData>(tweenEntity)) {
tween->state = TweenState::Cancelled;
registry.markChanged<TweenData>(tweenEntity);
}
}
void TweenSystem::cancelAllTweens(ecs::Registry& registry, Entity targetEntity) {
for (auto entity : registry.view<TweenData>()) {
auto& tween = registry.get<TweenData>(entity);
if (tween.target_entity == targetEntity && tween.state == TweenState::Running) {
tween.state = TweenState::Cancelled;
registry.markChanged<TweenData>(entity);
}
}
}
void TweenSystem::pauseTween(ecs::Registry& registry, Entity tweenEntity) {
if (auto* tween = registry.tryGet<TweenData>(tweenEntity)) {
if (tween->state == TweenState::Running) {
tween->state = TweenState::Paused;
registry.markChanged<TweenData>(tweenEntity);
}
}
}
void TweenSystem::resumeTween(ecs::Registry& registry, Entity tweenEntity) {
if (auto* tween = registry.tryGet<TweenData>(tweenEntity)) {
if (tween->state == TweenState::Paused) {
tween->state = TweenState::Running;
registry.markChanged<TweenData>(tweenEntity);
}
}
}
// Tween owns the writes for its fixed 13 targets (was routed through the generic
// animTargets `applyAnimatedValue`; decoupled so the generic enum+switch could be
// deleted with the C++ timeline). Mirrors the
// per-field semantics exactly: rotation.z → half-angle quaternion, and the UINode
// `anim_override_` flags so UI layout doesn't clobber animated Transform fields.
// Flag the entity's UINode so the layout pass leaves the tween-driven Transform
// field alone this frame; `flagged` remembers the entity for next frame's clear.
static void markUIAnimOverride(ecs::Registry& registry, Entity entity, u8 flag,
std::vector<Entity>& flagged) {
if (auto* n = registry.tryGet<ecs::UINode>(entity)) {
if (n->anim_override_ == 0) flagged.push_back(entity);
n->anim_override_ |= flag;
registry.markChanged<ecs::UINode>(entity);
}
}
static void applyTweenValue(ecs::Registry& registry, Entity entity, TweenTarget target, f32 value,
std::vector<Entity>& flagged) {
// Position, scale and rotation targets write local Transform fields.
// Notifying for colour targets too costs one recompose that changes
// nothing, where missing one leaves the world reading a stale transform.
ecs::invalidateTransformComposition();
switch (target) {
case TweenTarget::PositionX:
if (auto* c = registry.tryGet<ecs::Transform>(entity)) {
c->position.x = value;
markUIAnimOverride(registry, entity, ecs::UINode::ANIM_POS_X, flagged);
}
break;
case TweenTarget::PositionY:
if (auto* c = registry.tryGet<ecs::Transform>(entity)) {
c->position.y = value;
markUIAnimOverride(registry, entity, ecs::UINode::ANIM_POS_Y, flagged);
}
break;
case TweenTarget::PositionZ:
if (auto* c = registry.tryGet<ecs::Transform>(entity)) c->position.z = value;
break;
case TweenTarget::ScaleX:
if (auto* c = registry.tryGet<ecs::Transform>(entity)) {
c->scale.x = value;
markUIAnimOverride(registry, entity, ecs::UINode::ANIM_SCALE_X, flagged);
}
break;
case TweenTarget::ScaleY:
if (auto* c = registry.tryGet<ecs::Transform>(entity)) {
c->scale.y = value;
markUIAnimOverride(registry, entity, ecs::UINode::ANIM_SCALE_Y, flagged);
}
break;
case TweenTarget::RotationZ:
if (auto* c = registry.tryGet<ecs::Transform>(entity)) {
f32 h = value * 0.5f;
c->rotation = glm::quat(std::cos(h), 0.0f, 0.0f, std::sin(h));
markUIAnimOverride(registry, entity, ecs::UINode::ANIM_ROT_Z, flagged);
}
break;
case TweenTarget::ColorR:
if (auto* c = registry.tryGet<ecs::Sprite>(entity)) c->color.r = value;
break;
case TweenTarget::ColorG:
if (auto* c = registry.tryGet<ecs::Sprite>(entity)) c->color.g = value;
break;
case TweenTarget::ColorB:
if (auto* c = registry.tryGet<ecs::Sprite>(entity)) c->color.b = value;
break;
case TweenTarget::ColorA:
if (auto* c = registry.tryGet<ecs::Sprite>(entity)) c->color.a = value;
break;
case TweenTarget::SizeX:
if (auto* c = registry.tryGet<ecs::Sprite>(entity)) c->size.x = value;
break;
case TweenTarget::SizeY:
if (auto* c = registry.tryGet<ecs::Sprite>(entity)) c->size.y = value;
break;
case TweenTarget::CameraOrthoSize:
if (auto* c = registry.tryGet<ecs::Camera>(entity)) c->orthoSize = value;
break;
default:
break;
}
// Said once, for the component the target names: a write a reader of changes (the renderer) has to see.
switch (target) {
case TweenTarget::PositionX: case TweenTarget::PositionY: case TweenTarget::PositionZ:
case TweenTarget::ScaleX: case TweenTarget::ScaleY: case TweenTarget::RotationZ:
registry.markChanged<ecs::Transform>(entity);
break;
case TweenTarget::ColorR: case TweenTarget::ColorG: case TweenTarget::ColorB: case TweenTarget::ColorA:
case TweenTarget::SizeX: case TweenTarget::SizeY:
registry.markChanged<ecs::Sprite>(entity);
break;
case TweenTarget::CameraOrthoSize:
registry.markChanged<ecs::Camera>(entity);
break;
default:
break;
}
}
void TweenSystem::applyValue(ecs::Registry& registry, const TweenData& tween, f32 value) {
Entity target = tween.target_entity;
if (!registry.valid(target)) {
return;
}
applyTweenValue(registry, target, tween.target_property, value, ui_flagged_);
}
f32 TweenSystem::evaluateEasing(const TweenData& tween, f32 t) {
if (tween.easing == EasingType::CubicBezier) {
return cubicBezier(t, tween.bezier_p1x, tween.bezier_p1y,
tween.bezier_p2x, tween.bezier_p2y);
}
auto fn = getEasingFunction(tween.easing);
return fn(t);
}
} // namespace esengine::animation