Solving ground position in noise generated background world?

[FishOfTheNorthStar]

I'm trying to get ground positions in noise generated areas, and I've had a little success with it so far but it's not consistent, some areas i get a pretty solid and accurate response, other areas it's all over the place. This effect seems more associated with what part of the 0->1024 interval the location is at than how far it is from 0,0, which was my first inclination (floating point accuracy etc).

Here's where it's being well behaved:

but here it sunk most of them somewhat (still close to the surface though):

Here's the gdscript port of the shader's noise func, as I have it now (partially functional). I have this written for the extension too but while i'm sorting it out I wanted something faster to revise.
gdscript

func fract(f:float)->float:
	return f - floor(f);
func hashf(f:float)->float:
	return fract(sin(f) * 1e4);
func hashv2(v:Vector2)->float:
	return fract(1e4 * sin(17.0 * v.x + v.y * 0.1) * (0.1 + abs( sin(v.y * 13.0 + v.x))))
#// https://iquilezles.org/articles/morenoise/
func noise2D(x:Vector2) -> Vector3:
	var f:Vector2 = Vector2(fract(x.x),fract(x.y));
	var u:Vector2 = f*f*f*(f*(f*6.0-Vector2(15.0, 15.0))+Vector2(10.0, 10.0));
	var du:Vector2 = 30.0*f*f*((f*f)-Vector2(f.x*2.0, f.y*2.0)+Vector2(1.0, 1.0));
	var p:Vector2i = Vector2i(floorf(x.x), floorf(x.y));
	var a:float = hashv2( p               );
	var b:float = hashv2( p+Vector2i(1,0) );
	var c:float = hashv2( p+Vector2i(0,1) );
	var d:float = hashv2( p+Vector2i(1,1) );
	# Mix 4 corner percentages
	var k0:float =   a;
	var k1:float =   b - a;
	var k2:float =   c - a;
	var k3:float =   a - b - c + d;
	return Vector3( k0 + k1 * u.x + k2 * u.y + k3 * u.x * u.y, du.x * (k1 + k3 * u.y), du.y * (k2 + k3 * u.x)  ); 

#func noise_type1(p:Vector2, octaves:int) -> float:
func noise_type1(p:Vector2, octaves:int) -> float:
	var a:float = 0.0;
	var b:float = 1.0;
	var d:Vector2 = Vector2(0.0, 0.0);
	for i in range(0, octaves):
		var n = noise2D(p);
		d += Vector2(n.y, n.z);
		a += Vector2(0., b * n.x).y / Vector2(0., 1.0 + d.dot(d)).y;
		b *= 0.5;
		p = Vector2(0.8 * p.x + 0.6 * p.y, -0.6 * p.x + 0.8 * p.y) * 2.0;
	return a;
	
func get_unweighted_generated_height(worldPos:Vector3 , octaves:int = -1 ) -> float:
	if (terrain_mat != null):
		var _bg_world_offset:Vector3 = terrain_mat.get_bg_world_offset();
		var _bg_world_height:float = terrain_mat.get_bg_world_height();
		var _bg_world_scale:float = terrain_mat.get_bg_world_scale();
		var _bg_world_max_octaves:int = terrain_mat.get_bg_world_max_octaves();
		var wpx:float = ((worldPos.x / 1024.) + _bg_world_offset.x) * _bg_world_scale * .1;
		var wpz:float = ((worldPos.z / 1024.) + _bg_world_offset.z) * _bg_world_scale * .1;
		if (octaves == -1):
			octaves = _bg_world_max_octaves;
		return noise_type1( Vector2(wpx, wpz) , octaves) * (_bg_world_height*10.0) + (_bg_world_offset.y * 100.); 
	return 0.;

(edit: I had some notes in here about the du calculation that after closer testing seems to be wrong, there is no noticeable change between either version original or what I thought was different.)

So if anyone has any thoughts on best way to accurately perform the noise funcs on CPU that'd be great. If it helps, I already tried as many variations of 'cast some portion of the process into a vector2 etc then use a member of the vector instead of a godot float so it's a proper 32 bit float'. Then tried the opposite where i did all of it in 64 bit precision which just did not work at all. The above code is my most functional version so far.

[TokisanGames]

Terrain3D::get_intersection() uses a visual, GPU based raycaster which gives an accurate position of the ground anywhere. That could feed into get_height() and our dynamic collision generator when outside of regions.

The GPU can report normals, but it adds texture normals so it's way too jittery. But we could adapt get_normal() to use 3 get_intersections() outside of regions instead.

See https://twitter.com/TokisanGames/status/1753549183183921624

[TokisanGames]

Closing since this was answered. I have also consolidated various collision information into one page in the latest documentation:

https://terrain3d.readthedocs.io/en/latest/docs/collision.html