Decouple render from fixed sim tick with interpolation (#502)

[drsnuggles8]

Closes #502. Second acceptance criterion of parent #456 (slice 1 — frame-rate limiter + smoothing — shipped in #501).

What

Renders an interpolated pose between the two most recent fixed-tick simulation states so motion stays smooth when the display rate isn't a multiple of the sim rate (e.g. 60 Hz sim on a 144 Hz display). The deterministic fixed-tick accumulator already existed in Scene::OnUpdateRuntimeFixed (#484/#452); this builds interpolation on top of it.

How

• Scene::OnUpdateRuntimeFixed snapshots each entity's local TransformComponent into m_InterpPrev before each fixed step and into m_InterpCurr after the last step, and publishes m_RenderInterpAlpha = accumulator / fixedDt.
• Scene::RenderRuntime overwrites live local transforms with the blended pose (glm::mix translation/scale, glm::slerp rotation), re-propagates world matrices, renders, then restores the exact fixed-tick poses. Overwrite-then-restore makes every render read — GetWorldTransform() world matrices and the direct TransformComponent::GetTransform() reads in RenderScene3D (terrain/water/foliage/decals) — see the blended pose without threading alpha through every draw call.
• Restore copies the whole component (the private Rotation/RotationEuler would drift if restored via SetRotation()). The primary fly-cam is excluded from the overwrite (it's display-rate; restoring from the snapshot would erase its movement) — a gameplay camera's view is blended into cameraTransform directly instead.
• Determinism-safe: interpolation only ever runs in RenderRuntime and restores the persisted state before returning, so SaveGameManager::Tick / editor gizmos read the exact tick pose and Feature/deterministic fixed timestep #484 does not regress.

Editor toggle

EditorPreferences::RenderInterpolation (Performance tab, on by default). Persisted, applied on Play, and live via ApplyPreferences so toggling it takes effect on a running session. OloRuntime uses the default.

Testing

• New: RenderInterpolationSmoothsMotionTest (Functional) — drives a Lua constant-velocity mover through OnUpdateRuntimeFixed at 60 Hz sim / 144 Hz render and proves (1) the interpolated render pose advances in near-constant increments (monotonic, second difference ≈ 0 → judder-free) while the raw sim pose visibly stair-steps, and (2) interpolation never leaks a fractional pose into persisted sim state (raw pose stays exactly on the integer tick count).
• No regression: existing FixedTimestepDeterminismTest / DeterministicReplayProducesSameStateTest pass unchanged.
• Full suite: 4185 passed / 0 failed (3 SKIP by design). Editor builds + renders the full pipeline correctly (verified via screenshot).

Visual-verification note

Motion smoothness is proven analytically by the functional test (constant velocity ⇒ provably linear render trajectory), since Play-mode live motion can't be driven headlessly. This change adds no new pixel-producing code (no shader/pass/material/blend) — it only changes the input transforms fed to the already-pixel-tested GetWorldTransform→renderer path, and the full GPU visual-evidence suite stays green.

🤖 Generated with Claude Code

Summary by CodeRabbit

• New Features

  • Added a new Render Interpolation preference in the Performance settings, with a help tooltip and default enabled.
  • Enabled smoother in-game rendering by blending poses between fixed simulation ticks during Play mode.

• Bug Fixes

  • Render interpolation now applies immediately when starting Play mode and updates live during a running session.
  • Saved preference settings now persist correctly across app restarts.

• Tests

  • Added functional coverage to verify smoother motion and preserve exact simulation state.

[coderabbitai]

Warning

Review limit reached

@drsnuggles8, you've reached your PR review limit, so we couldn't start this review.

Next review available in: 50 minutes

Enable usage-based reviews in Billing to review now. Otherwise, wait until the next included review is available.
You're only billed for reviews past your plan's rate limits ($0.25/file).

How can I continue?

After more reviews become available, a review can be triggered using the @coderabbitai review command as a PR comment. Alternatively, push new commits to this PR.

To avoid repeated limits, reduce automatic review volume by pausing incremental auto-reviews earlier, using label-based review opt-in, excluding WIP or generated PR titles, or requesting reviews manually when the PR is ready. If your team needs uninterrupted high-volume reviews, an organization admin can enable usage-based reviews.

How do review limits work?

CodeRabbit enforces per-developer PR review limits for each organization. Most developers receive the normal plan review availability.

For paid Pro and Pro+ PR reviews, CodeRabbit uses adaptive limits for sustained high-volume activity. When a developer's recent PR review activity reaches the 95th percentile or higher among CodeRabbit users, additional reviews become available more gradually as earlier reviews age out of the rolling window.

Please refer docs for additional details.

Review details

⚙️ Run configuration

Configuration used: Repository UI

Review profile: ASSERTIVE

Plan: Pro

Run ID: 49406ec0-9786-420b-b3c1-ee133364f8e8

📥 Commits

Reviewing files that changed from the base of the PR and between 19398e8 and b85218c.

📒 Files selected for processing (3)

• OloEngine/src/OloEngine/Scene/Scene.cpp
• OloEngine/src/OloEngine/Scene/Scene.h
• OloEngine/tests/Functional/Scene/RenderInterpolationSmoothsMotionTest.cpp

📝 Walkthrough

Walkthrough

Adds a render interpolation system to Scene that blends rendered poses between fixed simulation ticks using snapshot capture and quaternion/vector interpolation, exposes a new RenderInterpolation editor preference wired into EditorLayer and EditorPreferencesPanel, and adds a functional test verifying interpolated motion behavior.

Changes

Render Interpolation Feature

Layer / File(s)	Summary
Scene interpolation API and state OloEngine/src/OloEngine/Scene/Scene.h	Adds InterpTransform pose struct, public methods (SetRenderInterpolationEnabled, IsRenderInterpolationEnabled, GetRenderInterpolationAlpha, GetInterpolatedLocalTransform), private capture/compute helpers, and member state for snapshots, alpha, and enable flag.
Fixed-step snapshot capture and interpolation computation OloEngine/src/OloEngine/Scene/Scene.cpp	Clears interpolation state on OnRuntimeStart/OnSimulationStart, snapshots locals before/after fixed steps and computes blend alpha in OnUpdateRuntimeFixed, and implements helper functions for capturing transforms and computing mix/slerp-blended local poses.
RenderRuntime pose blending and restore OloEngine/src/OloEngine/Scene/Scene.cpp	Tracks the primary camera in RenderRuntime, overwrites non-camera transforms with interpolated poses and blends the camera view for rendering, then restores authoritative poses and re-propagates world transforms post-render.
Editor preference wiring for render interpolation OloEditor/src/Panels/EditorPreferencesPanel.h, OloEditor/src/Panels/EditorPreferencesPanel.cpp, OloEditor/src/EditorLayer.cpp	Adds RenderInterpolation field to EditorPreferences, exposes a checkbox with tooltip in the Performance tab, persists it via YAML Save/Load, and applies it to the active scene in ApplyPreferences and OnScenePlay.
Functional tests for interpolated motion OloEngine/tests/Functional/Scene/RenderInterpolationSmoothsMotionTest.cpp, OloEngine/tests/CMakeLists.txt	Adds a Lua-driven mover test fixture and two tests validating judder-free interpolated rendering and that interpolation does not leak into persisted simulation state; wires the new test file into the test build.

Sequence Diagram(s)

sequenceDiagram
  participant FixedLoop as OnUpdateRuntimeFixed
  participant Scene
  participant RenderRuntime

  FixedLoop->>Scene: CaptureLocalTransforms into m_InterpPrev
  FixedLoop->>Scene: run fixed simulation step
  FixedLoop->>Scene: CaptureLocalTransforms into m_InterpCurr
  FixedLoop->>Scene: compute m_RenderInterpAlpha
  RenderRuntime->>Scene: GetInterpolatedLocalTransform per entity
  RenderRuntime->>RenderRuntime: overwrite transforms, PropagateWorldTransforms
  RenderRuntime->>RenderRuntime: render frame
  RenderRuntime->>Scene: restore authoritative poses
  RenderRuntime->>RenderRuntime: PropagateWorldTransforms (authoritative)

Loading

Related PRs: None identified.

Suggested labels: enhancement, scene, editor, tests

Suggested reviewers: drsnuggles8

🐰 Hopping between ticks so smooth,
Poses blend, no judder to soothe,
Snapshots kept in either hand,
Alpha slides where curr meets prev,
Then true state stands, restored, unbowed.

🚥 Pre-merge checks | ✅ 4

✅ Passed checks (4 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title clearly summarizes the main change: render interpolation to decouple rendering from fixed simulation ticks.
Linked Issues check	✅ Passed	The changes implement interpolated rendering, preserve deterministic simulation state, add an editor toggle, and include a functional test for non-multiple refresh motion.
Out of Scope Changes check	✅ Passed	All code changes are directly related to render interpolation, editor preference persistence, runtime application, and validation tests.

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}

[sonarqubecloud]

Quality Gate passed

Issues
4 New issues
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud