extends Node3D

@export var width: int = 16
@export var height: int = 16
@export var depth: int = 16

var map_grid: Array[float] = []

func map_grid_get(x: int, y: int, z: int):
	return map_grid[z*height*width + y*width + x]

func gen_map_grid():
	map_grid.resize(width*height*depth)
	for z in depth:
		for y in height:
			for x in width:
				if y <= 5:
					map_grid[z*height*width + y*width + x] = -1.0
				else:
					map_grid[z*height*width + y*width + x] = 0.0

# Called when the node enters the scene tree for the first time.
func _ready():
	gen_map_grid()
	var vertices = PackedVector3Array()
	var triangles = PackedInt32Array()
	# Initialize the ArrayMesh.
	var arr_mesh = ArrayMesh.new()
	var arrays = []
	arrays.resize(Mesh.ARRAY_MAX)
	arrays[Mesh.ARRAY_VERTEX] = vertices
	arrays[Mesh.ARRAY_INDEX] = triangles
	
	var cell = MarchingCubes.Cell.new()
	
	for z in range(-1, depth):
		for y in range(-1, height):
			for x in range(-1, width):
				var grid = [
					[x, y, z],
					[x + 1, y, z],
					[x + 1, y + 1, z],
					[x, y + 1, z],
					[x, y, z + 1],
					[x + 1, y, z + 1],
					[x + 1, y + 1, z + 1],
					[x, y + 1, z + 1],
				]
				for i in grid.size():
					if grid[i][0] >= width or grid[i][1] >= height or grid[i][2] >= depth or \
					   grid[i][0] < 0 or grid[i][1] < 0 or grid[i][2] < 0:
						cell.value[i] = 0.0
					else:
						cell.value[i] = map_grid_get(grid[i][0], grid[i][1], grid[i][2])
					cell.position[i] = Vector3(grid[i][0], grid[i][1], grid[i][2])
				
				MarchingCubes.march_cube(cell, triangles, vertices)
			
	# Create the Mesh.
	arr_mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arrays)
	var m = MeshInstance3D.new()
	m.mesh = arr_mesh
	
	var col_mesh = arr_mesh.create_trimesh_shape()
	
	var collision_shape = CollisionShape3D.new()
	collision_shape.set_shape(col_mesh)
	
	m.add_child(collision_shape)
	
	add_child(m)

# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(_delta):
	pass