working

1 files changed, 501 insertions, 0 deletions

diff --git a/addons/voxel-core/classes/voxel_object.gd b/addons/voxel-core/classes/voxel_object.gd
new file mode 100644
index 0000000..8d12633
--- /dev/null
+++ b/addons/voxel-core/classes/voxel_object.gd
@@ -0,0 +1,501 @@
+tool
+extends MeshInstance
+# Makeshift interface class inhereted by all voxel visualization objects.
+
+
+
+## Signals
+# Emitted when VoxelSet is changed
+signal set_voxel_set(voxel_set)
+
+
+
+## Enums
+# Defines the modes in which Mesh can be constructed
+enum MeshModes {
+	# Naive meshing, simple culling of voxel faces; http://web.archive.org/web/20200428085802/https://0fps.net/2012/06/30/meshing-in-a-minecraft-game/
+	NAIVE,
+	# Greedy meshing, culls and merges similar voxel faces; http://web.archive.org/web/20201112011204/https://www.gedge.ca/dev/2014/08/17/greedy-voxel-meshing
+	GREEDY,
+	# Marching Cubes meshing, https://en.wikipedia.org/wiki/Marching_cubes
+	#MARCHING_CUBES,
+	# Transvoxel meshing, http://web.archive.org/web/20201112033736/http://transvoxel.org/
+	#TRANSVOXEL,
+}
+
+
+
+## Exported Variables
+# The meshing mode by which Mesh is generated
+export(MeshModes) var mesh_mode := MeshModes.NAIVE setget set_mesh_mode
+
+# Flag indicating that UV Mapping should be applied when generating meshes if applicable
+export var uv_map := false setget set_uv_map
+
+# Flag indicating the persitant attachment and maintenance of a StaticBody
+export var static_body := false setget set_static_body
+
+# The VoxelSet for this VoxelObject
+export(Resource) var voxel_set = null setget set_voxel_set
+
+
+
+## Public Variables
+# Flag indicating that edits to voxel data will be frequent
+# NOTE: When true will only allow naive meshing
+var edit_hint := 0 setget set_edit_hint
+
+
+
+# Public Methods
+# Sets the EditHint flag, calls update_mesh if needed and not told otherwise
+func set_edit_hint(value : int, update := is_inside_tree()) -> void:
+	edit_hint = value
+	
+	if update:
+		update_mesh()
+
+
+# Sets the mesh_mode, calls update_mesh if needed and not told otherwise
+func set_mesh_mode(value : int, update := is_inside_tree()) -> void:
+	mesh_mode = value
+	
+	if update:
+		update_mesh()
+
+
+# Sets the uv_map, calls update_mesh if needed and not told otherwise
+func set_uv_map(value : bool, update := is_inside_tree()) -> void:
+	uv_map = value
+	
+	if update:
+		update_mesh()
+
+
+# Sets static_body, calls update_static_body if needed and not told otherwise
+func set_static_body(value : bool, update := is_inside_tree()) -> void:
+	static_body = value
+	
+	if update:
+		update_static_body()
+
+
+# Sets voxel_set, calls update_mesh if needed and not told otherwise
+func set_voxel_set(value : Resource, update := is_inside_tree()) -> void:
+	if not (typeof(value) == TYPE_NIL or value is VoxelSet):
+		printerr("Invalid Resource given expected VoxelSet")
+		return
+	
+	if is_instance_valid(voxel_set):
+		if voxel_set.is_connected("requested_refresh", self, "update_mesh"):
+			voxel_set.disconnect("requested_refresh", self, "update_mesh")
+	
+	voxel_set = value
+	if is_instance_valid(voxel_set):
+		if not voxel_set.is_connected("requested_refresh", self, "update_mesh"):
+			voxel_set.connect("requested_refresh", self, "update_mesh")
+	
+	if update:
+		update_mesh()
+	emit_signal("set_voxel_set", voxel_set)
+
+
+# Return true if no voxels are present
+func empty() -> bool:
+	return true
+
+
+# Sets given voxel id at the given grid position
+func set_voxel(grid : Vector3, voxel_id : int) -> void:
+	pass
+
+
+# Replace current voxel data with given voxel data
+# voxels : Dictionary<Vector3, int> : voxels to set
+func set_voxels(voxels : Dictionary) -> void:
+	erase_voxels()
+	for grid in voxels:
+		set_voxel(grid, voxels[grid])
+
+
+# Returns voxel id at given grid position if present; otherwise returns -1
+func get_voxel_id(grid : Vector3) -> int:
+	return -1
+
+
+# Returns voxel Dictionary representing voxel id at given grid position
+func get_voxel(grid : Vector3) -> Dictionary:
+	return voxel_set.get_voxel(get_voxel_id(grid))
+
+
+# Returns Array of all voxel grid positions
+# return   :   Array<Vector3>   :   Array of Vector3 each represents a grid position of a voxel
+func get_voxels() -> Array:
+	return []
+
+
+# Erase voxel id at given grid position
+func erase_voxel(grid : Vector3) -> void:
+	pass
+
+
+# Erase all voxels
+func erase_voxels() -> void:
+	for grid in get_voxels():
+		erase_voxel(grid)
+
+
+# Returns 3D axis-aligned bounding box
+# volume   :   Array<Vector3>   :   Array of grid positions from which to calculate bounds
+# return   :   Dictionary       :   bounding box, contains: { position : Vector3, size: Vector3 }
+func get_box(volume := get_voxels()) -> Dictionary:
+	var box := { "position": Vector3.ZERO, "size": Vector3.ZERO }
+	
+	if not volume.empty():
+		box["position"] = Vector3.INF
+		box["size"] = -Vector3.INF
+		
+		for voxel_grid in volume:
+			if voxel_grid.x < box["position"].x:
+				box["position"].x = voxel_grid.x
+			if voxel_grid.y < box["position"].y:
+				box["position"].y = voxel_grid.y
+			if voxel_grid.z < box["position"].z:
+				box["position"].z = voxel_grid.z
+			
+			if voxel_grid.x > box["size"].x:
+				box["size"].x = voxel_grid.x
+			if voxel_grid.y > box["size"].y:
+				box["size"].y = voxel_grid.y
+			if voxel_grid.z > box["size"].z:
+				box["size"].z = voxel_grid.z
+		
+		box["size"] = (box["size"] - box["position"]).abs() + Vector3.ONE
+	
+	return box
+
+
+# Moves voxels in given volume by given translation
+# translation   :   Vector3          :   translation to move voxels by
+# volume        :   Array<Vector3>   :   Array of grid positions representing voxels to move
+func move(translation := Vector3(), volume := get_voxels()) -> void:
+	var translated := {}
+	for voxel_grid in volume:
+		translated[voxel_grid + translation] = get_voxel_id(voxel_grid)
+		erase_voxel(voxel_grid)
+	for voxel_grid in translated:
+		set_voxel(voxel_grid, translated[voxel_grid])
+
+
+# Centers voxels in given volume with respect to axis origin with the given alignment
+# alignment   :   Vector3          :   Alignment to center voxels by
+# volume      :   Array<Vector3>   :   Array of grid positions representing voxels to center
+func center(alignment := Vector3(0.5, 0.5, 0.5), volume := get_voxels()) -> void:
+	move(vec_to_center(alignment, volume), volume)
+
+
+# Flips voxels in given volume over set axis
+func flip(x : bool, y : bool, z : bool, volume := get_voxels()) -> void:
+	var flipped := {}
+	for voxel_grid in volume:
+		flipped[Vector3(
+				(voxel_grid.x + (1 if z else 0)) * (-1 if z else 1),
+				(voxel_grid.y + (1 if y else 0)) * (-1 if y else 1),
+				(voxel_grid.z + (1 if x else 0)) * (-1 if x else 1))] = get_voxel_id(voxel_grid)
+		erase_voxel(voxel_grid)
+	for voxel_grid in flipped:
+		set_voxel(voxel_grid, flipped[voxel_grid])
+
+
+# Returns the translation necessary to center given volume by
+# alignment   :   Vector3          :   Alignment to center voxels by
+# volume      :   Array<Vector3>   :   Array of grid positions representing voxels to center
+# return      :   Vector3          :   Translation necessary to center
+func vec_to_center(alignment := Vector3(0.5, 0.5, 0.5), volume := get_voxels()) -> Vector3:
+	var box := get_box(volume)
+	alignment = Vector3.ONE - Vector3(
+			clamp(alignment.x, 0.0, 1.0),
+			clamp(alignment.y, 0.0, 1.0),
+			clamp(alignment.z, 0.0, 1.0))
+	return -box["position"] - (box["size"] * alignment).floor()
+
+# A Fast Voxel Traversal Algorithm for Ray Tracing, by John Amanatides
+# Algorithm paper: https://web.archive.org/web/20201108160724/http://www.cse.chalmers.se/edu/year/2010/course/TDA361/grid.pdf
+# from           :   Vector3                      :   World position from which to start raycast
+# direction      :   Vector3                      :   Direction of raycast
+# max_distance   :   int                          :   Maximum distance of ray cast
+# stop           :   FuncRef                      :   Calls on function, that receives "hit" and returns bool, as raycast is projected, if it returns true raycast is returned
+# return         :   Dictionary<String, Vector3>  :   If voxel is "hit", returns Dictionary with grid position and face normal; else empty
+func intersect_ray(
+		from : Vector3,
+		direction : Vector3,
+		max_distance := 64,
+		stop : FuncRef = null) -> Dictionary:
+	var hit := {
+		"normal": Vector3(),
+	}
+	var grid := Voxel.world_to_grid(from)
+	var step := Vector3(
+			1 if direction.x > 0 else -1,
+			1 if direction.y > 0 else -1,
+			1 if direction.z > 0 else -1)
+	var t_delta := direction.inverse().abs()
+	var dist := from.distance_to(Voxel.world_to_snapped(from))
+	var t_max := t_delta * dist
+	var step_index := -1
+	
+	var t = 0.0
+	var valid := false
+	while t < max_distance:
+		hit["position"] = grid
+		hit["normal"].x = -step.x if step_index == 0 else 0
+		hit["normal"].y = -step.y if step_index == 1 else 0
+		hit["normal"].z = -step.z if step_index == 2 else 0
+		if get_voxel_id(grid) > -1 or (is_instance_valid(stop) and stop.call_func(hit)):
+			valid = true
+			break
+		
+		match t_max.min_axis():
+			Vector3.AXIS_X:
+				grid.x += step.x
+				t = t_max.x
+				t_max.x += t_delta.x
+				step_index = 0
+			Vector3.AXIS_Y:
+				grid.y += step.y
+				t = t_max.y
+				t_max.y += t_delta.y
+				step_index = 1
+			Vector3.AXIS_Z:
+				grid.z += step.z
+				t = t_max.z
+				t_max.z += t_delta.z
+				step_index = 2
+	if not valid:
+		hit.clear()
+	return hit
+
+
+# Returns Array of all voxel grid positions connected to given target
+# target     :   Vector3          :   Grid position at which to start flood select
+# selected   :   Array            :   Array to add selected voxel grid positions to
+# return     :   Array<Vector3>   :   Array of all voxel grid positions connected to given target
+func select_flood(target : Vector3, selected := []) -> Array:
+	selected.append(get_voxel_id(target))
+	
+	for direction in Voxel.Faces:
+		var next = target + direction
+		if get_voxel_id(next) == get_voxel_id(selected[0]):
+			if not selected.has(next):
+				select_flood(next, selected)
+	
+	return selected
+
+
+# Returns Array of all voxel grid positions connected to given target that aren't obstructed at the given face normal
+# target        :   Vector3          :   Grid position at which to start flood select
+# face_normal   :   Vector3          :   Normal of face to check for obstruction
+# selected      :   Array            :   Array to add selected voxel grid positions to
+# return        :   Array<Vector3>   :   Array of all voxel grid positions connected to given target
+func select_face(target : Vector3, face_normal : Vector3, selected := []) -> Array:
+	selected.append(target)
+	
+	for direction in Voxel.Faces[face_normal]:
+		var next = target + direction
+		if get_voxel_id(next) > -1:
+			if get_voxel_id(next + face_normal) == -1:
+				if not selected.has(next):
+					select_face(next, face_normal, selected)
+	
+	return selected
+
+
+# Returns Array of all voxel grid positions connected to given target that are similar and aren't obstructed at the given face normal
+# target        :   Vector3          :   Grid position at which to start flood select
+# face_normal   :   Vector3          :   Normal of face to check for obstruction
+# selected      :   Array            :   Array to add selected voxel grid positions to
+# return        :   Array<Vector3>   :   Array of all voxel grid positions connected to given target
+func select_face_similar(target : Vector3, face_normal : Vector3, selected := []) -> Array:
+	selected.append(target)
+	
+	for direction in Voxel.Faces[face_normal]:
+		var next = target + direction
+		if get_voxel_id(next) == get_voxel_id(selected[0]):
+			if get_voxel_id(next + face_normal) == -1:
+				if not selected.has(next):
+					select_face_similar(next, face_normal, selected)
+	
+	return selected
+
+
+# Loads and sets voxels and replaces VoxelSet with given file
+# NOTE: Reference Reader.gd for valid file imports
+# source_file     :   String   :   Path to file to be loaded
+# new_voxel_set   :   bool     :   If true new VoxelSet is created, else overwrite current one
+# return int      :   int      :   Error code
+func load_file(source_file : String, new_voxel_set := true) -> int:
+	var read := Reader.read_file(source_file)
+	var error : int = read.get("error", FAILED)
+	if error == OK:
+		if new_voxel_set or not is_instance_valid(voxel_set):
+			set_voxel_set(VoxelSet.new(), false)
+		voxel_set.set_voxels(read["palette"])
+		
+		set_voxels(read["voxels"])
+	return error
+
+
+# Makes a naive mesh out of volume of voxels given
+# volume   :   Array<Vector3>    :   Array of grid positions representing volume of voxels from which to buid ArrayMesh
+# vt       :   VoxelTool         :   VoxelTool with which ArrayMesh will be built
+# return   :   ArrayMesh         :   Naive voxel mesh
+func naive_volume(volume : Array, vt := VoxelTool.new()) -> ArrayMesh:
+	if not is_instance_valid(voxel_set):
+		return null
+	
+	vt.begin(voxel_set, uv_map)
+	
+	for position in volume:
+		for direction in Voxel.Faces:
+			if get_voxel_id(position + direction) == -1:
+				vt.add_face(get_voxel(position), direction, position)
+	
+	return vt.commit()
+
+
+# Greedy meshing
+# volume   :   Array<Vector3>   :   Array of grid positions representing volume of voxels from which to buid ArrayMesh
+# vt       :   VoxelTool        :   VoxelTool with which ArrayMesh will be built
+# return   :   ArrayMesh        :   Greedy voxel mesh
+func greed_volume(volume : Array, vt := VoxelTool.new()) -> ArrayMesh:
+	if not is_instance_valid(voxel_set):
+		return null
+	
+	vt.begin(voxel_set, uv_map)
+	
+	var faces = Voxel.Faces.duplicate()
+	for face in faces:
+		faces[face] = []
+		for position in volume:
+			if get_voxel_id(position + face) == -1:
+				faces[face].append(position)
+	
+	for face in faces:
+		while not faces[face].empty():
+			var bottom_right : Vector3 = faces[face].pop_front()
+			var bottom_left : Vector3 = bottom_right
+			var top_right : Vector3 = bottom_right
+			var top_left : Vector3 = bottom_right
+			var voxel : Dictionary = get_voxel(bottom_right)
+			
+			
+			if not uv_map or Voxel.get_face_uv(voxel, face) == -Vector2.ONE:
+				var width := 1
+				
+				while true:
+					var index = faces[face].find(top_right + Voxel.Faces[face][1])
+					if index > -1:
+						var _voxel = get_voxel(faces[face][index])
+						if Voxel.get_face_color(_voxel, face) == Voxel.get_face_color(voxel, face) and (not uv_map or Voxel.get_face_uv(_voxel, face) == -Vector2.ONE):
+							width += 1
+							faces[face].remove(index)
+							top_right += Voxel.Faces[face][1]
+							bottom_right += Voxel.Faces[face][1]
+						else:
+							break
+					else:
+						break
+				
+				while true:
+					var index = faces[face].find(top_left + Voxel.Faces[face][0])
+					if index > -1:
+						var _voxel = get_voxel(faces[face][index])
+						if Voxel.get_face_color(_voxel, face) == Voxel.get_face_color(voxel, face) and (not uv_map or Voxel.get_face_uv(_voxel, face) == -Vector2.ONE):
+							width += 1
+							faces[face].remove(index)
+							top_left += Voxel.Faces[face][0]
+							bottom_left += Voxel.Faces[face][0]
+						else:
+							break
+					else:
+						break
+				
+				while true:
+					var used := []
+					var current := top_right
+					var index = faces[face].find(current + Voxel.Faces[face][3])
+					if index > -1:
+						var _voxel = get_voxel(faces[face][index])
+						if Voxel.get_face_color(_voxel, face) == Voxel.get_face_color(voxel, face) and (not uv_map or Voxel.get_face_uv(_voxel, face) == -Vector2.ONE):
+							current += Voxel.Faces[face][3]
+							used.append(current)
+							while true:
+								index = faces[face].find(current + Voxel.Faces[face][0])
+								if index > -1:
+									_voxel = get_voxel(faces[face][index])
+									if Voxel.get_face_color(_voxel, face) == Voxel.get_face_color(voxel, face) and (not uv_map or Voxel.get_face_uv(_voxel, face) == -Vector2.ONE):
+										current += Voxel.Faces[face][0]
+										used.append(current)
+									else:
+										break
+								else:
+									break
+							if used.size() == width:
+								top_right += Voxel.Faces[face][3]
+								top_left += Voxel.Faces[face][3]
+								for use in used:
+									faces[face].erase(use)
+							else:
+								break
+						else:
+							break
+					else:
+						break
+				
+				while true:
+					var used := []
+					var current := bottom_right
+					var index = faces[face].find(current + Voxel.Faces[face][2])
+					if index > -1:
+						var _voxel = get_voxel(faces[face][index])
+						if Voxel.get_face_color(_voxel, face) == Voxel.get_face_color(voxel, face) and (not uv_map or Voxel.get_face_uv(_voxel, face) == -Vector2.ONE):
+							current += Voxel.Faces[face][2]
+							used.append(current)
+							while true:
+								index = faces[face].find(current + Voxel.Faces[face][0])
+								if index > -1:
+									_voxel = get_voxel(faces[face][index])
+									if Voxel.get_face_color(_voxel, face) == Voxel.get_face_color(voxel, face) and (not uv_map or Voxel.get_face_uv(_voxel, face) == -Vector2.ONE):
+										current += Voxel.Faces[face][0]
+										used.append(current)
+									else:
+										break
+								else:
+									break
+							if used.size() == width:
+								bottom_right += Voxel.Faces[face][2]
+								bottom_left += Voxel.Faces[face][2]
+								for use in used:
+									faces[face].erase(use)
+							else:
+								break
+						else:
+							break
+					else:
+						break
+			
+			vt.add_face(voxel,face,
+					bottom_right, bottom_left, top_right, top_left)
+	
+	return vt.commit()
+
+
+# Updates Mesh and calls on save and update_static_body if needed
+# save   :   bool   :   Save voxels on update
+func update_mesh() -> void:
+	update_static_body()
+
+
+# Sets and updates StaticMesh if demanded
+func update_static_body() -> void:
+	pass