Godot 4.6: Fixing PhysicsRayQueryParameters3D Errors

Hey guys! If you're diving into Godot 4.6-dev3, you might've bumped into a head-scratcher when using PhysicsRayQueryParameters3D.create. Specifically, when you try to exclude objects from your raycasts using an array, you might be getting some error messages. Let's break down what's happening and how to fix it. This issue arises because of a type validation mismatch in how Godot handles the exclude parameter within PhysicsRayQueryParameters3D.create. The system is looking for an array of RIDs, which are essentially unique identifiers for physics objects, but you might be passing in a Node3D object directly. Don't worry, it's a common issue, and we'll walk through a solution.

The Problem: Type Mismatch in PhysicsRayQueryParameters3D.create

So, what's the deal? In Godot 4.6-dev3, when you call PhysicsRayQueryParameters3D.create, you're supposed to pass in an array of RIDs to the exclude parameter. These RIDs tell the physics engine which objects to ignore when performing the raycast. The problem is that, by default, you might be tempted to just pass in a Node3D directly, like in the example code. Godot's type checking system then throws an error because it expects something different.

Here's the error message you'll likely see:

E 0:02:27:327   physics_utils.gd:28 @ can_see_object(): Attempted to set a variable of type 'Object' into a TypedArray of type 'RID'.
  <C++ Error>   Method/function failed. Returning: false
  <C++ Source>  core/variant/container_type_validate.h:71 @ _internal_validate()
  <Stack Trace> physics_utils.gd:28 @ can_see_object()

And immediately following that:

E 0:02:27:327   physics_utils.gd:28 @ can_see_object(): Condition "!_p->typed.validate(value, "set")" is true.
  <C++ Source>  core/variant/array.cpp:520 @ set()
  <Stack Trace> physics_utils.gd:28 @ can_see_object()

Basically, Godot is saying, "Hey, you gave me an object when I was expecting an RID!" This happens because Node3D isn't directly compatible with the type the function expects.

How to Fix It: Getting the RID from the Node3D

The solution is pretty straightforward. Instead of passing the Node3D directly, you need to get the RID of the CollisionObject3D associated with your Node3D. Here's how you can modify your code to make it work:

static func can_see_object(
		from: Node3D,
		collider: CollisionObject3D,
		point: Vector3,
		normal: Vector3,
		height: float = 1.5,
		collision_mask: int = 0b101,
) -> bool:
	var space_state: PhysicsDirectSpaceState3D = from.get_world_3d().direct_space_state

	# move this up a bit since it's on the ground at y = 0
	var origin := from.global_transform.origin + Vector3(0, height, 0)

	# move the point a bit forward towards the collider since we want the end to be INSIDE of it
	var end := point + -normal * 0.25

	# Get the RID of the object to exclude
	var exclude_rid: Array[RID] = [collider.get_rid()]

	# the final param here is to exclude the object itself from the raycast
	var query := PhysicsRayQueryParameters3D.create(origin, end, collision_mask, exclude_rid)

	var result := space_state.intersect_ray(query)

	if not result.has("collider"):
		return false

	return result["collider"] == collider

Let's break down the changes:

1. Get the RID: We've added var exclude_rid: Array[RID] = [collider.get_rid()]. This line is crucial. We're calling collider.get_rid() to retrieve the RID of the CollisionObject3D. Then, we place this RID into an array, which is exactly what PhysicsRayQueryParameters3D.create expects. It creates an array specifically typed to store RIDs.
2. Pass the RID Array: When creating the PhysicsRayQueryParameters3D, we now pass exclude_rid, which contains the RID of the object you want to exclude.

By doing this, you're telling the physics engine, "Hey, don't worry about this particular object when doing the raycast." The type mismatch error goes away because you're giving the function what it wants: an array of RIDs.

Understanding RIDs and Godot's Physics Engine

Okay, so what exactly is an RID? In Godot, an RID (Resource ID) is a unique identifier used internally by the engine's resource management system. Think of it as a secret code that the engine uses to keep track of objects, including physics bodies. You usually don't need to mess with RIDs directly. You just use them when the engine tells you to. In this case, the PhysicsRayQueryParameters3D.create method specifically needs RIDs for exclusion, so you'll need to fetch them using the get_rid() method.

Additional Tips and Troubleshooting

• Verify Object Type: Make sure the object you're trying to exclude is a CollisionObject3D. This includes things like StaticBody3D, RigidBody3D, and CharacterBody3D. If you try to get the RID of something that isn't a collision object, you might run into other issues.
• Check Your Godot Version: This specific issue appeared in Godot 4.6-dev3. If you're using a different version, the behavior might vary. Always double-check the documentation for your specific Godot version.
• Documentation: While the documentation provides a good overview, it's always a good idea to experiment and test. Try different scenarios to see how the raycast behaves with and without exclusions.
• Minimal Reproduction Project (MRP): If you are still running into trouble, creating a Minimal Reproduction Project (MRP) is the best way to isolate the issue. Create a simple project that reproduces the error and then share it with the Godot community. This can help others help you more quickly.

Wrapping Up

So, that's the lowdown on fixing the type validation error with PhysicsRayQueryParameters3D.create in Godot 4.6-dev3. By using get_rid() and passing an array of RIDs, you can get your raycasts working as expected. This small tweak keeps your Godot projects running smoothly. Keep coding, keep experimenting, and keep having fun! If you have any other questions, feel free to ask. Cheers!