Fixed Timestep Interpolation (3D)

Adds 3D fixed timestep interpolation to the rendering server.
This does not yet include support for multimeshes or particles.

Co-authored-by: lawnjelly <lawnjelly@gmail.com>

1 files changed, 146 insertions, 1 deletions

diff --git a/scene/3d/node_3d.cpp b/scene/3d/node_3d.cpp
index 2e08afb30d..86ce8a881a 100644
--- a/scene/3d/node_3d.cpp
+++ b/scene/3d/node_3d.cpp
@@ -30,6 +30,7 @@
 
 #include "node_3d.h"
 
+#include "core/math/transform_interpolator.h"
 #include "scene/3d/visual_instance_3d.h"
 #include "scene/main/viewport.h"
 #include "scene/property_utils.h"
@@ -176,6 +177,7 @@ void Node3D::_notification(int p_what) {
 			data.parent = nullptr;
 			data.C = nullptr;
 			_update_visibility_parent(true);
+			_disable_client_physics_interpolation();
 		} break;
 
 		case NOTIFICATION_ENTER_WORLD: {
@@ -226,6 +228,12 @@ void Node3D::_notification(int p_what) {
 			}
 #endif
 		} break;
+
+		case NOTIFICATION_RESET_PHYSICS_INTERPOLATION: {
+			if (data.client_physics_interpolation_data) {
+				data.client_physics_interpolation_data->global_xform_prev = data.client_physics_interpolation_data->global_xform_curr;
+			}
+		} break;
 	}
 }
 
@@ -341,6 +349,119 @@ Transform3D Node3D::get_transform() const {
 	return data.local_transform;
 }
 
+// Return false to timeout and remove from the client interpolation list.
+bool Node3D::update_client_physics_interpolation_data() {
+	if (!is_inside_tree() || !_is_physics_interpolated_client_side()) {
+		return false;
+	}
+
+	ERR_FAIL_NULL_V(data.client_physics_interpolation_data, false);
+	ClientPhysicsInterpolationData &pid = *data.client_physics_interpolation_data;
+
+	uint64_t tick = Engine::get_singleton()->get_physics_frames();
+
+	// Has this update been done already this tick?
+	// (For instance, get_global_transform_interpolated() could be called multiple times.)
+	if (pid.current_physics_tick != tick) {
+		// Timeout?
+		if (tick >= pid.timeout_physics_tick) {
+			return false;
+		}
+
+		if (pid.current_physics_tick == (tick - 1)) {
+			// Normal interpolation situation, there is a continuous flow of data
+			// from one tick to the next...
+			pid.global_xform_prev = pid.global_xform_curr;
+		} else {
+			// There has been a gap, we cannot sensibly offer interpolation over
+			// a multitick gap, so we will teleport.
+			pid.global_xform_prev = get_global_transform();
+		}
+		pid.current_physics_tick = tick;
+	}
+
+	pid.global_xform_curr = get_global_transform();
+	return true;
+}
+
+void Node3D::_disable_client_physics_interpolation() {
+	// Disable any current client side interpolation.
+	// (This can always restart as normal if you later re-attach the node to the SceneTree.)
+	if (data.client_physics_interpolation_data) {
+		memdelete(data.client_physics_interpolation_data);
+		data.client_physics_interpolation_data = nullptr;
+
+		SceneTree *tree = get_tree();
+		if (tree && _client_physics_interpolation_node_3d_list.in_list()) {
+			tree->client_physics_interpolation_remove_node_3d(&_client_physics_interpolation_node_3d_list);
+		}
+	}
+	_set_physics_interpolated_client_side(false);
+}
+
+Transform3D Node3D::_get_global_transform_interpolated(real_t p_interpolation_fraction) {
+	ERR_FAIL_COND_V(!is_inside_tree(), Transform3D());
+
+	// Set in motion the mechanisms for client side interpolation if not already active.
+	if (!_is_physics_interpolated_client_side()) {
+		_set_physics_interpolated_client_side(true);
+
+		ERR_FAIL_COND_V(data.client_physics_interpolation_data != nullptr, Transform3D());
+		data.client_physics_interpolation_data = memnew(ClientPhysicsInterpolationData);
+		data.client_physics_interpolation_data->global_xform_curr = get_global_transform();
+		data.client_physics_interpolation_data->global_xform_prev = data.client_physics_interpolation_data->global_xform_curr;
+		data.client_physics_interpolation_data->current_physics_tick = Engine::get_singleton()->get_physics_frames();
+	}
+
+	// Storing the last tick we requested client interpolation allows us to timeout
+	// and remove client interpolated nodes from the list to save processing.
+	// We use some arbitrary timeout here, but this could potentially be user defined.
+
+	// Note: This timeout has to be larger than the number of ticks in a frame, otherwise the interpolated
+	// data will stop flowing before the next frame is drawn. This should only be relevant at high tick rates.
+	// We could alternatively do this by frames rather than ticks and avoid this problem, but then the behavior
+	// would be machine dependent.
+	data.client_physics_interpolation_data->timeout_physics_tick = Engine::get_singleton()->get_physics_frames() + 256;
+
+	// Make sure data is up to date.
+	update_client_physics_interpolation_data();
+
+	// Interpolate the current data.
+	const Transform3D &xform_curr = data.client_physics_interpolation_data->global_xform_curr;
+	const Transform3D &xform_prev = data.client_physics_interpolation_data->global_xform_prev;
+
+	Transform3D res;
+	TransformInterpolator::interpolate_transform_3d(xform_prev, xform_curr, res, p_interpolation_fraction);
+
+	SceneTree *tree = get_tree();
+
+	// This should not happen, as is_inside_tree() is checked earlier.
+	ERR_FAIL_NULL_V(tree, res);
+	if (!_client_physics_interpolation_node_3d_list.in_list()) {
+		tree->client_physics_interpolation_add_node_3d(&_client_physics_interpolation_node_3d_list);
+	}
+
+	return res;
+}
+
+Transform3D Node3D::get_global_transform_interpolated() {
+	// Pass through if physics interpolation is switched off.
+	// This is a convenience, as it allows you to easy turn off interpolation
+	// without changing any code.
+	if (!is_physics_interpolated_and_enabled()) {
+		return get_global_transform();
+	}
+
+	// If we are in the physics frame, the interpolated global transform is meaningless.
+	// However, there is an exception, we may want to use this as a means of starting off the client
+	// interpolation pump if not already started (when _is_physics_interpolated_client_side() is false).
+	if (Engine::get_singleton()->is_in_physics_frame() && _is_physics_interpolated_client_side()) {
+		return get_global_transform();
+	}
+
+	return _get_global_transform_interpolated(Engine::get_singleton()->get_physics_interpolation_fraction());
+}
+
 Transform3D Node3D::get_global_transform() const {
 	ERR_FAIL_COND_V(!is_inside_tree(), Transform3D());
 
@@ -1140,6 +1261,7 @@ void Node3D::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("set_global_transform", "global"), &Node3D::set_global_transform);
 	ClassDB::bind_method(D_METHOD("get_global_transform"), &Node3D::get_global_transform);
+	ClassDB::bind_method(D_METHOD("get_global_transform_interpolated"), &Node3D::get_global_transform_interpolated);
 	ClassDB::bind_method(D_METHOD("set_global_position", "position"), &Node3D::set_global_position);
 	ClassDB::bind_method(D_METHOD("get_global_position"), &Node3D::get_global_position);
 	ClassDB::bind_method(D_METHOD("set_global_basis", "basis"), &Node3D::set_global_basis);
@@ -1236,4 +1358,27 @@ void Node3D::_bind_methods() {
 }
 
 Node3D::Node3D() :
-		xform_change(this) {}
+		xform_change(this), _client_physics_interpolation_node_3d_list(this) {
+	// Default member initializer for bitfield is a C++20 extension, so:
+
+	data.top_level = false;
+	data.inside_world = false;
+
+	data.ignore_notification = false;
+	data.notify_local_transform = false;
+	data.notify_transform = false;
+
+	data.visible = true;
+	data.disable_scale = false;
+	data.vi_visible = true;
+
+#ifdef TOOLS_ENABLED
+	data.gizmos_disabled = false;
+	data.gizmos_dirty = false;
+	data.transform_gizmo_visible = true;
+#endif
+}
+
+Node3D::~Node3D() {
+	_disable_client_physics_interpolation();
+}