Handle chunk boundaries by making sure we find neighbouring chunks when searching.

Round aabb values to pixel boundaries, to keep things from getting weird with arbitrary floating point rounding.

Author: jaynabonne

TerrainChunked.gd

@@ -54,8 +54,10 @@ func _ready():
 	if get_node_or_null(terrain_tool_node):
 		terrain_tool = get_node(terrain_tool_node)
 #	print(range(-_size/2-8, 64-/2+8, 16))
-	for i in range((-_size+chunk_size)/2, (_size+chunk_size)/2, chunk_size):
-		for j in range((-_size+chunk_size)/2, (_size+chunk_size)/2, chunk_size):
+	var r = range((-_size+chunk_size)/2, (_size+chunk_size)/2, chunk_size)
+	# var r = range((-2*chunk_size+chunk_size)/2, (2*chunk_size+chunk_size)/2, chunk_size)
+	for i in r:
+		for j in r:
 			var image_offset: Vector2 = Vector2(range_lerp(i, -_size/2, _size/2, 0, _size), range_lerp(j, -_size/2, _size/2, 0, _size))
 			var chunk = Chunk.new(Vector3(i, 0, j), chunk_size, 0, height_map, image_offset)
 			add_child(chunk)
@@ -96,10 +98,16 @@ func _process(delta):
 			var aabb = terrain_tool.get_transformed_aabb()
 			aabb.position.y -= 50
 			aabb.size.y += 100
-			var queried_chunks = quad_tree.query(aabb)
+
+			# print("--------: ", aabb)
+
+			var vertex_size = 0.5
+
+			var queried_chunks = quad_tree.query(aabb.grow(vertex_size))
 			for chunk in queried_chunks:
-				var new_aabb = aabb.intersection(chunk.get_transformed_aabb())
+				var new_aabb = aabb
 				var old_aabb = (chunk.global_transform as Transform).xform_inv(new_aabb)
+				# print("chunk: ", chunk, " (", chunk.get_transformed_aabb(), "), aabb: ", aabb, ", new: ", new_aabb, ", old: ", old_aabb)
 				old_aabb.position.y -= 50
 				old_aabb.size.y += 100
 				(chunk as Chunk)._process_chunk(delta, terrain_tool, old_aabb)

chunking/Chunk.gd

@@ -36,8 +36,8 @@ func generate_mesh():
 	mesh.size = Vector2(size, size)
 
 	if lod_level == 0:
-		mesh.subdivide_width = size * 2
-		mesh.subdivide_depth = size * 2
+		mesh.subdivide_width = (size * 2)-1
+		mesh.subdivide_depth = (size * 2)-1
 	if lod_level == 1:
 		mesh.subdivide_width = size
 		mesh.subdivide_depth = size
@@ -47,7 +47,7 @@ func generate_mesh():
 
 	mesh_data_tool = create_datatool_from_mesh()
 	generate_collision_mesh()
-	
+
 	setup_quadtree()
 
 func setup_quadtree():
@@ -56,6 +56,7 @@ func setup_quadtree():
 		var spatial_vertex = Spatial.new()
 		spatial_vertex.translation = vertex
 		mesh_data_tool.set_vertex(i, Vector3(vertex.x, 0, vertex.z))
+		# print("vertex ", i, ": ", vertex)
 		spatial_vertex.set_meta("i", i)
 		quad_tree.add_body(spatial_vertex, _get_common_bounds(vertex))
 	quad_tree.draw(1, true, true, true, global_transform)
@@ -65,11 +66,20 @@ func _get_common_bounds(vertex):
 	return AABB(Vector3(vertex.x-0.25, vertex.y, vertex.z-0.25), Vector3(0.5, 0, 0.5))
 
 func _process_chunk(delta, terrain_tool, aabb: AABB):
-	var bodies = quad_tree.query(aabb)
+	var vertex_size = 0.5
+	aabb.position.x = floor(aabb.position.x / vertex_size)*vertex_size
+	aabb.position.z = floor(aabb.position.z / vertex_size)*vertex_size
+	aabb.end.x = ceil(aabb.end.x / vertex_size)*vertex_size
+	aabb.end.x = ceil(aabb.end.x / vertex_size)*vertex_size
+
+	var bodies = quad_tree.query(aabb.grow(0.05))
+	# print("chunk: ", self, "aabb:", aabb, " -> ", bodies.size())
+
 	for body in bodies:
 		var vertex = body.get_translation()
 		var old_vertex = body.get_translation()
 		var i = body.get_meta("i")
+		
 		if !terrain_tool.current_state == terrain_tool.TerrainToolStates.SLOPE_FLATTEN:
 			vertex.y += terrain_tool.get_strength_at_position(old_vertex, false) * ((2.0 * int(!terrain_tool.current_state == terrain_tool.TerrainToolStates.SLOPE_DOWN)) - 1) * delta
 		else:
@@ -79,6 +89,7 @@ func _process_chunk(delta, terrain_tool, aabb: AABB):
 				vertex.y += terrain_tool.get_strength_at_position(old_vertex, false) * ((2.0 * int(vertex.y < 0)) - 1) * delta
 		vertex.y = clamp(vertex.y, -50, 100)
 		if vertex != old_vertex:
+			# print("vertex ", i, ": ", vertex, ": ", old_vertex.y, " -> ", vertex.y)
 			mesh_data_tool.set_vertex(i, vertex)
 			body.set_translation(vertex)
 			quad_tree.update_body(body, _get_common_bounds(vertex))