Raycast possible in separate thread?

tucono maybe you could copy the stat to a varriable for the raycast thread? Explore mutex

tucono Get the space state object in the main thread and pass it to raycast threads.

xyz Nope, even calls using the state object sourced from outside of physics_process() results in "space->locked" errors.

test code:

var thread = Thread.new()


func _ready():
	var dss = await AW_get_dss()
	
	var c = Callable(self,"thread_func")
	thread.start(thread_func.bind(dss))
	
	
	print("done!")


func thread_func(dss):
	
	
	randomize()
	for x in range(90000):
		var p1 = Vector3(randf_range(0,20),randf_range(0,20),randf_range(0,20))
		var p2 = Vector3(randf_range(0,20),randf_range(0,20),randf_range(0,20))
		
		var r = simplified_line_of_sight_test([p1,p2,dss])
		print(str(x)+": "+str(r))
		


func _physics_process(delta):
	var p1 = Vector3(randf_range(0,20),randf_range(0,20),randf_range(0,20))
	var p2 = Vector3(randf_range(0,20),randf_range(0,20),randf_range(0,20))
	
	var dss = get_world_3d().direct_space_state
	
	var r = simplified_line_of_sight_test([p1,p2,dss])
	print(str("phy")+": "+str(r))

func AW_get_dss():
	await get_tree().physics_frame
	return get_world_3d().direct_space_state


func simplified_line_of_sight_test(params_arr):
	
	var perception_pos = params_arr[0]
	var perceived_entity_pos = params_arr[1]
	var dss = params_arr[2]
	var exclude_arr = []
	
	
	#do raycasts
	var is_obstructed = true
	
	
	
	var x = PhysicsRayQueryParameters3D.new()
	x.from = perception_pos
	x.to = perceived_entity_pos
	x.exclude = exclude_arr
	
	var _result = dss.intersect_ray( x )
	if _result.size() == 0:
		is_obstructed = false
	
	return !is_obstructed

There seems to be no way of offloading physics from the physics thread. This is now an issue for me because it means that every time I want to do a raycast from any other thread, I need to await a physics process frame.

I could try and force the physics thread into an alternative process loop that only updates upon request (like I did for threads here), allowing me to make physics calls without delay, but doing that would disable all physics_process() loops across my entire project, and if any nodes rely on physics_process() they would likely cease to work.

Overall really sucks; what if you want to make a bunch of disjointed physics calls without forcing the physics process to stall or being forced to wait upon process frames several times? Ideally there would be a way to duplicate the direct_space_state object to make physics tests independently from the physics server.

KnightNine Yep. You're right. Doing raycasts require interaction with the scene tree. And scene tree is in general not thread safe. See if you can use alternative approaches to your things that don't require casting.

I recently had a similar thing. I pushed some heavily raycasting code onto a thread and ended up generating and sampling a heightmap image instead of doing raycasts to find the intersection points. Of course, alternatives are not always possible. In that case, try to distribute casts through multiple frames.

xyz I made a feature request, but in the process of trying to work around this issue, I found out that I can't even halt the physics_process() loop without also halting the main thread, turns out physics threading doesn't work how I expected it to so this system doesn't really work without slowing the main thread:

var physics_thread_held = false
var physics_thread_semaphore = Semaphore.new()
var physics_thread_semaphore_c = 0
var caller_semaphore = Semaphore.new()
var caller_semaphore_c = 0

#number of function calls in the held physics thread before allowing a physics frame to pass in order to smooth out the loading sequence and lower the ammount of stuttering
const HELD_PHYSICS_THREAD_FRAME_PASS_ITERATION = 50
var iteration = 0

var physics_function_object
var physics_function_name
var physics_function_params
var physics_function_result



func held_physics_thread_func():
	while physics_thread_held:
		
		physics_thread_semaphore.wait()
#		if physics_thread_semaphore_c > 1:
#			OS.alert("whoops physics_thread_semaphore_c")
#			System.system_breakpoint()
		physics_thread_semaphore_c-=1
		
		iteration+=1
		
		#only allow the call to be made when the semaphore post count is 0 so that this never begins to overlap with other calls to this loop
		if physics_function_name != null:
			Logger.info(physics_function_params)
			physics_function_result = physics_function_object.call(physics_function_name,physics_function_params)
			#after physics_function_result retreived, allow caller function to return
			caller_semaphore_c+=1
			Logger.info("caller_semaphore_c:"+str(caller_semaphore_c))
			physics_function_object = null
			physics_function_name = null
			caller_semaphore.post()
			
			if iteration > HELD_PHYSICS_THREAD_FRAME_PASS_ITERATION:
				Logger.info("held_physics_frame_pass!")
				iteration = 0
				await get_tree().physics_frame
	
	Logger.info("physics thread released!")
	

#call this first
func hold_physics_thread():
	if !physics_thread_held:
		physics_thread_held = true
		await get_tree().physics_frame
		held_physics_thread_func()
	

func release_physics_thread():
	if physics_thread_held:
		physics_thread_held = false
		physics_thread_semaphore.post()





func call_from_held_physics_thread(func_object,func_name,func_params):
	
	if !physics_thread_held:
		Logger.error("Invalid call_from_held_physics_thread call: physics thread not held.")
		return
	
	physics_function_object = func_object
	physics_function_name = func_name
	physics_function_params = func_params
	
	physics_thread_semaphore.post()
	#wait till function is complete in physics thread
	caller_semaphore.wait()
	
	if physics_function_result == null:
		#this shouldn't happen
		System.system_breakpoint()
	
	return  physics_function_result

Is there any way to check if the physics thread is locked? I think I'll need to modify the engine so that the physics functions return null instead of false when the space is locked so that I can simply spam raycasts in a while loop until I get a proper result when calling it from a thread. (that is if I can't create a get_is_space_locked() function )

kuligs2 I explored Mutex but somehow I can still manage to get a few space locked errors in my test code (first comment) when wrapping the simplified_line_of_sight_test() in a mutex.
Do you have any idea why this is the case?

KnightNine its out of my expertise scope, im not smarts enough.. the best advice you can get is from xyz.

KnightNine I'd just do it from the main thread, little by little. What actual problem are you trying to solve with raycasts here?