From f0142a29c9a36d2b87b19b763d88c5ca2245c7dc Mon Sep 17 00:00:00 2001 From: Daniel Weipert Date: Wed, 19 Feb 2025 15:00:56 +0100 Subject: next commit --- chunk.gd | 173 ++++++++++++++++++++++++++++++++++++++++++--------------------- 1 file changed, 115 insertions(+), 58 deletions(-) (limited to 'chunk.gd') diff --git a/chunk.gd b/chunk.gd index c750153..4d24eba 100644 --- a/chunk.gd +++ b/chunk.gd @@ -1,39 +1,44 @@ class_name Chunk -extends Node +extends Node3D -static var chunks: Array = [] - -const CHUNK_SIZE := Vector3i(16, 16, 16) - -var position := Vector3i.ZERO -var mesh := MeshInstance3D.new() +var grid_position := Vector3i.ZERO +var mesh: ArrayMesh = ArrayMesh.new() @export var noise: FastNoiseLite @export var blocks: Array = [] func generate_block_data(row: int, column: int, depth: int, empty: bool = false): - position = Vector3i(row, column, depth) + Global.mutex.lock() + + grid_position = Vector3i(row, column, depth) blocks = [] - for x in CHUNK_SIZE.x: + for x in Global.CHUNK_SIZE.x: blocks.append([]) - for y in CHUNK_SIZE.y: + for y in Global.CHUNK_SIZE.y: blocks[x].append([]) - for z in CHUNK_SIZE.z: + for z in Global.CHUNK_SIZE.z: var block_position = Vector3i( - position.x * CHUNK_SIZE.x + x, - position.y * CHUNK_SIZE.y + y, - position.z * CHUNK_SIZE.z + z + grid_position.x * Global.CHUNK_SIZE.x + x, + grid_position.y * Global.CHUNK_SIZE.y + y, + grid_position.z * Global.CHUNK_SIZE.z + z )# * 2 var value = noise.get_noise_3d(block_position.x, block_position.y, block_position.z) * 100 var type = Block.Type.AIR - if value > -15: + if value > 4: type = Block.Type.GRASS - elif value > -20: + if value < -4: type = Block.Type.STONE + #if value < -16: + #type = Block.Type.DIRT + if value < -17 and value > -20: + type = Block.Type.SAND + if abs(value) > 21 and abs(value) < 21.25: + type = [Block.Type.STONE, Block.Type.YELLOW_STONE, Block.Type.BLUE_STONE, Block.Type.RED_STONE, Block.Type.BLACK_STONE].pick_random() + #print(value) var block = Block.new() block.position = block_position @@ -43,9 +48,13 @@ func generate_block_data(row: int, column: int, depth: int, empty: bool = false) block.type = Block.Type.AIR blocks[x][y].append(block) + + Global.mutex.unlock() -func generate_mesh() -> MeshInstance3D: +func generate_mesh(): + Global.mutex.lock() + var material := preload("res://new_shader_material.tres") var st = SurfaceTool.new() st.begin(Mesh.PRIMITIVE_TRIANGLES) @@ -56,41 +65,52 @@ func generate_mesh() -> MeshInstance3D: for z in blocks[x][y].size(): var block: Block = blocks[x][y][z] + if block.type == Block.Type.AIR: + continue + var block_front: Block if block_exists(x, y, z + 1): block_front = blocks[x][y][z + 1] - elif is_chunk_border(x, y, z) and chunk_exists(position.x, position.y, position.z + 1): - block_front = chunks[position.x][position.y][position.z + 1].blocks[x][y][0] + elif is_chunk_border(x, y, z) and chunk_exists(grid_position + Vector3i(0, 0, 1)): + var chunk_front := Global.chunks[grid_position + Vector3i(0, 0, 1)] + block_front = chunk_front.blocks[x][y][0] var block_back: Block if block_exists(x, y, z - 1): block_back = blocks[x][y][z - 1] - elif is_chunk_border(x, y, z) and chunk_exists(position.x, position.y, position.z - 1): - block_back = chunks[position.x][position.y][position.z - 1].blocks[x][y][CHUNK_SIZE.z - 1] - - var block_left: Block - if block_exists(x - 1, y, z): - block_left = blocks[x - 1][y][z] - elif is_chunk_border(x, y, z) and chunk_exists(position.x - 1, position.y, position.z): - block_left = chunks[position.x - 1][position.y][position.z].blocks[CHUNK_SIZE.x - 1][y][z] + elif is_chunk_border(x, y, z) and chunk_exists(grid_position + Vector3i(0, 0, -1)): + var chunk_back := Global.chunks[grid_position + Vector3i(0, 0, -1)] + block_back = chunk_back.blocks[x][y][Global.CHUNK_SIZE.z - 1] var block_right: Block if block_exists(x + 1, y, z): block_right = blocks[x + 1][y][z] - elif is_chunk_border(x, y, z) and chunk_exists(position.x + 1, position.y, position.z): - block_right = chunks[position.x + 1][position.y][position.z].blocks[0][y][z] + elif is_chunk_border(x, y, z) and chunk_exists(grid_position + Vector3i(1, 0, 0)): + var chunk_right := Global.chunks[grid_position + Vector3i(1, 0, 0)] + block_right = chunk_right.blocks[0][y][z] + + var block_left: Block + if block_exists(x - 1, y, z): + block_left = blocks[x - 1][y][z] + elif is_chunk_border(x, y, z) and chunk_exists(grid_position + Vector3i(-1, 0, 0)): + var chunk_left := Global.chunks[grid_position + Vector3i(-1, 0, 0)] + block_left = chunk_left.blocks[Global.CHUNK_SIZE.x - 1][y][z] var block_top: Block if block_exists(x, y + 1, z): block_top = blocks[x][y + 1][z] - elif is_chunk_border(x, y, z) and chunk_exists(position.x, position.y + 1, position.z): - block_top = chunks[position.x][position.y + 1][position.z].blocks[x][0][z] + elif is_chunk_border(x, y, z) and chunk_exists(grid_position + Vector3i(0, 1, 0)): + var chunk_top := Global.chunks[grid_position + Vector3i(0, 1, 0)] + #if chunk_top.is_inside_tree(): + block_top = chunk_top.blocks[x][0][z] var block_bottom: Block if block_exists(x, y - 1, z): block_bottom = blocks[x][y - 1][z] - elif is_chunk_border(x, y, z) and chunk_exists(position.x, position.y - 1, position.z): - block_bottom = chunks[position.x][position.y - 1][position.z].blocks[x][CHUNK_SIZE.y - 1][z] + elif is_chunk_border(x, y, z) and chunk_exists(grid_position + Vector3i(0, -1, 0)): + var chunk_bottom := Global.chunks[grid_position + Vector3i(0, -1, 0)] + #if chunk_bottom.is_inside_tree(): + block_bottom = chunk_bottom.blocks[x][Global.CHUNK_SIZE.y - 1][z] if not block.type == Block.Type.AIR: if block.type == Block.Type.GRASS: @@ -106,12 +126,12 @@ func generate_mesh() -> MeshInstance3D: if not block_front or block_front.type == Block.Type.AIR: block.add_face(st, Block.Face.FRONT) - if not block_right or block_right.type == Block.Type.AIR: - block.add_face(st, Block.Face.RIGHT) - if not block_back or block_back.type == Block.Type.AIR: block.add_face(st, Block.Face.BACK) + if not block_right or block_right.type == Block.Type.AIR: + block.add_face(st, Block.Face.RIGHT) + if not block_left or block_left.type == Block.Type.AIR: block.add_face(st, Block.Face.LEFT) @@ -123,16 +143,24 @@ func generate_mesh() -> MeshInstance3D: #st.generate_normals() - #mesh = MeshInstance3D.new() - mesh.mesh = st.commit() + mesh = st.commit() - for child in mesh.get_children(): - child.queue_free() - mesh.create_trimesh_collision.call_deferred() - - mesh.set_meta("chunk", self) + Global.mutex.unlock() + + +func update_mesh() -> void: + $MeshInstance3D.mesh = mesh - return mesh + var shape := ConcavePolygonShape3D.new() + var faces := mesh.get_faces() + if faces.size() > 0: + shape.set_faces(mesh.get_faces()) + $StaticBody3D/CollisionShape3D.shape = shape + + +func add_to(node: Node) -> void: + node.add_child(self) + update_mesh() func generate_chunk(row: int, column: int, depth: int): @@ -145,36 +173,65 @@ func generate_chunk(row: int, column: int, depth: int): func add_block(block_position: Vector3, block_type: Block.Type = Block.Type.GRASS) -> void: var block = Block.new() block.position = Vector3i( - position.x * CHUNK_SIZE.x + block_position.x, - position.y * CHUNK_SIZE.y + block_position.y, - position.z * CHUNK_SIZE.z + block_position.z + grid_position.x * Global.CHUNK_SIZE.x + int(block_position.x), + grid_position.y * Global.CHUNK_SIZE.y + int(block_position.y), + grid_position.z * Global.CHUNK_SIZE.z + int(block_position.z) ) block.type = block_type blocks[block_position.x][block_position.y][block_position.z] = block - generate_mesh.call_deferred() + #generate_mesh.call_deferred() func remove_block(block_position: Vector3) -> void: blocks[block_position.x][block_position.y][block_position.z].type = Block.Type.AIR - generate_mesh.call_deferred() -static func chunk_exists(x: int, y: int, z: int): - return x >= 0 and chunks.size() - 1 >= x and y >= 0 and chunks[x].size() - 1 >= y and z >= 0 and chunks[x][y].size() - 1 >= z +static func chunk_exists(chunk_position: Vector3i): + return Global.chunks.has(chunk_position) + #return x >= 0 and chunks.size() - 1 >= x and y >= 0 and chunks[x].size() - 1 >= y and z >= 0 and chunks[x][y].size() - 1 >= z func block_exists(x: int, y: int, z: int): return x >= 0 and blocks.size() - 1 >= x and y >= 0 and blocks[x].size() - 1 >= y and z >= 0 and blocks[x][y].size() - 1 >= z func is_chunk_border(x: int, y: int, z: int): - return x == 0 or x == CHUNK_SIZE.x - 1 or y == 0 or y == CHUNK_SIZE.y - 1 or z == 0 or z == CHUNK_SIZE.z - 1 + return x == 0 or x == Global.CHUNK_SIZE.x - 1 or y == 0 or y == Global.CHUNK_SIZE.y - 1 or z == 0 or z == Global.CHUNK_SIZE.z - 1 + +func get_bordering_chunks(block_position: Vector3i) -> Array[Vector3i]: + var bordering_chunks := [] as Array[Vector3i] + + if not is_chunk_border(block_position.x, block_position.y, block_position.z): + return bordering_chunks + + if block_position.z == 0: + bordering_chunks.append(grid_position + Vector3i(0, 0, -1)) + elif block_position.z == Global.CHUNK_SIZE.z - 1: + bordering_chunks.append(grid_position + Vector3i(0, 0, 1)) + + if block_position.x == 0: + bordering_chunks.append(grid_position + Vector3i(-1, 0, 0)) + elif block_position.x == Global.CHUNK_SIZE.x - 1: + bordering_chunks.append(grid_position + Vector3i(1, 0, 0)) + + if block_position.y == 0: + bordering_chunks.append(grid_position + Vector3i(0, -1, 0)) + elif block_position.y == Global.CHUNK_SIZE.y - 1: + bordering_chunks.append(grid_position + Vector3i(0, 1, 0)) + + return bordering_chunks + +func get_neighboring_blocks(_block_position: Vector3i) -> Array[Vector3i]: + return [] -static func global_to_chunk(global_position: Vector3) -> Vector3i: - return floor(global_position / Vector3(CHUNK_SIZE)) +@warning_ignore("shadowed_variable_base_class") +static func global_to_chunk(global_position: Vector3, normal: Vector3) -> Vector3i: + return floor((global_position - normal * (Block.BLOCK_SIZE * 0.5)) / Vector3(Global.CHUNK_SIZE)) -static func global_to_chunk_block(global_position: Vector3) -> Vector3i: - return global_to_block(global_position) - CHUNK_SIZE * global_to_chunk(global_position) +@warning_ignore("shadowed_variable_base_class") +static func global_to_chunk_block(global_position: Vector3, normal: Vector3) -> Vector3i: + return global_to_block(global_position, normal) - Global.CHUNK_SIZE * global_to_chunk(global_position, normal) -static func global_to_block(global_position: Vector3) -> Vector3i: - return floor(global_position) +@warning_ignore("shadowed_variable_base_class") +static func global_to_block(global_position: Vector3, normal: Vector3) -> Vector3i: + return floor(global_position - normal * (Block.BLOCK_SIZE * 0.5)) -- cgit v1.2.3