Jolt RigidBody can ignore transform updates in _input method when VehicleBody and Wheel present

[Haydoggo]

Tested versions

• Reproducible in 4.5 beta 4
• Not reproducible in 4.5 beta 3

Bisected to #108544

System information

Godot v4.5.beta (5a16e2f) - Windows 10 (build 19045) - Multi-window, 2 monitors @ 180Hz - Vulkan (Forward+) - dedicated NVIDIA GeForce GTX 1080 (NVIDIA; 32.0.15.6614) - Intel(R) Core(TM) i5-10600KF CPU @ 4.10GHz (12 threads) - 15.92 GiB memory

Issue description

RigidBody3Ds sometimes ignore updates to their transform made immediately after being instantiated.
Only seems to happen if spawned from _input event e.g.

func _input(event: InputEvent) -> void:
	if event.is_action_pressed("ui_accept"):
		var ball = TEMPLATE.instantiate()
		add_child(ball)
		ball.position = Vector3(2,0,0)

OriginError.DEBUG.2026-01-24.15-49-10.-.Trim.mp4

Workaround: defer the positioning of the body with set/call_deferred

Steps to reproduce

A rigidbody can ignore initial updates to transform if all of the following criteria are met:

• Instantiation/positioning happens in the _input event
• A VehicleBody3D with a VehicleWheel3D child is present in the scene
• Jolt is being used for physics

Lower framerates make the positioning fail more often

Minimal reproduction project (MRP)

origin-error-mrp.zip
Press space to spawn a rigid body, or tick Auto spawn to continually spawn rigid bodies.
Tick VehicleBodyFrozen to freeze the invisible vehicle body in scene to see the issue disappear

[jrouwe]

First the object is created at (-1 0 0). Then the gd script sets the position to (2 0 0). This sets the local transform, marks the global transform as dirty but does not send the transform to the physics server (data.notify_local_transform = false and data.enabled = false):

Node3D::set_position(const Vector3 & p_position) Line 708
call_with_variant_args_helper<Node3D,Vector3 const &,0>(Node3D * p_instance, void(Node3D::*)(const Vector3 &) p_method, const Variant * * p_args, Callable::CallError & r_error, IndexSequence<0> __formal) Line 223
call_with_variant_args_dv<Node3D,Vector3 const &>(Node3D * p_instance, void(Node3D::*)(const Vector3 &) p_method, const Variant * * p_args, int p_argcount, Callable::CallError & r_error, const Vector<Variant> & default_values) Line 370
MethodBindT<Node3D,Vector3 const &>::call(Object * p_object, const Variant * * p_args, int p_arg_count, Callable::CallError & r_error) Line 339
ClassDB::set_property(Object * p_object, const StringName & p_property, const Variant & p_value, bool * r_valid) Line 1677
Object::set(const StringName & p_name, const Variant & p_value, bool * r_valid) Line 361
Variant::set_named(const StringName & p_member, const Variant & p_value, bool & r_valid) Line 255
GDScriptFunction::call(GDScriptInstance * p_instance, const Variant * * p_args, int p_argcount, Callable::CallError & r_err, GDScriptFunction::CallState * p_state) Line 1210
GDScriptInstance::callp(const StringName & p_method, const Variant * * p_args, int p_argcount, Callable::CallError & r_error) Line 1907
Node::_gdvirtual__input_call(RequiredParam<InputEvent> arg1) Line 435
Node::_call_input(const Ref<InputEvent> & p_event) Line 3574
SceneTree::_call_input_pause(const StringName & p_group, SceneTree::CallInputType p_call_type, const Ref<InputEvent> & p_input, Viewport * p_viewport) Line 1451
Viewport::push_input(RequiredParam<InputEvent> rp_event, bool p_local_coords) Line 3512
Window::_window_input(const Ref<InputEvent> & p_ev) Line 1870
call_with_variant_args_helper<Window,Ref<InputEvent> const &,0>(Window * p_instance, void(Window::*)(const Ref<InputEvent> &) p_method, const Variant * * p_args, Callable::CallError & r_error, IndexSequence<0> __formal) Line 223
call_with_variant_args<Window,Ref<InputEvent> const &>(Window * p_instance, void(Window::*)(const Ref<InputEvent> &) p_method, const Variant * * p_args, int p_argcount, Callable::CallError & r_error) Line 337
CallableCustomMethodPointer<Window,void,Ref<InputEvent> const &>::call(const Variant * * p_arguments, int p_argcount, Variant & r_return_value, Callable::CallError & r_call_error) Line 103
Callable::callp(const Variant * * p_arguments, int p_argcount, Variant & r_return_value, Callable::CallError & r_call_error) Line 57
Callable::call<Ref<InputEvent>>(Ref<InputEvent> <p_args_0>) Line 951
DisplayServerWindows::_dispatch_input_event(const Ref<InputEvent> & p_event) Line 4539
DisplayServerWindows::_dispatch_input_events(const Ref<InputEvent> & p_event) Line 4509
Input::_parse_input_event_impl(const Ref<InputEvent> & p_event, bool p_is_emulated) Line 988
Input::flush_buffered_events() Line 1294
DisplayServerWindows::process_events() Line 3880
OS_Windows::run() Line 2353

Then the vehicle body does a ray cast, which flushes pending bodies to add. At this point the body is still at (-1 0 0) and the transform is still marked dirty. Because of #108544 this now calls _enqueue_call_queries:

JoltBody3D::_enqueue_call_queries() Line 166
JoltBody3D::_on_wake_up() Line 308
JoltBodyActivationListener3D::OnBodyActivated(const JPH::BodyID & p_body_id, unsigned __int64 p_body_user_data) Line 39
JPH::BodyManager::ActivateBodies(const JPH::BodyID * inBodyIDs, int inNumber) Line 575
JPH::BodyInterface::AddBodiesFinalize(JPH::BodyID * ioBodies, int inNumber, void * inAddState, JPH::EActivation inActivationMode) Line 194
JoltSpace3D::flush_pending_objects() Line 474
JoltPhysicsDirectSpaceState3D::intersect_ray(const PhysicsDirectSpaceState3D::RayParameters & p_parameters, PhysicsDirectSpaceState3D::RayResult & r_result) Line 469
VehicleBody3D::_ray_cast(int p_idx, PhysicsDirectBodyState3D * s) Line 484
VehicleBody3D::_body_state_changed(PhysicsDirectBodyState3D * p_state) Line 941
call_with_variant_args_helper<RigidBody3D,PhysicsDirectBodyState3D *,0>(RigidBody3D * p_instance, void(RigidBody3D::*)(PhysicsDirectBodyState3D *) p_method, const Variant * * p_args, Callable::CallError & r_error, IndexSequence<0> __formal) Line 223
call_with_variant_args<RigidBody3D,PhysicsDirectBodyState3D *>(RigidBody3D * p_instance, void(RigidBody3D::*)(PhysicsDirectBodyState3D *) p_method, const Variant * * p_args, int p_argcount, Callable::CallError & r_error) Line 337
CallableCustomMethodPointer<RigidBody3D,void,PhysicsDirectBodyState3D *>::call(const Variant * * p_arguments, int p_argcount, Variant & r_return_value, Callable::CallError & r_call_error) Line 103
Callable::callp(const Variant * * p_arguments, int p_argcount, Variant & r_return_value, Callable::CallError & r_call_error) Line 57
JoltBody3D::call_queries() Line 1115
JoltSpace3D::call_queries() Line 222
JoltPhysicsServer3D::flush_queries() Line 1649
PhysicsServer3DWrapMT::flush_queries() Line 76
Main::iteration() Line 4864
OS_Windows::run() Line 2354

Then the queries are flushed. This overwrites the global transform for the body to the current physics state at (-1 0 0), effectively forgetting that we wanted the object to be at (2 0 0):

Node3D::set_transform(const Transform3D & p_transform) Line 394
Node3D::set_global_transform(const Transform3D & p_transform) Line 419
RigidBody3D::_sync_body_state(PhysicsDirectBodyState3D * p_state) Line 146
RigidBody3D::_body_state_changed(PhysicsDirectBodyState3D * p_state) Line 179
call_with_variant_args_helper<RigidBody3D,PhysicsDirectBodyState3D *,0>(RigidBody3D * p_instance, void(RigidBody3D::*)(PhysicsDirectBodyState3D *) p_method, const Variant * * p_args, Callable::CallError & r_error, IndexSequence<0> __formal) Line 223
call_with_variant_args<RigidBody3D,PhysicsDirectBodyState3D *>(RigidBody3D * p_instance, void(RigidBody3D::*)(PhysicsDirectBodyState3D *) p_method, const Variant * * p_args, int p_argcount, Callable::CallError & r_error) Line 337
CallableCustomMethodPointer<RigidBody3D,void,PhysicsDirectBodyState3D *>::call(const Variant * * p_arguments, int p_argcount, Variant & r_return_value, Callable::CallError & r_call_error) Line 103
Callable::callp(const Variant * * p_arguments, int p_argcount, Variant & r_return_value, Callable::CallError & r_call_error) Line 57
JoltBody3D::call_queries() Line 1115
JoltSpace3D::call_queries() Line 222
JoltPhysicsServer3D::flush_queries() Line 1649
PhysicsServer3DWrapMT::flush_queries() Line 76
Main::iteration() Line 4864
OS_Windows::run() Line 2354

If there's no vehicle, then there's no ray cast and in the beginning of SceneTree::physics_process, flush_transform_notifications will be called. This sets the correct position on the physics server, thereby avoiding the bug.

Possible fixes:

• In SceneTree::iteration_prepare we now conditionally call flush_transform_notifications based on if physics interpolation is active. Calling this unconditionally fixes the issue because it means the transforms will be flushed before the vehicle does a ray cast. This fix probably means you can still trigger the same problem if you do a collision query in the _input gd script function.
• Changing JoltBody3D to only enqueue call queries when we're not adding objects ourselves. I did this in https://github.com/jrouwe/godot/tree/115322 and that fixes the issue. The downside of this change is that the vehicle ray cast will see the body at (-1 0 0) instead of at (2 0 0). Note that this was the case in 4.5 beta 3 too.
• Ideally, whenever you make a change to a body, the transform will be immediately pushed to the physics server. I don't know why notifications are turned off in the 1st callstack. Changing that would also be a possible fix.

@mihe What do you think is the correct fix here?

Edit: As an alternative to https://github.com/jrouwe/godot/tree/115322 it is maybe safer to only have an activation listener active during PhysicsSystem::Update (activating it just before that call and deactivating it right after).

[mihe]

Yikes! That looks like it took a while to distill down to an MRP. I appreciate the effort, from both of you.

As an alternative to https://github.com/jrouwe/godot/tree/115322 it is maybe safer to only have an activation listener active during PhysicsSystem::Update (activating it just before that call and deactivating it right after).

Yes, that would seem like the most appropriate fix here. I doubt I would've caught this bug even if I'd known that the activation listener would be called outside of the simulation step, but my assumption at the time was that it wouldn't be.

I took the liberty of putting up a pull request for it: #115364

Ideally, whenever you make a change to a body, the transform will be immediately pushed to the physics server. I don't know why notifications are turned off in the 1st callstack.

This is meant to be an optimization. See Node3D.force_update_transform.