diff --git a/core/math/transform_interpolator.cpp b/core/math/transform_interpolator.cpp
index b5d9aad7c..d2c7b849f 100644
--- a/core/math/transform_interpolator.cpp
+++ b/core/math/transform_interpolator.cpp
@@ -30,6 +30,8 @@
#include "transform_interpolator.h"
+#include "core/math/transform_2d.h"
+
void TransformInterpolator::interpolate_transform(const Transform &p_prev, const Transform &p_curr, Transform &r_result, real_t p_fraction) {
r_result.origin = p_prev.origin + ((p_curr.origin - p_prev.origin) * p_fraction);
interpolate_basis(p_prev.basis, p_curr.basis, r_result.basis, p_fraction);
@@ -40,6 +42,49 @@ void TransformInterpolator::interpolate_basis(const Basis &p_prev, const Basis &
interpolate_basis_via_method(p_prev, p_curr, r_result, p_fraction, method);
}
+void TransformInterpolator::interpolate_transform_2d(const Transform2D &p_prev, const Transform2D &p_curr, Transform2D &r_result, real_t p_fraction) {
+ // Extract parameters.
+ Vector2 p1 = p_prev.get_origin();
+ Vector2 p2 = p_curr.get_origin();
+
+ // Special case for physics interpolation, if flipping, don't interpolate basis.
+ // If the determinant polarity changes, the handedness of the coordinate system changes.
+ if (_sign(p_prev.basis_determinant()) != _sign(p_curr.basis_determinant())) {
+ r_result.columns[0] = p_curr.columns[0];
+ r_result.columns[1] = p_curr.columns[1];
+ r_result.set_origin(Vector2::linear_interpolate(p1, p2, p_fraction));
+ return;
+ }
+
+ real_t r1 = p_prev.get_rotation();
+ real_t r2 = p_curr.get_rotation();
+
+ Size2 s1 = p_prev.get_scale();
+ Size2 s2 = p_curr.get_scale();
+
+ // Slerp rotation.
+ Vector2 v1(Math::cos(r1), Math::sin(r1));
+ Vector2 v2(Math::cos(r2), Math::sin(r2));
+
+ real_t dot = v1.dot(v2);
+
+ dot = CLAMP(dot, -1, 1);
+
+ Vector2 v;
+
+ if (dot > 0.9995f) {
+ v = Vector2::linear_interpolate(v1, v2, p_fraction).normalized(); // Linearly interpolate to avoid numerical precision issues.
+ } else {
+ real_t angle = p_fraction * Math::acos(dot);
+ Vector2 v3 = (v2 - v1 * dot).normalized();
+ v = v1 * Math::cos(angle) + v3 * Math::sin(angle);
+ }
+
+ // Construct matrix.
+ r_result = Transform2D(Math::atan2(v.y, v.x), Vector2::linear_interpolate(p1, p2, p_fraction));
+ r_result.scale_basis(Vector2::linear_interpolate(s1, s2, p_fraction));
+}
+
void TransformInterpolator::interpolate_transform_via_method(const Transform &p_prev, const Transform &p_curr, Transform &r_result, real_t p_fraction, Method p_method) {
r_result.origin = p_prev.origin + ((p_curr.origin - p_prev.origin) * p_fraction);
interpolate_basis_via_method(p_prev.basis, p_curr.basis, r_result.basis, p_fraction, p_method);
diff --git a/core/math/transform_interpolator.h b/core/math/transform_interpolator.h
index f693a9933..ef4fc5b1d 100644
--- a/core/math/transform_interpolator.h
+++ b/core/math/transform_interpolator.h
@@ -46,6 +46,7 @@
// than performing every frame.
struct Transform;
+struct Transform2D;
class TransformInterpolator {
public:
@@ -65,6 +66,7 @@ private:
static Quaternion _basis_to_quat_unchecked(const Basis &p_basis);
static bool _basis_is_orthogonal(const Basis &p_basis, real_t p_epsilon = 0.01f);
static bool _basis_is_orthogonal_any_scale(const Basis &p_basis);
+ static bool _sign(real_t p_val) { return p_val >= 0; }
static void interpolate_basis_linear(const Basis &p_prev, const Basis &p_curr, Basis &r_result, real_t p_fraction);
static void interpolate_basis_scaled_slerp(Basis p_prev, Basis p_curr, Basis &r_result, real_t p_fraction);
@@ -74,6 +76,7 @@ public:
// These will be slower.
static void interpolate_transform(const Transform &p_prev, const Transform &p_curr, Transform &r_result, real_t p_fraction);
static void interpolate_basis(const Basis &p_prev, const Basis &p_curr, Basis &r_result, real_t p_fraction);
+ static void interpolate_transform_2d(const Transform2D &p_prev, const Transform2D &p_curr, Transform2D &r_result, real_t p_fraction);
// Optimized function when you know ahead of time the method
static void interpolate_transform_via_method(const Transform &p_prev, const Transform &p_curr, Transform &r_result, real_t p_fraction, Method p_method);
diff --git a/core/os/main_loop.h b/core/os/main_loop.h
index 7ddb96c87..3669938fe 100644
--- a/core/os/main_loop.h
+++ b/core/os/main_loop.h
@@ -66,6 +66,7 @@ public:
virtual void input_text(const String &p_text);
virtual void init();
+ virtual void iteration_prepare() {}
virtual bool iteration(float p_time);
virtual void iteration_end() {}
virtual bool idle(float p_time);
diff --git a/doc/classes/Control.xml b/doc/classes/Control.xml
index cf28c56ab..07c84115f 100644
--- a/doc/classes/Control.xml
+++ b/doc/classes/Control.xml
@@ -746,6 +746,7 @@
Controls whether the control will be able to receive mouse button input events through [method _gui_input] and how these events should be handled. Also controls whether the control can receive the [signal mouse_entered], and [signal mouse_exited] signals. See the constants to learn what each does.
+
Enables whether rendering of [CanvasItem] based children should be clipped to this control's rectangle. If [code]true[/code], parts of a child which would be visibly outside of this control's rectangle will not be rendered.
diff --git a/doc/classes/ParallaxLayer.xml b/doc/classes/ParallaxLayer.xml
index 59cfe2367..0a495387d 100644
--- a/doc/classes/ParallaxLayer.xml
+++ b/doc/classes/ParallaxLayer.xml
@@ -23,6 +23,7 @@
Multiplies the ParallaxLayer's motion. If an axis is set to [code]0[/code], it will not scroll.
+
diff --git a/doc/classes/RenderingServer.xml b/doc/classes/RenderingServer.xml
index 12fd8fb79..de21bb734 100644
--- a/doc/classes/RenderingServer.xml
+++ b/doc/classes/RenderingServer.xml
@@ -315,6 +315,14 @@
Once finished with your RID, you will want to free the RID using the RenderingServer's [method free_rid] static method.
+
+
+
+
+ Prevents physics interpolation for the current physics tick.
+ This is useful when moving a canvas item to a new location, to give an instantaneous change rather than interpolation from the previous location.
+
+
@@ -365,6 +373,14 @@
Sets the index for the [CanvasItem].
+
+
+
+
+
+ Turns on and off physics interpolation for the canvas item.
+
+
@@ -453,6 +469,16 @@
Sets the [CanvasItem]'s Z index, i.e. its draw order (lower indexes are drawn first).
+
+
+
+
+
+ Transforms both the current and previous stored transform for a canvas item.
+ This allows transforming a canvas item without creating a "glitch" in the interpolation.
+ This is particularly useful for large worlds utilising a shifting origin.
+
+
@@ -483,6 +509,14 @@
Once finished with your RID, you will want to free the RID using the RenderingServer's [method free_rid] static method.
+
+
+
+
+ Prevents physics interpolation for the current physics tick.
+ This is useful when moving an occluder to a new location, to give an instantaneous change rather than interpolation from the previous location.
+
+
@@ -491,6 +525,14 @@
Enables or disables light occluder.
+
+
+
+
+
+ Turns on and off physics interpolation for the occluder.
+
+
@@ -515,6 +557,24 @@
Sets a light occluder's [Transform2D].
+
+
+
+
+
+ Transforms both the current and previous stored transform for an occluder.
+ This allows transforming an occluder without creating a "glitch" in the interpolation.
+ This is particularly useful for large worlds utilising a shifting origin.
+
+
+
+
+
+
+ Prevents physics interpolation for the current physics tick.
+ This is useful when moving a light to a new location, to give an instantaneous change rather than interpolation from the previous location.
+
+
@@ -547,6 +607,14 @@
Sets a canvas light's height.
+
+
+
+
+
+ Turns on and off physics interpolation for the light.
+
+
@@ -669,6 +737,16 @@
Sets the Z range of objects that will be affected by this light. Equivalent to [member Light2D.range_z_min] and [member Light2D.range_z_max].
+
+
+
+
+
+ Transforms both the current and previous stored transform for a light.
+ This allows transforming a light without creating a "glitch" in the interpolation.
+ This is particularly useful for large worlds utilising a shifting origin.
+
+
diff --git a/main/main.cpp b/main/main.cpp
index 78329f778..02d1ae2a1 100644
--- a/main/main.cpp
+++ b/main/main.cpp
@@ -2366,6 +2366,12 @@ bool Main::iteration() {
PhysicsServer::get_singleton()->flush_queries();
+ // Prepare the fixed timestep interpolated nodes
+ // BEFORE they are updated by the physics 2D,
+ // otherwise the current and previous transforms
+ // may be the same, and no interpolation takes place.
+ OS::get_singleton()->get_main_loop()->iteration_prepare();
+
Physics2DServer::get_singleton()->sync();
Physics2DServer::get_singleton()->flush_queries();
diff --git a/scene/2d/camera_2d.cpp b/scene/2d/camera_2d.cpp
index 2a3ac859a..19ee1e6ab 100644
--- a/scene/2d/camera_2d.cpp
+++ b/scene/2d/camera_2d.cpp
@@ -56,8 +56,12 @@ void Camera2D::_update_scroll() {
if (is_current()) {
ERR_FAIL_COND(custom_viewport && !ObjectDB::get_instance(custom_viewport_id));
- Transform2D xform = get_camera_transform();
-
+ Transform2D xform;
+ if (is_physics_interpolated_and_enabled()) {
+ xform = _interpolation_data.xform_prev.interpolate_with(_interpolation_data.xform_curr, Engine::get_singleton()->get_physics_interpolation_fraction());
+ } else {
+ xform = get_camera_transform();
+ }
viewport->set_canvas_transform(xform);
Size2 screen_size = viewport->get_visible_rect().size;
@@ -68,13 +72,24 @@ void Camera2D::_update_scroll() {
}
void Camera2D::_update_process_mode() {
- // smoothing can be enabled in the editor but will never be active
- if (process_mode == CAMERA2D_PROCESS_IDLE) {
- set_process_internal(smoothing_active);
- set_physics_process_internal(false);
+ if (is_physics_interpolated_and_enabled()) {
+ set_process_internal(is_current());
+ set_physics_process_internal(is_current());
+
+#ifdef TOOLS_ENABLED
+ if (process_mode == CAMERA2D_PROCESS_IDLE) {
+ WARN_PRINT_ONCE("Camera2D overridden to physics process mode due to use of physics interpolation.");
+ }
+#endif
} else {
- set_process_internal(false);
- set_physics_process_internal(smoothing_active);
+ // Smoothing can be enabled in the editor but will never be active.
+ if (process_mode == CAMERA2D_PROCESS_IDLE) {
+ set_process_internal(smoothing_active);
+ set_physics_process_internal(false);
+ } else {
+ set_process_internal(false);
+ set_physics_process_internal(smoothing_active);
+ }
}
}
@@ -179,8 +194,19 @@ Transform2D Camera2D::get_camera_transform() {
}
}
+ // TODO ..
+ // There is a bug here.
+ // Smoothing occurs rather confusingly
+ // during the call to get_camera_transform().
+ // It may be called MULTIPLE TIMES on certain frames,
+ // therefore smoothing is not currently applied only once per frame / tick,
+ // which will result in some haphazard results.
if (smoothing_active) {
- float c = smoothing * (process_mode == CAMERA2D_PROCESS_PHYSICS ? get_physics_process_delta_time() : get_process_delta_time());
+ // Note that if we are using physics interpolation,
+ // processing will always be physics based (it ignores the process mode set in the UI).
+ bool physics_process = (process_mode == CAMERA2D_PROCESS_PHYSICS) || is_physics_interpolated_and_enabled();
+ float delta = physics_process ? get_physics_process_delta_time() : get_process_delta_time();
+ float c = smoothing * delta;
smoothed_camera_pos = ((camera_pos - smoothed_camera_pos) * c) + smoothed_camera_pos;
ret_camera_pos = smoothed_camera_pos;
} else {
@@ -235,18 +261,51 @@ Transform2D Camera2D::get_camera_transform() {
return (xform).affine_inverse();
}
+void Camera2D::_ensure_update_interpolation_data() {
+ // The curr -> previous update can either occur
+ // on the INTERNAL_PHYSICS_PROCESS OR
+ // on NOTIFICATION_TRANSFORM_CHANGED,
+ // if NOTIFICATION_TRANSFORM_CHANGED takes place
+ // earlier than INTERNAL_PHYSICS_PROCESS on a tick.
+ // This is to ensure that the data keeps flowing, but the new data
+ // doesn't overwrite before prev has been set.
+
+ // Keep the data flowing.
+ uint64_t tick = Engine::get_singleton()->get_physics_frames();
+ if (_interpolation_data.last_update_physics_tick != tick) {
+ _interpolation_data.xform_prev = _interpolation_data.xform_curr;
+ _interpolation_data.last_update_physics_tick = tick;
+ }
+}
+
void Camera2D::_notification(int p_what) {
switch (p_what) {
- case NOTIFICATION_INTERNAL_PROCESS:
- case NOTIFICATION_INTERNAL_PHYSICS_PROCESS: {
+ case NOTIFICATION_INTERNAL_PROCESS: {
_update_scroll();
} break;
+ case NOTIFICATION_INTERNAL_PHYSICS_PROCESS: {
+ if (is_physics_interpolated_and_enabled()) {
+ _ensure_update_interpolation_data();
+ _interpolation_data.xform_curr = get_camera_transform();
+ } else {
+ _update_scroll();
+ }
+ } break;
+ case NOTIFICATION_RESET_PHYSICS_INTERPOLATION: {
+ // Force the limits etc to update.
+ _interpolation_data.xform_curr = get_camera_transform();
+ _interpolation_data.xform_prev = _interpolation_data.xform_curr;
+ } break;
case NOTIFICATION_TRANSFORM_CHANGED: {
- if (!smoothing_active) {
+ if (!smoothing_active && !is_physics_interpolated_and_enabled()) {
_update_scroll();
}
+ if (is_physics_interpolated_and_enabled()) {
+ _ensure_update_interpolation_data();
+ _interpolation_data.xform_curr = get_camera_transform();
+ }
} break;
case NOTIFICATION_ENTER_TREE: {
ERR_FAIL_COND(!is_inside_tree());
@@ -420,11 +479,13 @@ void Camera2D::_make_current(Object *p_which) {
get_viewport()->_camera_2d_set(this);
update();
_update_scroll();
+ _update_process_mode();
}
} else {
if (is_inside_tree()) {
if (get_viewport()->get_camera_2d() == this) {
get_viewport()->_camera_2d_set(nullptr);
+ _update_process_mode();
}
update();
}
@@ -435,6 +496,7 @@ void Camera2D::make_current() {
ERR_FAIL_COND(!enabled || !is_inside_tree());
get_tree()->call_group(group_name, "_make_current", this);
_update_scroll();
+ _update_process_mode();
}
void Camera2D::clear_current() {
@@ -442,6 +504,7 @@ void Camera2D::clear_current() {
if (viewport && !(custom_viewport && !ObjectDB::get_instance(custom_viewport_id))) {
viewport->assign_next_enabled_camera_2d(group_name);
}
+ _update_process_mode();
}
bool Camera2D::is_current() const {
diff --git a/scene/2d/camera_2d.h b/scene/2d/camera_2d.h
index 5c0b7569d..b8bd1dc77 100644
--- a/scene/2d/camera_2d.h
+++ b/scene/2d/camera_2d.h
@@ -84,6 +84,7 @@ protected:
void _update_process_mode();
void _update_scroll();
void _setup_viewport();
+ void _ensure_update_interpolation_data();
void _make_current(Object *p_which);
@@ -93,6 +94,12 @@ protected:
Camera2DProcessMode process_mode;
+ struct InterpolationData {
+ Transform2D xform_curr;
+ Transform2D xform_prev;
+ uint32_t last_update_physics_tick = 0;
+ } _interpolation_data;
+
protected:
virtual Transform2D get_camera_transform();
void _notification(int p_what);
diff --git a/scene/2d/canvas_item.cpp b/scene/2d/canvas_item.cpp
index 8bb19e4e2..5003d698c 100644
--- a/scene/2d/canvas_item.cpp
+++ b/scene/2d/canvas_item.cpp
@@ -570,6 +570,10 @@ void CanvasItem::_exit_canvas() {
}
}
+void CanvasItem::_physics_interpolated_changed() {
+ RenderingServer::get_singleton()->canvas_item_set_interpolated(canvas_item, is_physics_interpolated());
+}
+
void CanvasItem::_notification(int p_what) {
switch (p_what) {
case NOTIFICATION_ENTER_TREE: {
@@ -607,6 +611,11 @@ void CanvasItem::_notification(int p_what) {
get_parent()->disconnect(SceneStringNames::get_singleton()->child_order_changed, get_viewport(), SceneStringNames::get_singleton()->canvas_parent_mark_dirty);
}
} break;
+ case NOTIFICATION_RESET_PHYSICS_INTERPOLATION: {
+ if (is_visible_in_tree() && is_physics_interpolated()) {
+ RenderingServer::get_singleton()->canvas_item_reset_physics_interpolation(canvas_item);
+ }
+ } break;
case NOTIFICATION_DRAW:
case NOTIFICATION_TRANSFORM_CHANGED: {
} break;
diff --git a/scene/2d/canvas_item.h b/scene/2d/canvas_item.h
index a4f0ffa10..b6db55b6d 100644
--- a/scene/2d/canvas_item.h
+++ b/scene/2d/canvas_item.h
@@ -214,6 +214,7 @@ private:
void _exit_canvas();
void _notify_transform(CanvasItem *p_node);
+ virtual void _physics_interpolated_changed();
void _set_on_top(bool p_on_top) { set_draw_behind_parent(!p_on_top); }
bool _is_on_top() const { return !is_draw_behind_parent_enabled(); }
diff --git a/scene/2d/light_2d.cpp b/scene/2d/light_2d.cpp
index 7f23dba5c..b693886a7 100644
--- a/scene/2d/light_2d.cpp
+++ b/scene/2d/light_2d.cpp
@@ -297,22 +297,31 @@ Color Light2D::get_shadow_color() const {
return shadow_color;
}
+void Light2D::_physics_interpolated_changed() {
+ RenderingServer::get_singleton()->canvas_light_set_interpolated(canvas_light, is_physics_interpolated());
+}
+
void Light2D::_notification(int p_what) {
- if (p_what == NOTIFICATION_ENTER_TREE) {
- RS::get_singleton()->canvas_light_attach_to_canvas(canvas_light, get_canvas());
- _update_light_visibility();
- }
-
- if (p_what == NOTIFICATION_TRANSFORM_CHANGED) {
- RS::get_singleton()->canvas_light_set_transform(canvas_light, get_global_transform());
- }
- if (p_what == NOTIFICATION_VISIBILITY_CHANGED) {
- _update_light_visibility();
- }
-
- if (p_what == NOTIFICATION_EXIT_TREE) {
- RS::get_singleton()->canvas_light_attach_to_canvas(canvas_light, RID());
- _update_light_visibility();
+ switch (p_what) {
+ case NOTIFICATION_ENTER_TREE: {
+ RS::get_singleton()->canvas_light_attach_to_canvas(canvas_light, get_canvas());
+ _update_light_visibility();
+ } break;
+ case NOTIFICATION_EXIT_TREE: {
+ RS::get_singleton()->canvas_light_attach_to_canvas(canvas_light, RID());
+ _update_light_visibility();
+ } break;
+ case NOTIFICATION_TRANSFORM_CHANGED: {
+ RS::get_singleton()->canvas_light_set_transform(canvas_light, get_global_transform());
+ } break;
+ case NOTIFICATION_VISIBILITY_CHANGED: {
+ _update_light_visibility();
+ } break;
+ case NOTIFICATION_RESET_PHYSICS_INTERPOLATION: {
+ if (is_visible_in_tree() && is_physics_interpolated()) {
+ RenderingServer::get_singleton()->canvas_light_reset_physics_interpolation(canvas_light);
+ }
+ } break;
}
}
diff --git a/scene/2d/light_2d.h b/scene/2d/light_2d.h
index e26f1f008..68d9dfe96 100644
--- a/scene/2d/light_2d.h
+++ b/scene/2d/light_2d.h
@@ -79,6 +79,7 @@ private:
void _update_light_visibility();
virtual void owner_changed_notify();
+ virtual void _physics_interpolated_changed();
protected:
void _notification(int p_what);
diff --git a/scene/2d/light_occluder_2d.cpp b/scene/2d/light_occluder_2d.cpp
index ae107219d..5f4bcb51a 100644
--- a/scene/2d/light_occluder_2d.cpp
+++ b/scene/2d/light_occluder_2d.cpp
@@ -159,43 +159,52 @@ void LightOccluder2D::_poly_changed() {
#endif
}
+void LightOccluder2D::_physics_interpolated_changed() {
+ RenderingServer::get_singleton()->canvas_light_occluder_set_interpolated(occluder, is_physics_interpolated());
+}
+
void LightOccluder2D::_notification(int p_what) {
- if (p_what == NOTIFICATION_ENTER_CANVAS) {
- RS::get_singleton()->canvas_light_occluder_attach_to_canvas(occluder, get_canvas());
- RS::get_singleton()->canvas_light_occluder_set_transform(occluder, get_global_transform());
- RS::get_singleton()->canvas_light_occluder_set_enabled(occluder, is_visible_in_tree());
- }
- if (p_what == NOTIFICATION_TRANSFORM_CHANGED) {
- RS::get_singleton()->canvas_light_occluder_set_transform(occluder, get_global_transform());
- }
- if (p_what == NOTIFICATION_VISIBILITY_CHANGED) {
- RS::get_singleton()->canvas_light_occluder_set_enabled(occluder, is_visible_in_tree());
- }
+ switch (p_what) {
+ case NOTIFICATION_ENTER_CANVAS: {
+ RS::get_singleton()->canvas_light_occluder_attach_to_canvas(occluder, get_canvas());
+ RS::get_singleton()->canvas_light_occluder_set_transform(occluder, get_global_transform());
+ RS::get_singleton()->canvas_light_occluder_set_enabled(occluder, is_visible_in_tree());
+ } break;
+ case NOTIFICATION_TRANSFORM_CHANGED: {
+ RS::get_singleton()->canvas_light_occluder_set_transform(occluder, get_global_transform());
+ } break;
+ case NOTIFICATION_VISIBILITY_CHANGED: {
+ RS::get_singleton()->canvas_light_occluder_set_enabled(occluder, is_visible_in_tree());
+ } break;
+ case NOTIFICATION_DRAW: {
+ if (Engine::get_singleton()->is_editor_hint()) {
+ if (occluder_polygon.is_valid()) {
+ PoolVector poly = occluder_polygon->get_polygon();
- if (p_what == NOTIFICATION_DRAW) {
- if (Engine::get_singleton()->is_editor_hint()) {
- if (occluder_polygon.is_valid()) {
- PoolVector poly = occluder_polygon->get_polygon();
-
- if (poly.size()) {
- if (occluder_polygon->is_closed()) {
- Vector color;
- color.push_back(Color(0, 0, 0, 0.6));
- draw_polygon(Variant(poly), color);
- } else {
- int ps = poly.size();
- PoolVector::Read r = poly.read();
- for (int i = 0; i < ps - 1; i++) {
- draw_line(r[i], r[i + 1], Color(0, 0, 0, 0.6), 3);
+ if (poly.size()) {
+ if (occluder_polygon->is_closed()) {
+ Vector color;
+ color.push_back(Color(0, 0, 0, 0.6));
+ draw_polygon(Variant(poly), color);
+ } else {
+ int ps = poly.size();
+ PoolVector::Read r = poly.read();
+ for (int i = 0; i < ps - 1; i++) {
+ draw_line(r[i], r[i + 1], Color(0, 0, 0, 0.6), 3);
+ }
}
}
}
}
- }
- }
-
- if (p_what == NOTIFICATION_EXIT_CANVAS) {
- RS::get_singleton()->canvas_light_occluder_attach_to_canvas(occluder, RID());
+ } break;
+ case NOTIFICATION_EXIT_CANVAS: {
+ RS::get_singleton()->canvas_light_occluder_attach_to_canvas(occluder, RID());
+ } break;
+ case NOTIFICATION_RESET_PHYSICS_INTERPOLATION: {
+ if (is_visible_in_tree() && is_physics_interpolated()) {
+ RenderingServer::get_singleton()->canvas_light_occluder_reset_physics_interpolation(occluder);
+ }
+ } break;
}
}
diff --git a/scene/2d/light_occluder_2d.h b/scene/2d/light_occluder_2d.h
index ece837441..ee26cc863 100644
--- a/scene/2d/light_occluder_2d.h
+++ b/scene/2d/light_occluder_2d.h
@@ -85,6 +85,7 @@ class LightOccluder2D : public Node2D {
Ref occluder_polygon;
void _poly_changed();
+ virtual void _physics_interpolated_changed();
protected:
void _notification(int p_what);
diff --git a/scene/2d/parallax_layer.cpp b/scene/2d/parallax_layer.cpp
index 6a770bb5f..8a59a45df 100644
--- a/scene/2d/parallax_layer.cpp
+++ b/scene/2d/parallax_layer.cpp
@@ -163,4 +163,7 @@ void ParallaxLayer::_bind_methods() {
ParallaxLayer::ParallaxLayer() {
motion_scale = Size2(1, 1);
+
+ // ParallaxLayer is always updated every frame so there is no need to interpolate.
+ set_physics_interpolation_mode(Node::PHYSICS_INTERPOLATION_MODE_OFF);
}
diff --git a/scene/gui/control.cpp b/scene/gui/control.cpp
index 2ebe5b876..9366b3ad7 100644
--- a/scene/gui/control.cpp
+++ b/scene/gui/control.cpp
@@ -3008,6 +3008,8 @@ Control::Control() {
}
data.focus_mode = FOCUS_NONE;
data.modal_prev_focus_owner = 0;
+
+ set_physics_interpolation_mode(Node::PHYSICS_INTERPOLATION_MODE_OFF);
}
Control::~Control() {
diff --git a/scene/main/scene_tree.cpp b/scene/main/scene_tree.cpp
index a08a83416..4b6f70164 100644
--- a/scene/main/scene_tree.cpp
+++ b/scene/main/scene_tree.cpp
@@ -603,6 +603,12 @@ void SceneTree::client_physics_interpolation_remove_spatial(SelfList *p
_client_physics_interpolation._spatials_list.remove(p_elem);
}
+void SceneTree::iteration_prepare() {
+ if (_physics_interpolation_enabled) {
+ RenderingServer::get_singleton()->tick();
+ }
+}
+
void SceneTree::iteration_end() {
// When physics interpolation is active, we want all pending transforms
// to be flushed to the RenderingServer before finishing a physics tick.
@@ -616,10 +622,6 @@ bool SceneTree::iteration(float p_time) {
current_frame++;
- if (_physics_interpolation_enabled) {
- RenderingServer::get_singleton()->tick();
- }
-
// Any objects performing client physics interpolation
// should be given an opportunity to keep their previous transforms
// up to take before each new physics tick.
diff --git a/scene/main/scene_tree.h b/scene/main/scene_tree.h
index 8e04b3e22..8ccee4412 100644
--- a/scene/main/scene_tree.h
+++ b/scene/main/scene_tree.h
@@ -313,6 +313,7 @@ public:
virtual void input_event(const Ref &p_event);
virtual void init();
+ virtual void iteration_prepare();
virtual bool iteration(float p_time);
virtual void iteration_end();
virtual bool idle(float p_time);
diff --git a/servers/rendering/rasterizer.h b/servers/rendering/rasterizer.h
index 6eb2698c3..749117a3d 100644
--- a/servers/rendering/rasterizer.h
+++ b/servers/rendering/rasterizer.h
@@ -590,9 +590,12 @@ public:
};
struct Light : public RID_Data {
- bool enabled;
+ bool enabled : 1;
+ bool on_interpolate_transform_list : 1;
+ bool interpolated : 1;
Color color;
- Transform2D xform;
+ Transform2D xform_curr;
+ Transform2D xform_prev;
float height;
float energy;
float scale;
@@ -631,6 +634,8 @@ public:
Light() {
enabled = true;
+ on_interpolate_transform_list = false;
+ interpolated = true;
color = Color(1, 1, 1);
shadow_color = Color(0, 0, 0, 0);
height = 0;
@@ -837,13 +842,19 @@ public:
Rect2 rect;
};
- Transform2D xform;
+ // For interpolation we store the current local xform,
+ // and the previous xform from the previous tick.
+ Transform2D xform_curr;
+ Transform2D xform_prev;
+
bool clip : 1;
bool visible : 1;
bool behind : 1;
bool update_when_visible : 1;
bool distance_field : 1;
bool light_masked : 1;
+ bool on_interpolate_transform_list : 1;
+ bool interpolated : 1;
mutable bool custom_rect : 1;
mutable bool rect_dirty : 1;
mutable bool bound_dirty : 1;
@@ -890,6 +901,13 @@ public:
// in local space.
Rect2 local_bound;
+ // When using interpolation, the local bound for culling
+ // should be a combined bound of the previous and current.
+ // To keep this up to date, we need to keep track of the previous
+ // bound separately rather than just the combined bound.
+ Rect2 local_bound_prev;
+ uint32_t local_bound_last_update_tick;
+
const Rect2 &get_rect() const {
if (custom_rect) {
return rect;
@@ -1049,6 +1067,8 @@ public:
memdelete(skinning_data);
skinning_data = NULL;
}
+
+ on_interpolate_transform_list = false;
}
Item() {
@@ -1070,6 +1090,9 @@ public:
distance_field = false;
light_masked = false;
update_when_visible = false;
+ on_interpolate_transform_list = false;
+ interpolated = true;
+ local_bound_last_update_tick = 0;
}
virtual ~Item() {
@@ -1089,12 +1112,15 @@ public:
virtual void canvas_debug_viewport_shadows(Light *p_lights_with_shadow) = 0;
struct LightOccluderInstance : public RID_Data {
- bool enabled;
+ bool enabled : 1;
+ bool on_interpolate_transform_list : 1;
+ bool interpolated : 1;
RID canvas;
RID polygon;
RID polygon_buffer;
Rect2 aabb_cache;
- Transform2D xform;
+ Transform2D xform_curr;
+ Transform2D xform_prev;
Transform2D xform_cache;
int light_mask;
RS::CanvasOccluderPolygonCullMode cull_cache;
@@ -1106,6 +1132,8 @@ public:
next = nullptr;
light_mask = 1;
cull_cache = RS::CANVAS_OCCLUDER_POLYGON_CULL_DISABLED;
+ on_interpolate_transform_list = false;
+ interpolated = true;
}
};
diff --git a/servers/rendering/rendering_server_canvas.cpp b/servers/rendering/rendering_server_canvas.cpp
index 4495aba37..13b7ed281 100644
--- a/servers/rendering/rendering_server_canvas.cpp
+++ b/servers/rendering/rendering_server_canvas.cpp
@@ -30,6 +30,8 @@
#include "core/config/project_settings.h"
+#include "core/math/transform_interpolator.h"
+
#include "rendering_server_canvas.h"
#include "rendering_server_globals.h"
#include "rendering_server_raster.h"
@@ -67,7 +69,7 @@ void _collect_ysort_children(RenderingServerCanvas::Item *p_canvas_item, Transfo
r_items[r_index] = child_items[i];
child_items[i]->ysort_modulate = p_modulate;
child_items[i]->ysort_xform = p_transform;
- child_items[i]->ysort_pos = p_transform.xform(child_items[i]->xform.columns[2]);
+ child_items[i]->ysort_pos = p_transform.xform(child_items[i]->xform_curr.columns[2]);
child_items[i]->material_owner = child_items[i]->use_parent_material ? p_material_owner : nullptr;
child_items[i]->ysort_index = r_index;
}
@@ -76,7 +78,7 @@ void _collect_ysort_children(RenderingServerCanvas::Item *p_canvas_item, Transfo
if (child_items[i]->sort_y) {
_collect_ysort_children(child_items[i],
- p_transform * child_items[i]->xform,
+ p_transform * child_items[i]->xform_curr,
child_items[i]->use_parent_material ? p_material_owner : child_items[i],
p_modulate * child_items[i]->modulate,
r_items, r_index);
@@ -243,6 +245,37 @@ void RenderingServerCanvas::_calculate_canvas_item_bound(Item *p_canvas_item, Re
}
_finalize_and_merge_local_bound_to_branch(ci, r_branch_bound);
+
+ // If we are interpolating, we want to modify the local_bound (combined)
+ // to include both the previous AND current bounds.
+ if (local_bound && _interpolation_data.interpolation_enabled && ci->interpolated) {
+ Rect2 bound_prev = ci->local_bound_prev;
+
+ // Keep track of the previously assigned exact bound for the next tick.
+ ci->local_bound_prev = ci->local_bound;
+
+ // The combined bound is the exact current bound merged with the previous exact bound.
+ ci->local_bound = ci->local_bound.merge(bound_prev);
+
+ // This can overflow, it's no problem, it is just rough to detect when items stop
+ // having local bounds updated, so we can set prev to curr.
+ ci->local_bound_last_update_tick = Engine::get_singleton()->get_physics_frames();
+
+ // Detect special case of overflow.
+ // This is omitted but included for reference.
+ // It is such a rare possibility, and even if it did occur
+ // so it should just result in slightly larger culling bounds
+ // probably for one tick (and no visual errors).
+ // Would occur once every 828.5 days at 60 ticks per second
+ // with uint32_t counter.
+#if 0
+ if (!ci->local_bound_last_update_tick) {
+ // Prevents it being treated as non-dirty.
+ // Just has an increased delay of one tick in this very rare occurrence.
+ ci->local_bound_last_update_tick = 1;
+ }
+#endif
+ }
}
void RenderingServerCanvas::_finalize_and_merge_local_bound_to_branch(Item *p_canvas_item, Rect2 *r_branch_bound) {
@@ -277,7 +310,7 @@ void RenderingServerCanvas::_merge_local_bound_to_branch(Item *p_canvas_item, Re
return;
}
- Rect2 this_item_total_local_bound = p_canvas_item->xform.xform(p_canvas_item->local_bound);
+ Rect2 this_item_total_local_bound = p_canvas_item->xform_curr.xform(p_canvas_item->local_bound);
if (!r_branch_bound->has_no_area()) {
*r_branch_bound = r_branch_bound->merge(this_item_total_local_bound);
@@ -299,10 +332,16 @@ void RenderingServerCanvas::_render_canvas_item_cull_by_item(Item *p_canvas_item
}
Rect2 rect = ci->get_rect();
- Transform2D xform = ci->xform;
- xform = p_transform * xform;
+ Transform2D final_xform;
+ if (!_interpolation_data.interpolation_enabled || !ci->interpolated) {
+ final_xform = ci->xform_curr;
+ } else {
+ real_t f = Engine::get_singleton()->get_physics_interpolation_fraction();
+ TransformInterpolator::interpolate_transform_2d(ci->xform_prev, ci->xform_curr, final_xform, f);
+ }
+ final_xform = p_transform * final_xform;
- Rect2 global_rect = xform.xform(rect);
+ Rect2 global_rect = final_xform.xform(rect);
global_rect.position += p_clip_rect.position;
if (ci->use_parent_material && p_material_owner) {
@@ -362,14 +401,14 @@ void RenderingServerCanvas::_render_canvas_item_cull_by_item(Item *p_canvas_item
continue;
}
if (ci->sort_y) {
- _render_canvas_item_cull_by_item(child_items[i], xform * child_items[i]->ysort_xform, p_clip_rect, modulate * child_items[i]->ysort_modulate, p_z, z_list, z_last_list, (Item *)ci->final_clip_owner, (Item *)child_items[i]->material_owner);
+ _render_canvas_item_cull_by_item(child_items[i], final_xform * child_items[i]->ysort_xform, p_clip_rect, modulate * child_items[i]->ysort_modulate, p_z, z_list, z_last_list, (Item *)ci->final_clip_owner, (Item *)child_items[i]->material_owner);
} else {
- _render_canvas_item_cull_by_item(child_items[i], xform, p_clip_rect, modulate, p_z, z_list, z_last_list, (Item *)ci->final_clip_owner, p_material_owner);
+ _render_canvas_item_cull_by_item(child_items[i], final_xform, p_clip_rect, modulate, p_z, z_list, z_last_list, (Item *)ci->final_clip_owner, p_material_owner);
}
}
if (ci->copy_back_buffer) {
- ci->copy_back_buffer->screen_rect = xform.xform(ci->copy_back_buffer->rect).clip(p_clip_rect);
+ ci->copy_back_buffer->screen_rect = final_xform.xform(ci->copy_back_buffer->rect).clip(p_clip_rect);
}
if (ci->update_when_visible) {
@@ -378,7 +417,7 @@ void RenderingServerCanvas::_render_canvas_item_cull_by_item(Item *p_canvas_item
if ((!ci->commands.empty() && p_clip_rect.intersects(global_rect, true)) || ci->vp_render || ci->copy_back_buffer) {
//something to draw?
- ci->final_transform = xform;
+ ci->final_transform = final_xform;
ci->final_modulate = Color(modulate.r * ci->self_modulate.r, modulate.g * ci->self_modulate.g, modulate.b * ci->self_modulate.b, modulate.a * ci->self_modulate.a);
ci->global_rect_cache = global_rect;
ci->global_rect_cache.position -= p_clip_rect.position;
@@ -403,9 +442,9 @@ void RenderingServerCanvas::_render_canvas_item_cull_by_item(Item *p_canvas_item
continue;
}
if (ci->sort_y) {
- _render_canvas_item_cull_by_item(child_items[i], xform * child_items[i]->ysort_xform, p_clip_rect, modulate * child_items[i]->ysort_modulate, p_z, z_list, z_last_list, (Item *)ci->final_clip_owner, (Item *)child_items[i]->material_owner);
+ _render_canvas_item_cull_by_item(child_items[i], final_xform * child_items[i]->ysort_xform, p_clip_rect, modulate * child_items[i]->ysort_modulate, p_z, z_list, z_last_list, (Item *)ci->final_clip_owner, (Item *)child_items[i]->material_owner);
} else {
- _render_canvas_item_cull_by_item(child_items[i], xform, p_clip_rect, modulate, p_z, z_list, z_last_list, (Item *)ci->final_clip_owner, p_material_owner);
+ _render_canvas_item_cull_by_item(child_items[i], final_xform, p_clip_rect, modulate, p_z, z_list, z_last_list, (Item *)ci->final_clip_owner, p_material_owner);
}
}
}
@@ -420,9 +459,23 @@ void RenderingServerCanvas::_render_canvas_item_cull_by_node(Item *p_canvas_item
// This should have been calculated as a pre-process.
DEV_ASSERT(!ci->bound_dirty);
+ // If we are interpolating, and the updates have stopped, we can reduce the local bound.
+ if (ci->local_bound_last_update_tick && (ci->local_bound_last_update_tick != Engine::get_singleton()->get_physics_frames())) {
+ // The combined bound is reduced to the last calculated exact bound.
+ ci->local_bound = ci->local_bound_prev;
+ ci->local_bound_last_update_tick = 0;
+ }
+
Rect2 rect = ci->get_rect();
- Transform2D final_xform = ci->xform;
+ Transform2D final_xform;
+ if (!_interpolation_data.interpolation_enabled || !ci->interpolated) {
+ final_xform = ci->xform_curr;
+ } else {
+ real_t f = Engine::get_singleton()->get_physics_interpolation_fraction();
+ TransformInterpolator::interpolate_transform_2d(ci->xform_prev, ci->xform_curr, final_xform, f);
+ }
+
final_xform = p_transform * final_xform;
Rect2 global_rect = final_xform.xform(rect);
@@ -828,7 +881,25 @@ void RenderingServerCanvas::canvas_item_set_transform(RID p_item, const Transfor
Item *canvas_item = canvas_item_owner.getornull(p_item);
ERR_FAIL_COND(!canvas_item);
- canvas_item->xform = p_transform;
+ if (_interpolation_data.interpolation_enabled && canvas_item->interpolated) {
+ if (!canvas_item->on_interpolate_transform_list) {
+ _interpolation_data.canvas_item_transform_update_list_curr->push_back(p_item);
+ canvas_item->on_interpolate_transform_list = true;
+ } else {
+ DEV_ASSERT(_interpolation_data.canvas_item_transform_update_list_curr->size());
+ }
+ }
+
+ if (_interpolation_data.interpolation_enabled && canvas_item->interpolated) {
+ if (!canvas_item->on_interpolate_transform_list) {
+ _interpolation_data.canvas_item_transform_update_list_curr->push_back(p_item);
+ canvas_item->on_interpolate_transform_list = true;
+ } else {
+ DEV_ASSERT(_interpolation_data.canvas_item_transform_update_list_curr->size());
+ }
+ }
+
+ canvas_item->xform_curr = p_transform;
// Special case!
// Modifying the transform DOES NOT affect the local bound.
@@ -1421,6 +1492,64 @@ void RenderingServerCanvas::canvas_item_set_skeleton_relative_xform(RID p_item,
}
}
+// Useful especially for origin shifting.
+void RenderingServerCanvas::canvas_item_transform_physics_interpolation(RID p_item, Transform2D p_transform) {
+ Item *canvas_item = canvas_item_owner.getornull(p_item);
+ ERR_FAIL_COND(!canvas_item);
+ canvas_item->xform_prev = p_transform * canvas_item->xform_prev;
+ canvas_item->xform_curr = p_transform * canvas_item->xform_curr;
+}
+
+void RenderingServerCanvas::canvas_item_reset_physics_interpolation(RID p_item) {
+ Item *canvas_item = canvas_item_owner.getornull(p_item);
+ ERR_FAIL_COND(!canvas_item);
+ canvas_item->xform_prev = canvas_item->xform_curr;
+}
+
+void RenderingServerCanvas::canvas_item_set_interpolated(RID p_item, bool p_interpolated) {
+ Item *canvas_item = canvas_item_owner.getornull(p_item);
+ ERR_FAIL_COND(!canvas_item);
+ canvas_item->interpolated = p_interpolated;
+}
+
+void RenderingServerCanvas::canvas_light_set_interpolated(RID p_light, bool p_interpolated) {
+ RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
+ ERR_FAIL_COND(!clight);
+ clight->interpolated = p_interpolated;
+}
+
+void RenderingServerCanvas::canvas_light_reset_physics_interpolation(RID p_light) {
+ RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
+ ERR_FAIL_COND(!clight);
+ clight->xform_prev = clight->xform_curr;
+}
+
+void RenderingServerCanvas::canvas_light_transform_physics_interpolation(RID p_light, Transform2D p_transform) {
+ RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
+ ERR_FAIL_COND(!clight);
+ clight->xform_prev = p_transform * clight->xform_prev;
+ clight->xform_curr = p_transform * clight->xform_curr;
+}
+
+void RenderingServerCanvas::canvas_light_occluder_set_interpolated(RID p_occluder, bool p_interpolated) {
+ RasterizerCanvas::LightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
+ ERR_FAIL_COND(!occluder);
+ occluder->interpolated = p_interpolated;
+}
+
+void RenderingServerCanvas::canvas_light_occluder_reset_physics_interpolation(RID p_occluder) {
+ RasterizerCanvas::LightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
+ ERR_FAIL_COND(!occluder);
+ occluder->xform_prev = occluder->xform_curr;
+}
+
+void RenderingServerCanvas::canvas_light_occluder_transform_physics_interpolation(RID p_occluder, Transform2D p_transform) {
+ RasterizerCanvas::LightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
+ ERR_FAIL_COND(!occluder);
+ occluder->xform_prev = p_transform * occluder->xform_prev;
+ occluder->xform_curr = p_transform * occluder->xform_curr;
+}
+
void RenderingServerCanvas::canvas_item_attach_skeleton(RID p_item, RID p_skeleton) {
Item *canvas_item = canvas_item_owner.getornull(p_item);
ERR_FAIL_COND(!canvas_item);
@@ -1560,7 +1689,16 @@ void RenderingServerCanvas::canvas_light_set_transform(RID p_light, const Transf
RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
ERR_FAIL_COND(!clight);
- clight->xform = p_transform;
+ if (_interpolation_data.interpolation_enabled && clight->interpolated) {
+ if (!clight->on_interpolate_transform_list) {
+ _interpolation_data.canvas_light_transform_update_list_curr->push_back(p_light);
+ clight->on_interpolate_transform_list = true;
+ } else {
+ DEV_ASSERT(_interpolation_data.canvas_light_transform_update_list_curr->size());
+ }
+ }
+
+ clight->xform_curr = p_transform;
}
void RenderingServerCanvas::canvas_light_set_texture(RID p_light, RID p_texture) {
RasterizerCanvas::Light *clight = canvas_light_owner.get(p_light);
@@ -1747,7 +1885,16 @@ void RenderingServerCanvas::canvas_light_occluder_set_transform(RID p_occluder,
RasterizerCanvas::LightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
ERR_FAIL_COND(!occluder);
- occluder->xform = p_xform;
+ if (_interpolation_data.interpolation_enabled && occluder->interpolated) {
+ if (!occluder->on_interpolate_transform_list) {
+ _interpolation_data.canvas_light_occluder_transform_update_list_curr->push_back(p_occluder);
+ occluder->on_interpolate_transform_list = true;
+ } else {
+ DEV_ASSERT(_interpolation_data.canvas_light_occluder_transform_update_list_curr->size());
+ }
+ }
+
+ occluder->xform_curr = p_xform;
}
void RenderingServerCanvas::canvas_light_occluder_set_light_mask(RID p_occluder, int p_mask) {
RasterizerCanvas::LightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
@@ -1857,7 +2004,8 @@ bool RenderingServerCanvas::free(RID p_rid) {
} else if (canvas_item_owner.owns(p_rid)) {
Item *canvas_item = canvas_item_owner.get(p_rid);
ERR_FAIL_COND_V(!canvas_item, true);
- _make_bound_dirty(canvas_item);
+ _make_bound_dirty(canvas_item);
+ _interpolation_data.notify_free_canvas_item(p_rid, *canvas_item);
if (canvas_item->parent.is_valid()) {
if (canvas_owner.owns(canvas_item->parent)) {
@@ -1891,6 +2039,7 @@ bool RenderingServerCanvas::free(RID p_rid) {
} else if (canvas_light_owner.owns(p_rid)) {
RasterizerCanvas::Light *canvas_light = canvas_light_owner.get(p_rid);
ERR_FAIL_COND_V(!canvas_light, true);
+ _interpolation_data.notify_free_canvas_light(p_rid, *canvas_light);
if (canvas_light->canvas.is_valid()) {
Canvas *canvas = canvas_owner.get(canvas_light->canvas);
@@ -1911,6 +2060,7 @@ bool RenderingServerCanvas::free(RID p_rid) {
} else if (canvas_light_occluder_owner.owns(p_rid)) {
RasterizerCanvas::LightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_rid);
ERR_FAIL_COND_V(!occluder, true);
+ _interpolation_data.notify_free_canvas_light_occluder(p_rid, *occluder);
if (occluder->polygon.is_valid()) {
LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(occluder->polygon);
@@ -2043,6 +2193,83 @@ void RenderingServerCanvas::_print_tree_down(int p_child_id, int p_depth, const
#endif
+void RenderingServerCanvas::tick() {
+ if (_interpolation_data.interpolation_enabled) {
+ update_interpolation_tick(true);
+ }
+}
+
+void RenderingServerCanvas::update_interpolation_tick(bool p_process) {
+#define PANDEMONIUM_UPDATE_INTERPOLATION_TICK(LIST_PREV, LIST_CURR, TYPE, OWNER_LIST) \
+ /* Detect any that were on the previous transform list that are no longer active. */ \
+ for (unsigned int n = 0; n < _interpolation_data.LIST_PREV->size(); n++) { \
+ const RID &rid = (*_interpolation_data.LIST_PREV)[n]; \
+ TYPE *item = OWNER_LIST.getornull(rid); \
+ /* no longer active? (either the instance deleted or no longer being transformed) */ \
+ if (item && !item->on_interpolate_transform_list) { \
+ item->xform_prev = item->xform_curr; \
+ } \
+ } \
+ /* and now for any in the transform list (being actively interpolated), */ \
+ /* keep the previous transform value up to date and ready for next tick */ \
+ if (p_process) { \
+ for (unsigned int n = 0; n < _interpolation_data.LIST_CURR->size(); n++) { \
+ const RID &rid = (*_interpolation_data.LIST_CURR)[n]; \
+ TYPE *item = OWNER_LIST.getornull(rid); \
+ if (item) { \
+ item->xform_prev = item->xform_curr; \
+ item->on_interpolate_transform_list = false; \
+ } \
+ } \
+ } \
+ SWAP(_interpolation_data.LIST_CURR, _interpolation_data.LIST_PREV); \
+ _interpolation_data.LIST_CURR->clear();
+
+ PANDEMONIUM_UPDATE_INTERPOLATION_TICK(canvas_item_transform_update_list_prev, canvas_item_transform_update_list_curr, Item, canvas_item_owner);
+ PANDEMONIUM_UPDATE_INTERPOLATION_TICK(canvas_light_transform_update_list_prev, canvas_light_transform_update_list_curr, RasterizerCanvas::Light, canvas_light_owner);
+ PANDEMONIUM_UPDATE_INTERPOLATION_TICK(canvas_light_occluder_transform_update_list_prev, canvas_light_occluder_transform_update_list_curr, RasterizerCanvas::LightOccluderInstance, canvas_light_occluder_owner);
+
+#undef PANDEMONIUM_UPDATE_INTERPOLATION_TICK
+}
+
+void RenderingServerCanvas::InterpolationData::notify_free_canvas_item(RID p_rid, RenderingServerCanvas::Item &r_canvas_item) {
+ r_canvas_item.on_interpolate_transform_list = false;
+
+ if (!interpolation_enabled) {
+ return;
+ }
+
+ // If the instance was on any of the lists, remove.
+ canvas_item_transform_update_list_curr->erase_multiple_unordered(p_rid);
+ canvas_item_transform_update_list_prev->erase_multiple_unordered(p_rid);
+}
+
+void RenderingServerCanvas::InterpolationData::notify_free_canvas_light(RID p_rid, RasterizerCanvas::Light &r_canvas_light) {
+ r_canvas_light.on_interpolate_transform_list = false;
+
+ if (!interpolation_enabled) {
+ return;
+ }
+
+ // If the instance was on any of the lists, remove.
+ canvas_light_transform_update_list_curr->erase_multiple_unordered(p_rid);
+ canvas_light_transform_update_list_prev->erase_multiple_unordered(p_rid);
+}
+
+void RenderingServerCanvas::InterpolationData::notify_free_canvas_light_occluder(RID p_rid, RasterizerCanvas::LightOccluderInstance &r_canvas_light_occluder) {
+ r_canvas_light_occluder.on_interpolate_transform_list = false;
+
+ if (!interpolation_enabled) {
+ return;
+ }
+
+ // If the instance was on any of the lists, remove.
+ canvas_light_occluder_transform_update_list_curr->erase_multiple_unordered(p_rid);
+ canvas_light_occluder_transform_update_list_prev->erase_multiple_unordered(p_rid);
+}
+
+
+
RenderingServerCanvas::RenderingServerCanvas() {
_canvas_cull_mode = CANVAS_CULL_MODE_NODE;
diff --git a/servers/rendering/rendering_server_canvas.h b/servers/rendering/rendering_server_canvas.h
index 29fa414ba..6424508ac 100644
--- a/servers/rendering/rendering_server_canvas.h
+++ b/servers/rendering/rendering_server_canvas.h
@@ -256,9 +256,13 @@ public:
void canvas_item_set_use_parent_material(RID p_item, bool p_enable);
void canvas_item_attach_skeleton(RID p_item, RID p_skeleton);
+ void _canvas_item_skeleton_moved(RID p_item);
void canvas_item_set_skeleton_relative_xform(RID p_item, Transform2D p_relative_xform);
Rect2 _debug_canvas_item_get_rect(RID p_item);
- void _canvas_item_skeleton_moved(RID p_item);
+
+ void canvas_item_set_interpolated(RID p_item, bool p_interpolated);
+ void canvas_item_reset_physics_interpolation(RID p_item);
+ void canvas_item_transform_physics_interpolation(RID p_item, Transform2D p_transform);
RID canvas_light_create();
void canvas_light_attach_to_canvas(RID p_light, RID p_canvas);
@@ -274,9 +278,7 @@ public:
void canvas_light_set_layer_range(RID p_light, int p_min_layer, int p_max_layer);
void canvas_light_set_item_cull_mask(RID p_light, int p_mask);
void canvas_light_set_item_shadow_cull_mask(RID p_light, int p_mask);
-
void canvas_light_set_mode(RID p_light, RS::CanvasLightMode p_mode);
-
void canvas_light_set_shadow_enabled(RID p_light, bool p_enabled);
void canvas_light_set_shadow_buffer_size(RID p_light, int p_size);
void canvas_light_set_shadow_gradient_length(RID p_light, float p_length);
@@ -284,6 +286,10 @@ public:
void canvas_light_set_shadow_color(RID p_light, const Color &p_color);
void canvas_light_set_shadow_smooth(RID p_light, float p_smooth);
+ void canvas_light_set_interpolated(RID p_light, bool p_interpolated);
+ void canvas_light_reset_physics_interpolation(RID p_light);
+ void canvas_light_transform_physics_interpolation(RID p_light, Transform2D p_transform);
+
RID canvas_light_occluder_create();
void canvas_light_occluder_attach_to_canvas(RID p_occluder, RID p_canvas);
void canvas_light_occluder_set_enabled(RID p_occluder, bool p_enabled);
@@ -291,6 +297,10 @@ public:
void canvas_light_occluder_set_transform(RID p_occluder, const Transform2D &p_xform);
void canvas_light_occluder_set_light_mask(RID p_occluder, int p_mask);
+ void canvas_light_occluder_set_interpolated(RID p_occluder, bool p_interpolated);
+ void canvas_light_occluder_reset_physics_interpolation(RID p_occluder);
+ void canvas_light_occluder_transform_physics_interpolation(RID p_occluder, Transform2D p_transform);
+
RID canvas_occluder_polygon_create();
void canvas_occluder_polygon_set_shape(RID p_occluder_polygon, const PoolVector &p_shape, bool p_closed);
void canvas_occluder_polygon_set_shape_as_lines(RID p_occluder_polygon, const PoolVector &p_shape);
@@ -298,6 +308,32 @@ public:
void canvas_occluder_polygon_set_cull_mode(RID p_occluder_polygon, RS::CanvasOccluderPolygonCullMode p_mode);
bool free(RID p_rid);
+
+ // Interpolation
+ void tick();
+ void update_interpolation_tick(bool p_process = true);
+ void set_physics_interpolation_enabled(bool p_enabled) { _interpolation_data.interpolation_enabled = p_enabled; }
+
+ struct InterpolationData {
+ void notify_free_canvas_item(RID p_rid, RenderingServerCanvas::Item &r_canvas_item);
+ void notify_free_canvas_light(RID p_rid, RasterizerCanvas::Light &r_canvas_light);
+ void notify_free_canvas_light_occluder(RID p_rid, RasterizerCanvas::LightOccluderInstance &r_canvas_light_occluder);
+
+ LocalVector canvas_item_transform_update_lists[2];
+ LocalVector *canvas_item_transform_update_list_curr = &canvas_item_transform_update_lists[0];
+ LocalVector *canvas_item_transform_update_list_prev = &canvas_item_transform_update_lists[1];
+
+ LocalVector canvas_light_transform_update_lists[2];
+ LocalVector *canvas_light_transform_update_list_curr = &canvas_light_transform_update_lists[0];
+ LocalVector *canvas_light_transform_update_list_prev = &canvas_light_transform_update_lists[1];
+
+ LocalVector canvas_light_occluder_transform_update_lists[2];
+ LocalVector *canvas_light_occluder_transform_update_list_curr = &canvas_light_occluder_transform_update_lists[0];
+ LocalVector *canvas_light_occluder_transform_update_list_prev = &canvas_light_occluder_transform_update_lists[1];
+
+ bool interpolation_enabled = false;
+ } _interpolation_data;
+
RenderingServerCanvas();
~RenderingServerCanvas();
};
diff --git a/servers/rendering/rendering_server_raster.cpp b/servers/rendering/rendering_server_raster.cpp
index 9d16d0c46..868471f3b 100644
--- a/servers/rendering/rendering_server_raster.cpp
+++ b/servers/rendering/rendering_server_raster.cpp
@@ -135,6 +135,20 @@ void RenderingServerRaster::draw(bool p_swap_buffers, double frame_step) {
void RenderingServerRaster::sync() {
}
+void RenderingServerRaster::set_physics_interpolation_enabled(bool p_enabled) {
+ RSG::scene->set_physics_interpolation_enabled(p_enabled);
+ RSG::canvas->set_physics_interpolation_enabled(p_enabled);
+}
+
+void RenderingServerRaster::tick() {
+ RSG::scene->tick();
+ RSG::canvas->tick();
+}
+
+void RenderingServerRaster::pre_draw(bool p_will_draw) {
+ RSG::scene->pre_draw(p_will_draw);
+}
+
bool RenderingServerRaster::has_changed(ChangedPriority p_priority) const {
switch (p_priority) {
default: {
diff --git a/servers/rendering/rendering_server_raster.h b/servers/rendering/rendering_server_raster.h
index 9675e5223..e95a2bd10 100644
--- a/servers/rendering/rendering_server_raster.h
+++ b/servers/rendering/rendering_server_raster.h
@@ -361,11 +361,6 @@ public:
//from now on, calls forwarded to this singleton
#define BINDBASE RSG::scene
- /* EVENT QUEUING */
-
- BIND0N(tick)
- BIND1N(pre_draw, bool)
-
/* CAMERA API */
BIND0R(RID, camera_create)
@@ -466,10 +461,6 @@ public:
#undef BINDBASE
#define BINDBASE RSG::scene
- /* INTERPOLATION */
-
- BIND1(set_physics_interpolation_enabled, bool)
-
/* SCENARIO API */
BIND0R(RID, scenario_create)
@@ -503,7 +494,7 @@ public:
BIND2(instance_set_extra_visibility_margin, RID, real_t)
/* PORTALS */
-
+
BIND2(instance_set_portal_mode, RID, InstancePortalMode)
BIND0R(RID, ghost_create)
@@ -524,7 +515,7 @@ public:
BIND2(roomgroup_add_room, RID, RID)
/* OCCLUDERS */
-
+
BIND0R(RID, occluder_instance_create)
BIND2(occluder_instance_set_scenario, RID, RID)
BIND2(occluder_instance_link_resource, RID, RID)
@@ -624,16 +615,18 @@ public:
BIND2(canvas_item_set_z_index, RID, int)
BIND2(canvas_item_set_z_as_relative_to_parent, RID, bool)
BIND3(canvas_item_set_copy_to_backbuffer, RID, bool, const Rect2 &)
+ BIND1(canvas_item_clear, RID)
+ BIND2(canvas_item_set_draw_index, RID, int)
+ BIND2(canvas_item_set_material, RID, RID)
+ BIND2(canvas_item_set_use_parent_material, RID, bool)
+
BIND2(canvas_item_attach_skeleton, RID, RID)
BIND2(canvas_item_set_skeleton_relative_xform, RID, Transform2D)
BIND1R(Rect2, _debug_canvas_item_get_rect, RID)
- BIND1(canvas_item_clear, RID)
- BIND2(canvas_item_set_draw_index, RID, int)
-
- BIND2(canvas_item_set_material, RID, RID)
-
- BIND2(canvas_item_set_use_parent_material, RID, bool)
+ BIND2(canvas_item_set_interpolated, RID, bool)
+ BIND1(canvas_item_reset_physics_interpolation, RID)
+ BIND2(canvas_item_transform_physics_interpolation, RID, Transform2D)
BIND0R(RID, canvas_light_create)
BIND2(canvas_light_attach_to_canvas, RID, RID)
@@ -659,6 +652,10 @@ public:
BIND2(canvas_light_set_shadow_color, RID, const Color &)
BIND2(canvas_light_set_shadow_smooth, RID, float)
+ BIND2(canvas_light_set_interpolated, RID, bool)
+ BIND1(canvas_light_reset_physics_interpolation, RID)
+ BIND2(canvas_light_transform_physics_interpolation, RID, Transform2D)
+
BIND0R(RID, canvas_light_occluder_create)
BIND2(canvas_light_occluder_attach_to_canvas, RID, RID)
BIND2(canvas_light_occluder_set_enabled, RID, bool)
@@ -666,6 +663,10 @@ public:
BIND2(canvas_light_occluder_set_transform, RID, const Transform2D &)
BIND2(canvas_light_occluder_set_light_mask, RID, int)
+ BIND2(canvas_light_occluder_set_interpolated, RID, bool)
+ BIND1(canvas_light_occluder_reset_physics_interpolation, RID)
+ BIND2(canvas_light_occluder_transform_physics_interpolation, RID, Transform2D)
+
BIND0R(RID, canvas_occluder_polygon_create)
BIND3(canvas_occluder_polygon_set_shape, RID, const PoolVector &, bool)
BIND2(canvas_occluder_polygon_set_shape_as_lines, RID, const PoolVector &)
@@ -685,12 +686,16 @@ public:
virtual void request_frame_drawn_callback(Object *p_where, const StringName &p_method, const Variant &p_userdata);
+ virtual void tick();
+ virtual void pre_draw(bool p_will_draw);
virtual void draw(bool p_swap_buffers, double frame_step);
virtual void sync();
virtual bool has_changed(ChangedPriority p_priority = CHANGED_PRIORITY_ANY) const;
virtual void init();
virtual void finish();
+ virtual void set_physics_interpolation_enabled(bool p_enabled);
+
/* STATUS INFORMATION */
virtual uint64_t get_render_info(RenderInfo p_info);
diff --git a/servers/rendering/rendering_server_viewport.cpp b/servers/rendering/rendering_server_viewport.cpp
index d853627e4..d71c821f0 100644
--- a/servers/rendering/rendering_server_viewport.cpp
+++ b/servers/rendering/rendering_server_viewport.cpp
@@ -126,7 +126,14 @@ void RenderingServerViewport::_draw_viewport(Viewport *p_viewport) {
Vector2 offset = tsize / 2.0;
cl->rect_cache = Rect2(-offset + cl->texture_offset, tsize);
- cl->xform_cache = xf * cl->xform;
+
+ if (!RSG::canvas->_interpolation_data.interpolation_enabled || !cl->interpolated) {
+ cl->xform_cache = xf * cl->xform_curr;
+ } else {
+ real_t f = Engine::get_singleton()->get_physics_interpolation_fraction();
+ TransformInterpolator::interpolate_transform_2d(cl->xform_prev, cl->xform_curr, cl->xform_cache, f);
+ cl->xform_cache = xf * cl->xform_cache;
+ }
if (clip_rect.intersects_transformed(cl->xform_cache, cl->rect_cache)) {
cl->filter_next_ptr = lights;
@@ -171,13 +178,22 @@ void RenderingServerViewport::_draw_viewport(Viewport *p_viewport) {
Transform2D xf = _canvas_get_transform(p_viewport, canvas, &E->get(), clip_rect.size);
for (RBSet::Element *F = canvas->occluders.front(); F; F = F->next()) {
- if (!F->get()->enabled) {
+ RasterizerCanvas::LightOccluderInstance *occluder = F->get();
+ if (!occluder->enabled) {
continue;
}
- F->get()->xform_cache = xf * F->get()->xform;
- if (shadow_rect.intersects_transformed(F->get()->xform_cache, F->get()->aabb_cache)) {
- F->get()->next = occluders;
- occluders = F->get();
+
+ if (!RSG::canvas->_interpolation_data.interpolation_enabled || !occluder->interpolated) {
+ occluder->xform_cache = xf * occluder->xform_curr;
+ } else {
+ real_t f = Engine::get_singleton()->get_physics_interpolation_fraction();
+ TransformInterpolator::interpolate_transform_2d(occluder->xform_prev, occluder->xform_curr, occluder->xform_cache, f);
+ occluder->xform_cache = xf * occluder->xform_cache;
+ }
+
+ if (shadow_rect.intersects_transformed(occluder->xform_cache, occluder->aabb_cache)) {
+ occluder->next = occluders;
+ occluders = occluder;
}
}
}
diff --git a/servers/rendering/rendering_server_wrap_mt.cpp b/servers/rendering/rendering_server_wrap_mt.cpp
index c34cdfde5..ef342a67b 100644
--- a/servers/rendering/rendering_server_wrap_mt.cpp
+++ b/servers/rendering/rendering_server_wrap_mt.cpp
@@ -73,6 +73,30 @@ void RenderingServerWrapMT::thread_loop() {
/* EVENT QUEUING */
+void RenderingServerWrapMT::set_physics_interpolation_enabled(bool p_enabled) {
+ if (Thread::get_caller_id() != server_thread) {
+ command_queue.push(rendering_server, &RenderingServer::set_physics_interpolation_enabled, p_enabled);
+ } else {
+ rendering_server->set_physics_interpolation_enabled(p_enabled);
+ }
+}
+
+void RenderingServerWrapMT::tick() {
+ if (Thread::get_caller_id() != server_thread) {
+ command_queue.push(rendering_server, &RenderingServer::tick);
+ } else {
+ rendering_server->tick();
+ }
+}
+
+void RenderingServerWrapMT::pre_draw(bool p_will_draw) {
+ if (Thread::get_caller_id() != server_thread) {
+ command_queue.push(rendering_server, &RenderingServer::pre_draw, p_will_draw);
+ } else {
+ rendering_server->pre_draw(p_will_draw);
+ }
+}
+
void RenderingServerWrapMT::sync() {
if (create_thread) {
draw_pending.increment();
diff --git a/servers/rendering/rendering_server_wrap_mt.h b/servers/rendering/rendering_server_wrap_mt.h
index 7cfd2f964..33ac85957 100644
--- a/servers/rendering/rendering_server_wrap_mt.h
+++ b/servers/rendering/rendering_server_wrap_mt.h
@@ -374,10 +374,6 @@ public:
FUNC7(environment_set_fog_depth, RID, bool, float, float, float, bool, float)
FUNC5(environment_set_fog_height, RID, bool, float, float, float)
- /* INTERPOLATION API */
-
- FUNC1(set_physics_interpolation_enabled, bool)
-
/* SCENARIO API */
FUNCRID(scenario)
@@ -527,16 +523,18 @@ public:
FUNC2(canvas_item_set_z_index, RID, int)
FUNC2(canvas_item_set_z_as_relative_to_parent, RID, bool)
FUNC3(canvas_item_set_copy_to_backbuffer, RID, bool, const Rect2 &)
+ FUNC1(canvas_item_clear, RID)
+ FUNC2(canvas_item_set_draw_index, RID, int)
+ FUNC2(canvas_item_set_material, RID, RID)
+ FUNC2(canvas_item_set_use_parent_material, RID, bool)
+
FUNC2(canvas_item_attach_skeleton, RID, RID)
FUNC2(canvas_item_set_skeleton_relative_xform, RID, Transform2D)
FUNC1R(Rect2, _debug_canvas_item_get_rect, RID)
- FUNC1(canvas_item_clear, RID)
- FUNC2(canvas_item_set_draw_index, RID, int)
-
- FUNC2(canvas_item_set_material, RID, RID)
-
- FUNC2(canvas_item_set_use_parent_material, RID, bool)
+ FUNC2(canvas_item_set_interpolated, RID, bool)
+ FUNC1(canvas_item_reset_physics_interpolation, RID)
+ FUNC2(canvas_item_transform_physics_interpolation, RID, Transform2D)
FUNC0R(RID, canvas_light_create)
FUNC2(canvas_light_attach_to_canvas, RID, RID)
@@ -562,6 +560,10 @@ public:
FUNC2(canvas_light_set_shadow_color, RID, const Color &)
FUNC2(canvas_light_set_shadow_smooth, RID, float)
+ FUNC2(canvas_light_set_interpolated, RID, bool)
+ FUNC1(canvas_light_reset_physics_interpolation, RID)
+ FUNC2(canvas_light_transform_physics_interpolation, RID, Transform2D)
+
FUNCRID(canvas_light_occluder)
FUNC2(canvas_light_occluder_attach_to_canvas, RID, RID)
FUNC2(canvas_light_occluder_set_enabled, RID, bool)
@@ -569,6 +571,10 @@ public:
FUNC2(canvas_light_occluder_set_transform, RID, const Transform2D &)
FUNC2(canvas_light_occluder_set_light_mask, RID, int)
+ FUNC2(canvas_light_occluder_set_interpolated, RID, bool)
+ FUNC1(canvas_light_occluder_reset_physics_interpolation, RID)
+ FUNC2(canvas_light_occluder_transform_physics_interpolation, RID, Transform2D)
+
FUNCRID(canvas_occluder_polygon)
FUNC3(canvas_occluder_polygon_set_shape, RID, const PoolVector &, bool)
FUNC2(canvas_occluder_polygon_set_shape_as_lines, RID, const PoolVector &)
@@ -590,11 +596,12 @@ public:
virtual void init();
virtual void finish();
+ virtual void tick();
+ virtual void pre_draw(bool p_will_draw);
virtual void draw(bool p_swap_buffers, double frame_step);
virtual void sync();
- FUNC0(tick)
- FUNC1(pre_draw, bool)
FUNC1RC(bool, has_changed, ChangedPriority)
+ virtual void set_physics_interpolation_enabled(bool p_enabled);
/* RENDER INFO */
diff --git a/servers/rendering_server.cpp b/servers/rendering_server.cpp
index 5e6e5d6ee..203c3c083 100644
--- a/servers/rendering_server.cpp
+++ b/servers/rendering_server.cpp
@@ -2133,6 +2133,9 @@ void RenderingServer::_bind_methods() {
ClassDB::bind_method(D_METHOD("canvas_item_set_z_index", "item", "z_index"), &RenderingServer::canvas_item_set_z_index);
ClassDB::bind_method(D_METHOD("canvas_item_set_z_as_relative_to_parent", "item", "enabled"), &RenderingServer::canvas_item_set_z_as_relative_to_parent);
ClassDB::bind_method(D_METHOD("canvas_item_set_copy_to_backbuffer", "item", "enabled", "rect"), &RenderingServer::canvas_item_set_copy_to_backbuffer);
+ ClassDB::bind_method(D_METHOD("canvas_item_set_interpolated", "item", "interpolated"), &RenderingServer::canvas_item_set_interpolated);
+ ClassDB::bind_method(D_METHOD("canvas_item_reset_physics_interpolation", "item"), &RenderingServer::canvas_item_reset_physics_interpolation);
+ ClassDB::bind_method(D_METHOD("canvas_item_transform_physics_interpolation", "item", "xform"), &RenderingServer::canvas_item_transform_physics_interpolation);
ClassDB::bind_method(D_METHOD("canvas_item_clear", "item"), &RenderingServer::canvas_item_clear);
ClassDB::bind_method(D_METHOD("canvas_item_set_draw_index", "item", "index"), &RenderingServer::canvas_item_set_draw_index);
ClassDB::bind_method(D_METHOD("canvas_item_set_material", "item", "material"), &RenderingServer::canvas_item_set_material);
@@ -2159,6 +2162,9 @@ void RenderingServer::_bind_methods() {
ClassDB::bind_method(D_METHOD("canvas_light_set_shadow_filter", "light", "filter"), &RenderingServer::canvas_light_set_shadow_filter);
ClassDB::bind_method(D_METHOD("canvas_light_set_shadow_color", "light", "color"), &RenderingServer::canvas_light_set_shadow_color);
ClassDB::bind_method(D_METHOD("canvas_light_set_shadow_smooth", "light", "smooth"), &RenderingServer::canvas_light_set_shadow_smooth);
+ ClassDB::bind_method(D_METHOD("canvas_light_set_interpolated", "light", "interpolated"), &RenderingServer::canvas_light_set_interpolated);
+ ClassDB::bind_method(D_METHOD("canvas_light_reset_physics_interpolation", "light"), &RenderingServer::canvas_light_reset_physics_interpolation);
+ ClassDB::bind_method(D_METHOD("canvas_light_transform_physics_interpolation", "light", "xform"), &RenderingServer::canvas_light_transform_physics_interpolation);
ClassDB::bind_method(D_METHOD("canvas_light_occluder_create"), &RenderingServer::canvas_light_occluder_create);
ClassDB::bind_method(D_METHOD("canvas_light_occluder_attach_to_canvas", "occluder", "canvas"), &RenderingServer::canvas_light_occluder_attach_to_canvas);
@@ -2166,6 +2172,9 @@ void RenderingServer::_bind_methods() {
ClassDB::bind_method(D_METHOD("canvas_light_occluder_set_polygon", "occluder", "polygon"), &RenderingServer::canvas_light_occluder_set_polygon);
ClassDB::bind_method(D_METHOD("canvas_light_occluder_set_transform", "occluder", "transform"), &RenderingServer::canvas_light_occluder_set_transform);
ClassDB::bind_method(D_METHOD("canvas_light_occluder_set_light_mask", "occluder", "mask"), &RenderingServer::canvas_light_occluder_set_light_mask);
+ ClassDB::bind_method(D_METHOD("canvas_light_occluder_set_interpolated", "occluder", "interpolated"), &RenderingServer::canvas_light_occluder_set_interpolated);
+ ClassDB::bind_method(D_METHOD("canvas_light_occluder_reset_physics_interpolation", "occluder"), &RenderingServer::canvas_light_occluder_reset_physics_interpolation);
+ ClassDB::bind_method(D_METHOD("canvas_light_occluder_transform_physics_interpolation", "occluder", "xform"), &RenderingServer::canvas_light_occluder_transform_physics_interpolation);
ClassDB::bind_method(D_METHOD("canvas_occluder_polygon_create"), &RenderingServer::canvas_occluder_polygon_create);
ClassDB::bind_method(D_METHOD("canvas_occluder_polygon_set_shape", "occluder_polygon", "shape", "closed"), &RenderingServer::canvas_occluder_polygon_set_shape);
diff --git a/servers/rendering_server.h b/servers/rendering_server.h
index 6fd666c03..7c407ebeb 100644
--- a/servers/rendering_server.h
+++ b/servers/rendering_server.h
@@ -942,6 +942,10 @@ public:
virtual void canvas_item_set_z_index(RID p_item, int p_z) = 0;
virtual void canvas_item_set_z_as_relative_to_parent(RID p_item, bool p_enable) = 0;
virtual void canvas_item_set_copy_to_backbuffer(RID p_item, bool p_enable, const Rect2 &p_rect) = 0;
+ virtual void canvas_item_clear(RID p_item) = 0;
+ virtual void canvas_item_set_draw_index(RID p_item, int p_index) = 0;
+ virtual void canvas_item_set_material(RID p_item, RID p_material) = 0;
+ virtual void canvas_item_set_use_parent_material(RID p_item, bool p_enable) = 0;
virtual void canvas_item_attach_skeleton(RID p_item, RID p_skeleton) = 0;
virtual void canvas_item_set_skeleton_relative_xform(RID p_item, Transform2D p_relative_xform) = 0;
@@ -955,12 +959,9 @@ public:
}
virtual Rect2 _debug_canvas_item_get_rect(RID p_item) = 0;
- virtual void canvas_item_clear(RID p_item) = 0;
- virtual void canvas_item_set_draw_index(RID p_item, int p_index) = 0;
-
- virtual void canvas_item_set_material(RID p_item, RID p_material) = 0;
-
- virtual void canvas_item_set_use_parent_material(RID p_item, bool p_enable) = 0;
+ virtual void canvas_item_set_interpolated(RID p_item, bool p_interpolated) = 0;
+ virtual void canvas_item_reset_physics_interpolation(RID p_item) = 0;
+ virtual void canvas_item_transform_physics_interpolation(RID p_item, Transform2D p_transform) = 0;
virtual RID canvas_light_create() = 0;
virtual void canvas_light_attach_to_canvas(RID p_light, RID p_canvas) = 0;
@@ -977,6 +978,10 @@ public:
virtual void canvas_light_set_item_cull_mask(RID p_light, int p_mask) = 0;
virtual void canvas_light_set_item_shadow_cull_mask(RID p_light, int p_mask) = 0;
+ virtual void canvas_light_set_interpolated(RID p_light, bool p_interpolated) = 0;
+ virtual void canvas_light_reset_physics_interpolation(RID p_light) = 0;
+ virtual void canvas_light_transform_physics_interpolation(RID p_light, Transform2D p_transform) = 0;
+
enum CanvasLightMode {
CANVAS_LIGHT_MODE_ADD,
CANVAS_LIGHT_MODE_SUB,
@@ -1009,6 +1014,10 @@ public:
virtual void canvas_light_occluder_set_transform(RID p_occluder, const Transform2D &p_xform) = 0;
virtual void canvas_light_occluder_set_light_mask(RID p_occluder, int p_mask) = 0;
+ virtual void canvas_light_occluder_set_interpolated(RID p_occluder, bool p_interpolated) = 0;
+ virtual void canvas_light_occluder_reset_physics_interpolation(RID p_occluder) = 0;
+ virtual void canvas_light_occluder_transform_physics_interpolation(RID p_occluder, Transform2D p_transform) = 0;
+
virtual RID canvas_occluder_polygon_create() = 0;
virtual void canvas_occluder_polygon_set_shape(RID p_occluder_polygon, const PoolVector &p_shape, bool p_closed) = 0;
virtual void canvas_occluder_polygon_set_shape_as_lines(RID p_occluder_polygon, const PoolVector &p_shape) = 0;