diff --git a/addons/voronoishatter/plugin.cfg b/addons/voronoishatter/plugin.cfg
new file mode 100644
index 0000000..61ecb53
--- /dev/null
+++ b/addons/voronoishatter/plugin.cfg
@@ -0,0 +1,7 @@
+[plugin]
+
+name="VoronoiShatter"
+description="An easy and dynamic way to create Voronoi fracture geometry for your Godot game."
+author="Robert Varadan"
+version="0.2"
+script="voronoishatterplugin.gd"
diff --git a/addons/voronoishatter/tetrahedron/tetrahedron.gd b/addons/voronoishatter/tetrahedron/tetrahedron.gd
new file mode 100644
index 0000000..02661f9
--- /dev/null
+++ b/addons/voronoishatter/tetrahedron/tetrahedron.gd
@@ -0,0 +1,51 @@
+extends Object
+
+class_name Tetrahedron
+# Use float epsilon consistent with Vector3 precision
+const EPSILON: float = 1e-5
+
+var vertices: Array[Vector3] = []
+var indices: Array[int] = []
+
+func try_calculate_tetrahedron_circumcenter() -> Vector3:
+ if vertices == null or len(vertices) != 4:
+ VoronoiLog.err("try_calculate_tetrahedron_circumcenter: Invalid vertices in input.")
+ return Vector3.INF
+
+ var a: Vector3 = vertices[0]
+ var b: Vector3 = vertices[1]
+ var c: Vector3 = vertices[2]
+ var d: Vector3 = vertices[3]
+
+ # Use coordinates relative to point 'a'. Use float consistently.
+ var ba: Vector3 = b - a
+ var ca: Vector3 = c - a
+ var da: Vector3 = d - a
+
+ # Use length_squared()
+ var len_ba_sq: float = ba.length_squared()
+ var len_ca_sq: float = ca.length_squared()
+ var len_da_sq: float = da.length_squared()
+
+ # cross products
+ var cross_cd: Vector3 = ca.cross(da)
+ var cross_db: Vector3 = da.cross(ba)
+ var cross_bc: Vector3 = ba.cross(ca)
+
+ # Scalar triple product (volume related) is float
+ var scalar_triple_product: float = ba.dot(cross_cd)
+
+ # Check for degenerate or near-degenerate tetrahedron
+ if abs(scalar_triple_product) < EPSILON:
+ return Vector3.INF # Return inf for degenerate cases
+
+ # Denominator calculation using float
+ var denominator_inv = 0.5 / scalar_triple_product
+
+ # Calculate offset using float operations
+ var circ_relative: Vector3 = (cross_cd * len_ba_sq + cross_db * len_ca_sq + cross_bc * len_da_sq) * denominator_inv
+
+ # Absolute circumcenter
+ var circumcenter: Vector3 = a + circ_relative
+
+ return circumcenter
diff --git a/addons/voronoishatter/tetrahedron/tetrahedron.gd.uid b/addons/voronoishatter/tetrahedron/tetrahedron.gd.uid
new file mode 100644
index 0000000..f3c7df4
--- /dev/null
+++ b/addons/voronoishatter/tetrahedron/tetrahedron.gd.uid
@@ -0,0 +1 @@
+uid://d1q802ma5r05x
diff --git a/addons/voronoishatter/tools/voronoicollection.gd b/addons/voronoishatter/tools/voronoicollection.gd
new file mode 100644
index 0000000..ef1be06
--- /dev/null
+++ b/addons/voronoishatter/tools/voronoicollection.gd
@@ -0,0 +1,24 @@
+## A simple wrapper node that contains the fractured meshes generated from a VoronoiShatter node.
+@tool
+extends Node3D
+
+class_name VoronoiCollection
+
+@export_tool_button("Create Rigid Bodies", "RigidBody3D") var create_rigid_bodies_callback = create_rigid_bodies
+
+func create_rigid_bodies():
+ for child in get_children():
+ if is_instance_of(child, MeshInstance3D):
+ var mesh_instance: MeshInstance3D = child as MeshInstance3D
+ mesh_instance.create_convex_collision(true, true)
+
+ for maybe_static in mesh_instance.get_children():
+ if is_instance_of(maybe_static, StaticBody3D):
+ var static_body: StaticBody3D = maybe_static
+ var rigid_body = RigidBody3D.new()
+ rigid_body.name = "Rigid_" + mesh_instance.name
+ static_body.replace_by(rigid_body)
+ rigid_body.reparent(self)
+ mesh_instance.reparent(rigid_body)
+ mesh_instance.scale = rigid_body.scale
+ rigid_body.scale = Vector3.ONE
diff --git a/addons/voronoishatter/tools/voronoicollection.gd.uid b/addons/voronoishatter/tools/voronoicollection.gd.uid
new file mode 100644
index 0000000..44a7f9c
--- /dev/null
+++ b/addons/voronoishatter/tools/voronoicollection.gd.uid
@@ -0,0 +1 @@
+uid://btyiucuxdhvig
diff --git a/addons/voronoishatter/tools/voronoicollection.svg b/addons/voronoishatter/tools/voronoicollection.svg
new file mode 100644
index 0000000..29a27f5
--- /dev/null
+++ b/addons/voronoishatter/tools/voronoicollection.svg
@@ -0,0 +1,246 @@
+
+
diff --git a/addons/voronoishatter/tools/voronoicollection.svg.import b/addons/voronoishatter/tools/voronoicollection.svg.import
new file mode 100644
index 0000000..ef6c445
--- /dev/null
+++ b/addons/voronoishatter/tools/voronoicollection.svg.import
@@ -0,0 +1,37 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://d3t3503wmsl6u"
+path="res://.godot/imported/voronoicollection.svg-da84ce0d88770e57a0603d0449c83bbb.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://addons/voronoishatter/tools/voronoicollection.svg"
+dest_files=["res://.godot/imported/voronoicollection.svg-da84ce0d88770e57a0603d0449c83bbb.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1
+svg/scale=1.0
+editor/scale_with_editor_scale=false
+editor/convert_colors_with_editor_theme=false
diff --git a/addons/voronoishatter/tools/voronoishatter.gd b/addons/voronoishatter/tools/voronoishatter.gd
new file mode 100644
index 0000000..8a839db
--- /dev/null
+++ b/addons/voronoishatter/tools/voronoishatter.gd
@@ -0,0 +1,211 @@
+## The editor node that allows you to shatter a MeshInstance3D.
+@tool
+@icon("res://addons/voronoishatter/tools/voronoishatter.svg")
+extends Node3D
+
+class_name VoronoiShatter
+
+@export_tool_button("Generate Fracture Meshes", "MeshInstance3D") var execute_action = execute
+
+@export_category("Materials")
+## Randomly assign color to each resulting fracture mesh (ignoring any other materials). Good for previewing the fractures.
+@export var random_color: bool = true:
+ set(value):
+ random_color = value
+ notify_property_list_changed()
+
+var _inherit_outer_material := false
+## Inherit the target mesh's surface materials
+@export var inherit_outer_material: bool:
+ get: return _inherit_outer_material
+ set(value):
+ _inherit_outer_material = value
+ notify_property_list_changed()
+## This material is applied to all clipped/original surfaces
+@export var outer_material: StandardMaterial3D
+## This material applies to the inner surfaces within the volume
+@export var inner_material: StandardMaterial3D
+
+@export_category("Structure")
+## The number of samples used to determine the fracture points. Lower samples = bigger pieces (and faster generation). However, a < ~6 sample-size may lead to missing pieces.
+@export_range(1, 1024, 1, "hide_slider") var samples: int = 32:
+ set(value):
+ samples = value
+ refresh_view()
+
+## The random seed used to generate the samples.
+@export var seed: int = 0:
+ set(value):
+ seed = value
+ refresh_view()
+
+## Cell scale - change the size of the shape that is actually clipped
+@export
+var cell_scale: float = 1.0
+
+## An optional 3D texture that influences where the samples points are generated.
+@export var sample_texture: Texture3D:
+ set(value):
+ if sample_texture:
+ sample_texture.changed.disconnect(refresh_view)
+
+ sample_texture = value
+ if sample_texture:
+ value.changed.connect(refresh_view)
+
+ refresh_view()
+
+## Randomize the random seed.
+@export_tool_button("Randomize seed", "RandomNumberGenerator") var randomize_seed_action = randomize_seed
+@export_category("Original Mesh")
+## Hide the target mesh after generating the fracture mesh.
+@export var hide_original: bool = true
+## Delete any fracture mesh children of this node before generation.
+@export var delete_existing_fractures: bool = true
+
+const NO_MESH_CHILD = "VoronoiShatter must have a MeshInstance3D as a child."
+func randomize_seed():
+ seed = randi()
+
+var editable_owner: Node
+var voronoi_generator: VoronoiGenerator
+
+func _enter_tree():
+ # Plugin initialization
+ if Engine.is_editor_hint():
+ EditorInterface.get_selection().connect("selection_changed", refresh_view)
+ editable_owner = get_tree().get_edited_scene_root()
+ voronoi_generator = Engine.get_singleton("EditorVoronoiGenerator") as VoronoiGenerator
+
+func _exit_tree() -> void:
+ if Engine.is_editor_hint():
+ EditorInterface.get_selection().disconnect("selection_changed", refresh_view)
+
+func get_target_mesh() -> MeshInstance3D:
+ for child in get_children():
+ if is_instance_of(child, MeshInstance3D):
+ return child
+
+ return null
+
+func execute():
+ started = Time.get_ticks_usec()
+ await get_tree().process_frame
+
+ if delete_existing_fractures:
+ for child in get_children():
+ if is_instance_of(child, VoronoiCollection):
+ child.queue_free()
+
+ generate_fracture_meshes(get_config())
+
+var current_collection
+var started = null
+
+func generate_fracture_meshes(config: VoronoiGeneratorConfig):
+ var target = get_target_mesh()
+ if not target:
+ VoronoiLog.err(NO_MESH_CHILD)
+ return
+
+ VoronoiLog.log("Creating Voronoi geometry for %s..." % target.name)
+
+ # Create the parent node collection
+ current_collection = VoronoiCollection.new()
+ current_collection.set_block_signals(true)
+ current_collection.name = "Fractured_" + target.name + "_" + str(Time.get_ticks_msec())
+ add_child(current_collection)
+ current_collection.set_owner(owner)
+
+ if hide_original:
+ target.visible = false
+
+ var results := voronoi_generator.create_from_mesh(target, config)
+ for result in results:
+ create_from_voronoi_mesh(result)
+ VoronoiLog.log("Completed in " + str((Time.get_ticks_usec() - started) / 10e5) + " seconds")
+ current_collection.set_block_signals(false)
+
+func create_from_voronoi_mesh(voronoi_mesh: VoronoiMesh):
+ if voronoi_mesh == null:
+ VoronoiLog.err("Skipping creation of null mesh")
+
+ var mesh_instance = MeshInstance3D.new()
+ mesh_instance.set_block_signals(true)
+ var target = get_target_mesh()
+ var mesh = voronoi_mesh.mesh
+ mesh_instance.scale = target.scale
+ mesh_instance.name = "FracturedPiece_" + str(mesh.get_rid())
+ mesh_instance.mesh = mesh
+ mesh_instance.position -= voronoi_mesh.position * target.scale
+ mesh_instance.scale = Vector3.ONE * cell_scale
+
+ var has_outside_faces = mesh_instance.mesh.get_surface_count() > 1
+
+ if random_color:
+ var random_color: Color = Color(randf(), randf(), randf())
+ for surface in range(mesh_instance.mesh.get_surface_count()):
+ var material = StandardMaterial3D.new()
+ material.albedo_color = random_color
+
+ mesh_instance.mesh.surface_set_material(surface, material)
+ else:
+ if has_outside_faces:
+ if not inherit_outer_material:
+ for surface_id in range(1, mesh_instance.mesh.get_surface_count()):
+ mesh_instance.mesh.surface_set_material(surface_id, outer_material)
+
+ if inner_material:
+ mesh_instance.mesh.surface_set_material(0, inner_material)
+
+ call_deferred("_deferred_add_child", mesh_instance)
+
+func _deferred_add_child(mesh_instance: MeshInstance3D):
+ current_collection.add_child(mesh_instance)
+ mesh_instance.set_owner(owner)
+ mesh_instance.set_block_signals(false)
+
+func get_config() -> VoronoiGeneratorConfig:
+ var config = VoronoiGeneratorConfig.new()
+ config.num_samples = samples
+ config.random_seed = seed
+ config.texture = sample_texture
+ return config
+
+# INTERNAL FUNCTIONS - for showing things in the editor, e.g.
+var sample_visualizers: Array[CSGSphere3D] = []
+
+func refresh_view():
+ if not Engine.is_editor_hint() or not is_instance_valid(voronoi_generator):
+ return
+
+ for visualizer in sample_visualizers:
+ visualizer.queue_free()
+
+ sample_visualizers = []
+
+ var target = get_target_mesh()
+ if not EditorInterface.get_selection().get_selected_nodes().has(self) or not target:
+ return
+
+ var config = get_config()
+ var material = StandardMaterial3D.new()
+ material.albedo_color = Color.RED
+ material.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED
+ material.disable_receive_shadows = true
+
+ for sample in voronoi_generator.sample_points(target.mesh, config):
+ var sphere = CSGSphere3D.new()
+ sphere.set_block_signals(true)
+ sphere.material = material
+ sphere.radius = 0.02
+ sphere.rings = 4
+ sphere.radial_segments = 4
+ sphere.position = sample + target.position
+ sphere.cast_shadow = false
+ sample_visualizers += [sphere]
+ add_child(sphere)
+
+func _get_configuration_warnings():
+ if not get_target_mesh():
+ return [NO_MESH_CHILD]
diff --git a/addons/voronoishatter/tools/voronoishatter.gd.uid b/addons/voronoishatter/tools/voronoishatter.gd.uid
new file mode 100644
index 0000000..9438325
--- /dev/null
+++ b/addons/voronoishatter/tools/voronoishatter.gd.uid
@@ -0,0 +1 @@
+uid://da087cg46iawj
diff --git a/addons/voronoishatter/tools/voronoishatter.svg b/addons/voronoishatter/tools/voronoishatter.svg
new file mode 100644
index 0000000..804dbc6
--- /dev/null
+++ b/addons/voronoishatter/tools/voronoishatter.svg
@@ -0,0 +1,174 @@
+
+
diff --git a/addons/voronoishatter/tools/voronoishatter.svg.import b/addons/voronoishatter/tools/voronoishatter.svg.import
new file mode 100644
index 0000000..98e335e
--- /dev/null
+++ b/addons/voronoishatter/tools/voronoishatter.svg.import
@@ -0,0 +1,37 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://cbqj0ybncmmf4"
+path="res://.godot/imported/voronoishatter.svg-5b600ca359f1e12281bb947272031af7.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://addons/voronoishatter/tools/voronoishatter.svg"
+dest_files=["res://.godot/imported/voronoishatter.svg-5b600ca359f1e12281bb947272031af7.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1
+svg/scale=1.0
+editor/scale_with_editor_scale=false
+editor/convert_colors_with_editor_theme=false
diff --git a/addons/voronoishatter/voronoi/model/voronoicell.gd b/addons/voronoishatter/voronoi/model/voronoicell.gd
new file mode 100644
index 0000000..0941afc
--- /dev/null
+++ b/addons/voronoishatter/voronoi/model/voronoicell.gd
@@ -0,0 +1,10 @@
+## Represents a voronoi "cell," a collection of vertices (Vector3) that are associated with a sample site
+extends Object
+
+class_name VoronoiCell
+
+var vertices: Array[Vector3] = []
+var site: Vector3
+
+func is_valid() -> bool:
+ return len(vertices) >= 4
diff --git a/addons/voronoishatter/voronoi/model/voronoicell.gd.uid b/addons/voronoishatter/voronoi/model/voronoicell.gd.uid
new file mode 100644
index 0000000..e6e78ce
--- /dev/null
+++ b/addons/voronoishatter/voronoi/model/voronoicell.gd.uid
@@ -0,0 +1 @@
+uid://dx5577o370jiw
diff --git a/addons/voronoishatter/voronoi/model/voronoigeneratorconfig.gd b/addons/voronoishatter/voronoi/model/voronoigeneratorconfig.gd
new file mode 100644
index 0000000..773f241
--- /dev/null
+++ b/addons/voronoishatter/voronoi/model/voronoigeneratorconfig.gd
@@ -0,0 +1,11 @@
+## Configuration options for using VoronoiGenerator
+extends Object
+
+class_name VoronoiGeneratorConfig
+
+# The seed influencing sample point placement
+var random_seed: int
+# The number of samples to intersperse in the AABB
+var num_samples: int
+# (optional) A 3D texture to finely control the seed placement
+var texture: Texture3D
\ No newline at end of file
diff --git a/addons/voronoishatter/voronoi/model/voronoigeneratorconfig.gd.uid b/addons/voronoishatter/voronoi/model/voronoigeneratorconfig.gd.uid
new file mode 100644
index 0000000..d9e1dce
--- /dev/null
+++ b/addons/voronoishatter/voronoi/model/voronoigeneratorconfig.gd.uid
@@ -0,0 +1 @@
+uid://cuy041nbmm0nf
diff --git a/addons/voronoishatter/voronoi/model/voronoimesh.gd b/addons/voronoishatter/voronoi/model/voronoimesh.gd
new file mode 100644
index 0000000..c9d5c28
--- /dev/null
+++ b/addons/voronoishatter/voronoi/model/voronoimesh.gd
@@ -0,0 +1,8 @@
+## Represents positioning information, mesh data, and a reference to the original target mesh.
+extends Object
+
+class_name VoronoiMesh
+
+var mesh: ArrayMesh
+var position: Vector3
+var target: MeshInstance3D
diff --git a/addons/voronoishatter/voronoi/model/voronoimesh.gd.uid b/addons/voronoishatter/voronoi/model/voronoimesh.gd.uid
new file mode 100644
index 0000000..6cb16be
--- /dev/null
+++ b/addons/voronoishatter/voronoi/model/voronoimesh.gd.uid
@@ -0,0 +1 @@
+uid://doh2rqeb2qw42
diff --git a/addons/voronoishatter/voronoi/utils/voronoigenerator.gd b/addons/voronoishatter/voronoi/utils/voronoigenerator.gd
new file mode 100644
index 0000000..31b5280
--- /dev/null
+++ b/addons/voronoishatter/voronoi/utils/voronoigenerator.gd
@@ -0,0 +1,250 @@
+## Helper functions to create Voronoi geometry. To use, create a new instance of this node and
+## call create_from_mesh() with a MeshInstance3D and VoronoiGeneratorConfig. The best way to use
+## this is to store it as a singleton instead of creating a new instance each time to avoid the
+## overhead of creating the child node instances.
+
+extends Node
+
+class_name VoronoiGenerator
+# These CSGMesh3Ds are used to efficiently perform the clipping logic seen below.
+var csg_clip = CSGMesh3D.new()
+var csg_mask = CSGMesh3D.new()
+
+func _init() -> void:
+ add_child(csg_clip)
+ csg_clip.add_child(csg_mask)
+ csg_mask.operation = CSGShape3D.OPERATION_INTERSECTION
+
+
+## End-to-end function that samples points, creates tetrahedra, and generates voronoi cells (asyncronously).
+## This is the best way to create fractures from a mesh. REQUIRES THE VoronoiWorker TO WORK!
+## Make sure you listen to the signal as described in README.md.
+func create_from_mesh(mesh: MeshInstance3D, options: VoronoiGeneratorConfig) -> Array[VoronoiMesh]:
+ var points = sample_points(mesh.mesh, options)
+ var tetrahedra = create_delauney_tetrahedra(points)
+ # Dictionary[Vector3, int]
+ var point_to_index_map: Dictionary[Vector3, int] = {}
+ for i in range(len(points)):
+ if points[i] not in point_to_index_map:
+ point_to_index_map[points[i]] = i
+
+ return generate_voronoi_cells(mesh, tetrahedra, points, point_to_index_map)
+
+## This function is used to sample points inside a bounding box. These points
+## can be used for Delauney Tetrahedronization.
+func sample_points(mesh: Mesh, options: VoronoiGeneratorConfig) -> Array[Vector3]:
+ var aabb = mesh.get_aabb()
+ var random_seed = options.random_seed
+ var num_samples = options.num_samples
+ var sample_points: Array[Vector3] = []
+ var rng = RandomNumberGenerator.new()
+ var offset = 0
+ var texture3d = options.texture
+
+ # Randomly sample points
+ for i in range(num_samples):
+ # Generate random position in AABB
+ rng.seed = random_seed + offset
+ var x_norm: float = rng.randf()
+ offset += 1
+ rng.seed = random_seed + offset
+ var y_norm: float = rng.randf()
+ offset += 1
+ rng.seed = random_seed + offset
+ var z_norm: float = rng.randf()
+ offset += 1
+
+ var pos_in_aabb = Vector3(x_norm, y_norm, z_norm)
+
+ # If texture3d is provided, use rejection sampling based on texture value
+ if texture3d != null:
+ # Sample the texture at the normalized position (0-1)
+ var texture_value = sample_3d_texture(texture3d, pos_in_aabb)
+
+ # Reject sample if random value is greater than texture value
+ rng.seed = random_seed + offset
+ offset += 1
+ if rng.randf() > texture_value:
+ # Skip this sample and try again
+ i -= 1
+ continue
+
+ # Convert normalized position to world position
+ var x: float = aabb.position.x + x_norm * aabb.size.x
+ var y: float = aabb.position.y + y_norm * aabb.size.y
+ var z: float = aabb.position.z + z_norm * aabb.size.z
+
+ sample_points.append(Vector3(x, y, z))
+
+ # Missing geometry can happen if we don't add the 8 endpoints of the AABB
+ var endpoints: Array[Vector3] = []
+ for i in range(8):
+ endpoints.append(aabb.get_endpoint(i))
+
+ return sample_points + endpoints
+
+## Helper function to sample a Texture3D. Returns value in range 0.0 to 1.0
+func sample_3d_texture(texture: Texture3D, normalized_position: Vector3) -> float:
+ # Ensure position is in 0-1 range
+ var pos = normalized_position.clamp(Vector3.ZERO, Vector3.ONE)
+
+ # Get texture dimensions
+ var width = texture.get_width()
+ var height = texture.get_height()
+ var depth = texture.get_depth()
+
+ # Convert normalized position to texture coordinates
+ var tx = int(pos.x * (width - 1))
+ var ty = int(pos.y * (height - 1))
+ var tz = int(pos.z * (depth - 1))
+
+ # Get color at position
+ var color = texture.get_data()[tz].get_pixel(tx, ty)
+
+ # Use grayscale value (or you could use a specific channel or combination)
+ # Converting color to grayscale using standard luminance formula
+ return color.r * 0.299 + color.g * 0.587 + color.b * 0.114
+
+## Creates a set of tetrahedra from the given point cloud
+func create_delauney_tetrahedra(points: Array[Vector3]) -> Array[Tetrahedron]:
+ var packed_points_array = PackedVector3Array(points)
+ var delauney_indices = Geometry3D.tetrahedralize_delaunay(points)
+
+ if delauney_indices == null or delauney_indices.size() == 0:
+ VoronoiLog.err("Failed to tetrahedralize. This probably means all points are coplanar, e.g. the case of a plane or 2D geometry (this algorithm is meant for 3D shapes).")
+ return []
+
+ var tetrahedra: Array[Tetrahedron] = []
+
+ # Process tetrahedra. Each tetrahedron has 4 points.
+ for i in range(0, delauney_indices.size(), 4):
+ var i0: int = delauney_indices.get(i)
+ var i1: int = delauney_indices.get(i + 1)
+ var i2: int = delauney_indices.get(i + 2)
+ var i3: int = delauney_indices.get(i + 3)
+
+ var v0: Vector3 = points[i0]
+ var v1: Vector3 = points[i1]
+ var v2: Vector3 = points[i2]
+ var v3: Vector3 = points[i3]
+
+ var tetrahedron = Tetrahedron.new()
+ tetrahedron.vertices = [v0, v1, v2, v3] as Array[Vector3]
+ tetrahedron.indices = [i0, i1, i2, i3] as Array[int]
+ tetrahedra += [tetrahedron]
+
+ return tetrahedra
+
+## Create voronoi cell meshes using the circumcenters of the given tetrahedra
+func generate_voronoi_cells(clipping_mesh: MeshInstance3D, tetrahedra: Array[Tetrahedron], points: Array[Vector3], point_index_map: Dictionary) -> Array[VoronoiMesh]:
+ # Map: Site Index -> List of Circumcenters (potential Voronoi cell vertices)
+ # Dictionary[int, Array[Vector3]]
+ var potential_cell_vertices: Dictionary[int, Array] = {}
+
+ for tetrahedron in tetrahedra:
+ var center: Vector3 = tetrahedron.try_calculate_tetrahedron_circumcenter()
+
+ if center != null:
+ for point_index in tetrahedron.indices:
+ # Is this point one of our target Voronoi sites?
+ # Check efficiently if point_index corresponds to a key in point_index_map values
+ # A reverse lookup or checking if points[point_index] is a site is needed.
+ var current_point: Vector3 = points[point_index]
+ # Efficient check if this point is a site
+ if point_index_map.has(current_point):
+ # Get the index used as key for potential_cell_vertices
+ var site_list_index: int = point_index_map[current_point]
+
+ if !potential_cell_vertices.has(site_list_index):
+ potential_cell_vertices[site_list_index] = [] as Array[Vector3]
+
+ potential_cell_vertices[site_list_index] += [center]
+
+ var cells: Array[VoronoiCell] = []
+
+ for key in potential_cell_vertices:
+ var voronoi_cell = VoronoiCell.new()
+
+ # Re-create the aray from the vertices (I know, I know... but the type system is just a bit wonky in GDScript)
+ for vertex in potential_cell_vertices[key]:
+ voronoi_cell.vertices += [vertex] as Array[Vector3]
+ voronoi_cell.site = points[key]
+ cells += [voronoi_cell]
+
+ return create_geometry_from_sites(clipping_mesh, cells)
+
+# Creates Voronoi cells from the given points by clipping them against a given mesh.
+func create_geometry_from_sites(mesh_instance: MeshInstance3D, cells: Array[VoronoiCell]) -> Array[VoronoiMesh]:
+ var voronoi_meshes: Array[VoronoiMesh] = []
+ for cell in cells:
+ # Didn't find enough circumcenters to generate the sites from
+ if not cell.is_valid():
+ continue
+
+ # Some of these circumcenters may be outside the shape of the mesh, so clip them to size
+ var clipped_hull: VoronoiMesh = clip_to_mesh(cell.vertices, mesh_instance.mesh)
+
+ if not clipped_hull:
+ continue
+
+ # Add the clipped mesh as the result
+ voronoi_meshes += [clipped_hull]
+
+ return voronoi_meshes
+
+# Creates a mesh out of the points and clips it against the given mask_mesh
+func clip_to_mesh(points: Array, mask_mesh: Mesh) -> VoronoiMesh:
+ var center = mask_mesh.get_aabb().get_center()
+
+ csg_mask.mesh = mask_mesh
+
+ var shape_3d: ConvexPolygonShape3D = ConvexPolygonShape3D.new()
+ shape_3d.set_points(PackedVector3Array(points))
+ csg_clip.mesh = shape_3d.get_debug_mesh()
+
+ # Now safe to access result
+ csg_clip._update_shape()
+
+ var resulting_mesh: ArrayMesh = csg_clip.bake_static_mesh()
+
+ if not is_instance_valid(resulting_mesh):
+ VoronoiLog.err("ClipCellToMesh: CSG result mesh is invalid for cell centered at %s." % center)
+ return null
+
+ if resulting_mesh.get_surface_count() == 0:
+ return null
+
+ var offset = resulting_mesh.get_aabb().get_center()
+ resulting_mesh = recenter_mesh_origin(resulting_mesh)
+
+ var voronoi_mesh = VoronoiMesh.new()
+ voronoi_mesh.mesh = resulting_mesh
+ voronoi_mesh.position = - offset
+
+ return voronoi_mesh
+
+func recenter_mesh_origin(mesh: ArrayMesh) -> ArrayMesh:
+ var combined_aabb = mesh.get_aabb()
+ var center = combined_aabb.get_center()
+
+ var new_mesh = ArrayMesh.new()
+
+ for surface in range(mesh.get_surface_count()):
+ var arr = mesh.surface_get_arrays(surface)
+ var vertices = arr[Mesh.ARRAY_VERTEX]
+
+ if not len(vertices):
+ continue
+
+ # Offset all vertices by -center
+ for i in range(vertices.size()):
+ vertices[i] -= center
+
+ # Preserve material
+ var material = mesh.surface_get_material(surface)
+
+ # Re-add the adjusted surface to the new mesh
+ new_mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arr)
+ new_mesh.surface_set_material(surface, material)
+
+ return new_mesh
diff --git a/addons/voronoishatter/voronoi/utils/voronoigenerator.gd.uid b/addons/voronoishatter/voronoi/utils/voronoigenerator.gd.uid
new file mode 100644
index 0000000..5457835
--- /dev/null
+++ b/addons/voronoishatter/voronoi/utils/voronoigenerator.gd.uid
@@ -0,0 +1 @@
+uid://dcv358ta48eac
diff --git a/addons/voronoishatter/voronoi/utils/voronoilogger.gd b/addons/voronoishatter/voronoi/utils/voronoilogger.gd
new file mode 100644
index 0000000..a12127f
--- /dev/null
+++ b/addons/voronoishatter/voronoi/utils/voronoilogger.gd
@@ -0,0 +1,12 @@
+# Simple logger wrapper
+extends Object
+
+class_name VoronoiLog
+
+const prefix = "[VoronoiShatter] "
+
+static func err(message: String):
+ printerr(prefix + message)
+
+static func log(message: String):
+ print(prefix + message)
diff --git a/addons/voronoishatter/voronoi/utils/voronoilogger.gd.uid b/addons/voronoishatter/voronoi/utils/voronoilogger.gd.uid
new file mode 100644
index 0000000..9d5d8b5
--- /dev/null
+++ b/addons/voronoishatter/voronoi/utils/voronoilogger.gd.uid
@@ -0,0 +1 @@
+uid://cy4vqubgwpw85
diff --git a/addons/voronoishatter/voronoishatterplugin.gd b/addons/voronoishatter/voronoishatterplugin.gd
new file mode 100644
index 0000000..6ad1723
--- /dev/null
+++ b/addons/voronoishatter/voronoishatterplugin.gd
@@ -0,0 +1,21 @@
+@tool
+extends EditorPlugin
+
+# WORKER_COUNT determines how many threads are in the worker pool used by the VoronoiWorker.
+# I don't really want to make this configurable right now, but if you're seeing this, you can change
+# this number to whatever you want for varying performance needs. :)
+var WORKER_COUNT := 8
+
+func _enter_tree():
+ add_custom_type("VoronoiShatter", "Node3D", preload("res://addons/voronoishatter/tools/voronoishatter.gd"), preload("res://addons/voronoishatter/tools/voronoishatter.svg"))
+ add_custom_type("VoronoiCollection", "Node3D", preload("res://addons/voronoishatter/tools/voronoicollection.gd"), preload("res://addons/voronoishatter/tools/voronoicollection.svg"))
+ var voronoi_generator = VoronoiGenerator.new()
+ Engine.register_singleton("EditorVoronoiGenerator", voronoi_generator)
+
+
+func _exit_tree():
+ remove_custom_type("VoronoiShatter")
+ remove_custom_type("VoronoiCollection")
+ var voronoi_generator = Engine.get_singleton("EditorVoronoiGenerator") as VoronoiGenerator
+ voronoi_generator.queue_free()
+ Engine.unregister_singleton("EditorVoronoiGenerator")
diff --git a/addons/voronoishatter/voronoishatterplugin.gd.uid b/addons/voronoishatter/voronoishatterplugin.gd.uid
new file mode 100644
index 0000000..c368b6a
--- /dev/null
+++ b/addons/voronoishatter/voronoishatterplugin.gd.uid
@@ -0,0 +1 @@
+uid://bhfkx7pbplw1q
diff --git a/buildings/building.gd b/buildings/building.gd
index 58f546a..f104c8c 100644
--- a/buildings/building.gd
+++ b/buildings/building.gd
@@ -8,6 +8,8 @@ extends CollisionObject3D
var shake_duration := 0.
@onready var initial_shaker_pos: Vector3 = %Shaker.position
+signal destroyed_from(global_pos: Vector3)
+
func _ready() -> void:
if randomize_height:
scale.y = randf_range(.5, 1.25)
@@ -37,11 +39,12 @@ func _show_score_label(score: int) -> void:
t.finished.connect(%ScoreLabel.queue_free)
-func hit(_proj: Node3D, damage: float) -> bool:
+func hit(proj: Node3D, damage: float) -> bool:
health -= damage
if health <