229 lines
6.7 KiB
GDScript
229 lines
6.7 KiB
GDScript
@tool
|
|
extends Node
|
|
#var generation_thread: Thread = Thread.new()
|
|
#### CHUNK GENERATION ####
|
|
@export_category("CHUNK GENERATION")
|
|
|
|
const CHUNK_SIZE := 256
|
|
const CHUNK_BOUNDS := 6
|
|
|
|
## How detailed the chunk should be. This could be made a const when debug phase is finished
|
|
@export_range(4, 256, 4) var chunk_resolution := 32:
|
|
set(new_resolution):
|
|
chunk_resolution = new_resolution
|
|
update_all_mesh()
|
|
|
|
#### WORLD GENERATION ####
|
|
@export_category("WORLD GENERATION")
|
|
@export_tool_button("Generate Chunks") var generate_chunk_callable = generate.bind(true)
|
|
@export_tool_button("Delete Chunks") var delete_chunk_callable = delete.bind(true)
|
|
@export var terrainnoise: FastNoiseLite
|
|
@export_range(4.0, 256.0, 4.0) var height := 64.0:
|
|
set(new_height):
|
|
height = new_height
|
|
update_all_mesh()
|
|
|
|
var loaded_chunks := {}# Key: Vector2i, Value: MeshInstance3D
|
|
@export_category("player")
|
|
var player_coord := Vector2i(0,0)
|
|
|
|
|
|
# Called when the node enters the scene tree for the first time. ALSO IN EDITOR
|
|
func _ready() -> void:
|
|
if !(Engine.is_editor_hint()):
|
|
delete(true)
|
|
generate(true)
|
|
|
|
|
|
func generate(_ForceRegen: bool = false):
|
|
print('Generation starts')
|
|
generate_chunks_around(Vector3(0, 0, 0), _ForceRegen)
|
|
|
|
|
|
func _process(_delta):
|
|
var new_player_coord = get_chunk_coord($"../Player".position)
|
|
|
|
if new_player_coord == player_coord:
|
|
return
|
|
|
|
generate_chunks_around($"../Player".position)
|
|
player_coord = new_player_coord
|
|
|
|
|
|
func delete(_Force:bool = true):
|
|
|
|
for c in get_children():
|
|
c.free()
|
|
|
|
loaded_chunks.clear()
|
|
|
|
|
|
func generate_chunk(position: Vector3, _ForceRegen: bool = false):
|
|
WorkerThreadPool.add_task(func():
|
|
var mesh_instance = MeshInstance3D.new()
|
|
update_mesh(mesh_instance, position)
|
|
mesh_instance.position = position
|
|
var chunk_coord = get_chunk_coord(position)
|
|
call_deferred("add_chunk_deferred", mesh_instance, chunk_coord)
|
|
|
|
)
|
|
|
|
|
|
func add_chunk_deferred(mesh_instance: MeshInstance3D, chunk_coord: Vector2i):
|
|
add_child(mesh_instance)
|
|
if Engine.is_editor_hint():
|
|
mesh_instance.owner = get_tree().edited_scene_root
|
|
|
|
loaded_chunks[chunk_coord] = mesh_instance
|
|
print("Chunk at: ", str(mesh_instance.position), ", coord: ", str(chunk_coord), " loaded")
|
|
|
|
|
|
func get_height(x: float, y: float) -> float:
|
|
if not terrainnoise:
|
|
return 0.0
|
|
|
|
return terrainnoise.get_noise_2d(x, y) * height
|
|
|
|
|
|
func get_normal(x: float, y: float) -> Vector3:
|
|
if not terrainnoise:
|
|
return Vector3.UP
|
|
|
|
var epsilon := CHUNK_SIZE / chunk_resolution
|
|
var normal := Vector3(
|
|
(get_height(x + epsilon, y) - get_height(x - epsilon, y)) / (2.0 * epsilon),
|
|
1.0,
|
|
(get_height(x, y + epsilon) - get_height(x, y - epsilon)) / (2.0 * epsilon)
|
|
|
|
)
|
|
return normal.normalized()
|
|
|
|
|
|
func get_biome(x: float, z: float) -> String:
|
|
if not terrainnoise:
|
|
return "default"
|
|
|
|
var biome_noise = load("res://world_gen/biome_noise.tres")
|
|
biome_noise.seed = terrainnoise.seed
|
|
var value = biome_noise.get_noise_2d(x, z)
|
|
|
|
if value < -0.3:
|
|
return "desert"
|
|
elif value < 0.1:
|
|
return "forest"
|
|
elif value < 0.4:
|
|
return "mountain"
|
|
else:
|
|
return "ocean"
|
|
|
|
|
|
func update_all_mesh():
|
|
for chunk_coord in loaded_chunks:
|
|
update_mesh(loaded_chunks[chunk_coord], loaded_chunks[chunk_coord].position)
|
|
|
|
|
|
func update_mesh(chunk_terrain_instance: MeshInstance3D, chunk_pos: Vector3):
|
|
var plane: PlaneMesh = load("uid://rhv7l5ya1qnf").duplicate() # Used as a template for UV/vertex/normals that the final array mesh will inherit/expand
|
|
plane.subdivide_depth = chunk_resolution
|
|
plane.subdivide_width = chunk_resolution
|
|
plane.size = Vector2(CHUNK_SIZE, CHUNK_SIZE)
|
|
|
|
var plane_arrays := plane.get_mesh_arrays()
|
|
var vertex_array: PackedVector3Array = plane_arrays[ArrayMesh.ARRAY_VERTEX]
|
|
var normal_array: PackedVector3Array = plane_arrays[ArrayMesh.ARRAY_NORMAL]
|
|
var tangent_array: PackedFloat32Array = plane_arrays[ArrayMesh.ARRAY_TANGENT]
|
|
|
|
for i: int in vertex_array.size():
|
|
var vertex := vertex_array[i]
|
|
var world_x = chunk_pos.x + vertex.x
|
|
var world_z = chunk_pos.z + vertex.z
|
|
var normal := Vector3.UP
|
|
var tangent := Vector3.RIGHT
|
|
|
|
if terrainnoise:
|
|
vertex.y = get_height(world_x, world_z)
|
|
normal = get_normal(world_x, world_z)
|
|
tangent = normal.cross(Vector3.UP)
|
|
|
|
vertex_array[i] = vertex
|
|
normal_array[i] = normal
|
|
tangent_array[4 * i] = tangent.x
|
|
tangent_array[4 * i + 1] = tangent.y
|
|
tangent_array[4 * i + 2] = tangent.z
|
|
tangent_array[4 * i + 3] = 1.0
|
|
|
|
plane_arrays[ArrayMesh.ARRAY_VERTEX] = vertex_array
|
|
plane_arrays[ArrayMesh.ARRAY_NORMAL] = normal_array
|
|
plane_arrays[ArrayMesh.ARRAY_TANGENT] = tangent_array
|
|
|
|
var array_mesh := ArrayMesh.new()
|
|
array_mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, plane_arrays)
|
|
if get_biome_mat(chunk_pos):
|
|
array_mesh.surface_set_material(0, get_biome_mat(chunk_pos))
|
|
|
|
chunk_terrain_instance.mesh = array_mesh
|
|
chunk_terrain_instance.create_trimesh_collision()
|
|
|
|
|
|
func get_biome_mat(chunk_pos) -> Material:
|
|
# Apply biome-based material
|
|
var material = StandardMaterial3D.new()
|
|
|
|
if material:
|
|
material.albedo_texture = load("res://smooth+sand+dunes.jpg")
|
|
|
|
var biome = get_biome(chunk_pos.x + CHUNK_SIZE / 2.0, chunk_pos.z + CHUNK_SIZE / 2.0)
|
|
|
|
match biome:
|
|
"desert":
|
|
if material:
|
|
material.albedo_color = Color(1.0, 0.8, 0.4)
|
|
|
|
"forest":
|
|
if material:
|
|
material.albedo_color = Color(0.2, 0.6, 0.2)
|
|
|
|
"mountain":
|
|
if material:
|
|
material.albedo_color = Color(0.5, 0.5, 0.5)
|
|
|
|
"ocean":
|
|
if material:
|
|
material.albedo_color = Color(0.0, 0.4, 0.8)
|
|
|
|
return material
|
|
|
|
|
|
## Convert position to chunk coordinates
|
|
func get_chunk_coord(position: Vector3) -> Vector2i:
|
|
var coord_chunk_x = int(floor(position.x / CHUNK_SIZE))
|
|
var coord_chunk_z = int(floor(position.z / CHUNK_SIZE))
|
|
return Vector2i(coord_chunk_x, coord_chunk_z)
|
|
|
|
|
|
func generate_chunks_around(position: Vector3, ForceRegen: bool = false):
|
|
# Convert position to chunk coordinates
|
|
var position_to_coord := get_chunk_coord(position)
|
|
print("Closest chunk: ", str(position_to_coord))
|
|
var new_chunks := {}
|
|
|
|
for x in range(position_to_coord.x - CHUNK_BOUNDS, position_to_coord.x + CHUNK_BOUNDS + 1):
|
|
for z in range(position_to_coord.y - CHUNK_BOUNDS, position_to_coord.y + CHUNK_BOUNDS + 1):
|
|
var chunk_coord := Vector2i(x, z)
|
|
var chunk_position := Vector3(x * CHUNK_SIZE, 0, z * CHUNK_SIZE)
|
|
print("Trying to load chunk at coordinate: ", chunk_coord)
|
|
if loaded_chunks.has(chunk_coord):
|
|
new_chunks[chunk_coord] = loaded_chunks[chunk_coord]
|
|
else:
|
|
generate_chunk(chunk_position, ForceRegen)
|
|
new_chunks[chunk_coord] = null # Placeholder until chunk is added
|
|
|
|
# Unload chunks outside bounds
|
|
for coord in loaded_chunks.keys():
|
|
if not new_chunks.has(coord) && loaded_chunks[coord]:
|
|
loaded_chunks[coord].queue_free()
|
|
loaded_chunks[coord].call_deferred("queue_free")
|
|
print("chunk at ",str(coord), "unloading")
|
|
loaded_chunks.erase(coord)
|
|
|
|
loaded_chunks = new_chunks
|