added CSG toolkit
This commit is contained in:
522
addons/csg_toolkit/scripts/csg_repeater_3d.gd
Normal file
522
addons/csg_toolkit/scripts/csg_repeater_3d.gd
Normal file
@@ -0,0 +1,522 @@
|
||||
@tool
|
||||
class_name CSGRepeater3D extends CSGCombiner3D
|
||||
|
||||
# NOTE: Registered as custom type in plugin (csg_toolkit.gd) inheriting CSGCombiner3D.
|
||||
# Ensure pattern resource scripts are loaded (Godot should handle via class_name, but we force references for safety):
|
||||
const _REF_GRID = preload("res://addons/csg_toolkit/scripts/patterns/grid_pattern.gd") # ensure subclass scripts loaded
|
||||
const _REF_CIRC = preload("res://addons/csg_toolkit/scripts/patterns/circular_pattern.gd")
|
||||
const _REF_SPIRAL = preload("res://addons/csg_toolkit/scripts/patterns/spiral_pattern.gd")
|
||||
const _REF_NOISE = preload("res://addons/csg_toolkit/scripts/patterns/noise_pattern.gd")
|
||||
|
||||
const REPEATER_NODE_META = "REPEATED_NODE_META"
|
||||
const MAX_INSTANCES = 20000
|
||||
|
||||
var _dirty: bool = false
|
||||
var _template_node_path: NodePath
|
||||
@export var template_node_path: NodePath:
|
||||
get: return _template_node_path
|
||||
set(value):
|
||||
_template_node_path = value
|
||||
_mark_dirty()
|
||||
|
||||
var _template_node_scene: PackedScene
|
||||
@export var template_node_scene: PackedScene:
|
||||
get: return _template_node_scene
|
||||
set(value):
|
||||
_template_node_scene = value
|
||||
_mark_dirty()
|
||||
|
||||
var _hide_template: bool = true
|
||||
@export var hide_template: bool = true:
|
||||
get: return _hide_template
|
||||
set(value):
|
||||
_hide_template = value
|
||||
_update_template_visibility()
|
||||
|
||||
## repeat & spacing removed (migrated into pattern resources)
|
||||
|
||||
@export_group("Pattern Options")
|
||||
# A single exported pattern resource (`pattern`) defines generation behavior.
|
||||
|
||||
|
||||
@export_group("Variation Options")
|
||||
# Rotation variation properties now managed via custom property list for collapsible enable group.
|
||||
var _randomize_rotation: bool = false
|
||||
var randomize_rotation: bool:
|
||||
get: return _randomize_rotation
|
||||
set(value):
|
||||
_randomize_rotation = value
|
||||
_mark_dirty()
|
||||
notify_property_list_changed()
|
||||
|
||||
var _randomize_rot_x: bool = false
|
||||
var randomize_rot_x: bool:
|
||||
get: return _randomize_rot_x
|
||||
set(value):
|
||||
_randomize_rot_x = value
|
||||
if _randomize_rotation: _mark_dirty()
|
||||
notify_property_list_changed()
|
||||
|
||||
var _randomize_rot_y: bool = false
|
||||
var randomize_rot_y: bool:
|
||||
get: return _randomize_rot_y
|
||||
set(value):
|
||||
_randomize_rot_y = value
|
||||
if _randomize_rotation: _mark_dirty()
|
||||
notify_property_list_changed()
|
||||
|
||||
var _randomize_rot_z: bool = false
|
||||
var randomize_rot_z: bool:
|
||||
get: return _randomize_rot_z
|
||||
set(value):
|
||||
_randomize_rot_z = value
|
||||
if _randomize_rotation: _mark_dirty()
|
||||
notify_property_list_changed()
|
||||
|
||||
# Per-axis rotation variance in degrees (0 = full 0..360 random for that axis; >0 jitters around original)
|
||||
var _rotation_variance_x_deg: float = 0.0
|
||||
var rotation_variance_x_deg: float:
|
||||
get: return _rotation_variance_x_deg
|
||||
set(value):
|
||||
_rotation_variance_x_deg = clamp(value, 0.0, 360.0)
|
||||
if _randomize_rotation and _randomize_rot_x: _mark_dirty()
|
||||
|
||||
var _rotation_variance_y_deg: float = 0.0
|
||||
var rotation_variance_y_deg: float:
|
||||
get: return _rotation_variance_y_deg
|
||||
set(value):
|
||||
_rotation_variance_y_deg = clamp(value, 0.0, 360.0)
|
||||
if _randomize_rotation and _randomize_rot_y: _mark_dirty()
|
||||
|
||||
var _rotation_variance_z_deg: float = 0.0
|
||||
var rotation_variance_z_deg: float:
|
||||
get: return _rotation_variance_z_deg
|
||||
set(value):
|
||||
_rotation_variance_z_deg = clamp(value, 0.0, 360.0)
|
||||
if _randomize_rotation and _randomize_rot_z: _mark_dirty()
|
||||
|
||||
var _randomize_scale: bool = false
|
||||
var randomize_scale: bool:
|
||||
get: return _randomize_scale
|
||||
set(value):
|
||||
_randomize_scale = value
|
||||
_mark_dirty()
|
||||
notify_property_list_changed()
|
||||
|
||||
var _scale_variance: float = 0.0
|
||||
var scale_variance: float:
|
||||
get: return _scale_variance
|
||||
set(value):
|
||||
_scale_variance = clamp(value, 0.0, 1.0)
|
||||
if _randomize_scale:
|
||||
_mark_dirty()
|
||||
|
||||
# Per-axis scale variance (if zero => use global variance when axis toggle active)
|
||||
var _scale_variance_x: float = 0.0
|
||||
var scale_variance_x: float:
|
||||
get: return _scale_variance_x
|
||||
set(value):
|
||||
_scale_variance_x = clamp(value, 0.0, 1.0)
|
||||
if _randomize_scale and _randomize_scale_x: _mark_dirty()
|
||||
|
||||
var _scale_variance_y: float = 0.0
|
||||
var scale_variance_y: float:
|
||||
get: return _scale_variance_y
|
||||
set(value):
|
||||
_scale_variance_y = clamp(value, 0.0, 1.0)
|
||||
if _randomize_scale and _randomize_scale_y: _mark_dirty()
|
||||
|
||||
var _scale_variance_z: float = 0.0
|
||||
var scale_variance_z: float:
|
||||
get: return _scale_variance_z
|
||||
set(value):
|
||||
_scale_variance_z = clamp(value, 0.0, 1.0)
|
||||
if _randomize_scale and _randomize_scale_z: _mark_dirty()
|
||||
|
||||
# Per-axis scale randomization toggles (optional – if none enabled acts as uniform variance on all axes)
|
||||
var _randomize_scale_x: bool = false
|
||||
var randomize_scale_x: bool:
|
||||
get: return _randomize_scale_x
|
||||
set(value):
|
||||
_randomize_scale_x = value
|
||||
if _randomize_scale: _mark_dirty()
|
||||
notify_property_list_changed()
|
||||
|
||||
var _randomize_scale_y: bool = false
|
||||
var randomize_scale_y: bool:
|
||||
get: return _randomize_scale_y
|
||||
set(value):
|
||||
_randomize_scale_y = value
|
||||
if _randomize_scale: _mark_dirty()
|
||||
notify_property_list_changed()
|
||||
|
||||
var _randomize_scale_z: bool = false
|
||||
var randomize_scale_z: bool:
|
||||
get: return _randomize_scale_z
|
||||
set(value):
|
||||
_randomize_scale_z = value
|
||||
if _randomize_scale: _mark_dirty()
|
||||
notify_property_list_changed()
|
||||
|
||||
var _position_jitter: float = 0.0
|
||||
@export var position_jitter: float = 0.0:
|
||||
get: return _position_jitter
|
||||
set(value):
|
||||
_position_jitter = max(0.0, value)
|
||||
_mark_dirty()
|
||||
|
||||
var _random_seed: int = 0
|
||||
@export var random_seed: int = 0:
|
||||
get: return _random_seed
|
||||
set(value):
|
||||
_random_seed = value
|
||||
_mark_dirty()
|
||||
|
||||
# Estimated instance count (read-only in inspector; updated internally)
|
||||
@export var estimated_instances: int = 0
|
||||
|
||||
var rng: RandomNumberGenerator
|
||||
var _generation_in_progress := false
|
||||
var _pattern: CSGPattern
|
||||
@export var pattern: CSGPattern:
|
||||
get: return _pattern
|
||||
set(value):
|
||||
if value == _pattern:
|
||||
return
|
||||
# Reject non-CSGPattern resources
|
||||
if value != null and not (value is CSGPattern):
|
||||
push_warning("Assigned pattern is not a CSGPattern-derived resource; ignoring.")
|
||||
return
|
||||
# Prevent assigning the abstract base directly (must use subclass)
|
||||
if value != null and value.get_class() == "CSGPattern":
|
||||
push_warning("Cannot assign base CSGPattern directly. Please use a concrete pattern (Grid, Circular, Spiral...).")
|
||||
return
|
||||
# Disconnect old
|
||||
if _pattern and _pattern.is_connected("changed", Callable(self, "_on_pattern_changed")):
|
||||
_pattern.disconnect("changed", Callable(self, "_on_pattern_changed"))
|
||||
_pattern = value
|
||||
if _pattern and not _pattern.is_connected("changed", Callable(self, "_on_pattern_changed")):
|
||||
_pattern.connect("changed", Callable(self, "_on_pattern_changed"))
|
||||
_mark_dirty()
|
||||
|
||||
func _ready():
|
||||
rng = RandomNumberGenerator.new()
|
||||
# Provide a default pattern if none assigned (through setter for signal wiring).
|
||||
if pattern == null:
|
||||
pattern = CSGGridPattern.new()
|
||||
_mark_dirty()
|
||||
# Generate instances in-game on ready
|
||||
if not Engine.is_editor_hint():
|
||||
call_deferred("repeat_template")
|
||||
|
||||
func _on_pattern_changed():
|
||||
# Called when the assigned pattern resource's exported properties are edited in inspector.
|
||||
_mark_dirty()
|
||||
|
||||
func _process(_delta):
|
||||
if not Engine.is_editor_hint(): return
|
||||
if _dirty and not _generation_in_progress:
|
||||
_dirty = false
|
||||
call_deferred("repeat_template")
|
||||
|
||||
func _exit_tree():
|
||||
# Clean up any remaining repeated nodes
|
||||
clear_children()
|
||||
|
||||
func _mark_dirty():
|
||||
_dirty = true
|
||||
|
||||
func _update_template_visibility():
|
||||
if not is_inside_tree():
|
||||
return
|
||||
var template_node = get_node_or_null(template_node_path)
|
||||
if template_node and template_node is Node3D:
|
||||
template_node.visible = not _hide_template
|
||||
|
||||
func clear_children():
|
||||
# Clear existing children except the template node
|
||||
var children_to_remove = []
|
||||
for child in get_children(true):
|
||||
if child.has_meta(REPEATER_NODE_META):
|
||||
children_to_remove.append(child)
|
||||
# Remove children immediately for better performance
|
||||
for child in children_to_remove:
|
||||
remove_child(child)
|
||||
child.queue_free()
|
||||
|
||||
func repeat_template():
|
||||
if _generation_in_progress:
|
||||
return
|
||||
_generation_in_progress = true
|
||||
clear_children()
|
||||
|
||||
var template_node = get_node_or_null(template_node_path)
|
||||
var using_scene = false
|
||||
# Determine template source
|
||||
if not template_node:
|
||||
if not template_node_scene or not template_node_scene.can_instantiate():
|
||||
_generation_in_progress = false
|
||||
return
|
||||
template_node = template_node_scene.instantiate()
|
||||
using_scene = true
|
||||
add_child(template_node)
|
||||
|
||||
# Use pattern estimation for cap check
|
||||
var template_size := _get_template_size(template_node)
|
||||
var ctx_cap := {"template_size": template_size, "rng": rng, "position_jitter": _position_jitter}
|
||||
var estimate := 0
|
||||
if pattern:
|
||||
estimate = pattern.get_estimated_count(ctx_cap)
|
||||
if estimate <= 1:
|
||||
if using_scene:
|
||||
remove_child(template_node)
|
||||
template_node.queue_free()
|
||||
_generation_in_progress = false
|
||||
return
|
||||
if estimate > MAX_INSTANCES:
|
||||
push_warning("CSGRepeater3D: Estimated count %s exceeds cap %s. Aborting generation." % [estimate, MAX_INSTANCES])
|
||||
_generation_in_progress = false
|
||||
return
|
||||
|
||||
rng.seed = _random_seed
|
||||
# template_size already computed earlier (template_size variable)
|
||||
var positions = _generate_positions(template_size)
|
||||
estimated_instances = positions.size() - 1
|
||||
|
||||
for i in range(positions.size()):
|
||||
var position = positions[i]
|
||||
if i == 0 and position.is_zero_approx():
|
||||
continue
|
||||
var instance = template_node.duplicate()
|
||||
if instance == null:
|
||||
continue
|
||||
instance.set_meta(REPEATER_NODE_META, true)
|
||||
instance.transform.origin = position
|
||||
# Ensure instance is visible regardless of template visibility
|
||||
if instance is Node3D:
|
||||
instance.visible = true
|
||||
_apply_variations(instance)
|
||||
add_child(instance)
|
||||
|
||||
if using_scene:
|
||||
remove_child(template_node)
|
||||
template_node.queue_free()
|
||||
else:
|
||||
_update_template_visibility()
|
||||
_generation_in_progress = false
|
||||
|
||||
func _generate_positions(template_size: Vector3) -> Array:
|
||||
var ctx: Dictionary = {"template_size": template_size, "rng": rng, "position_jitter": _position_jitter}
|
||||
if pattern == null:
|
||||
return []
|
||||
return pattern.generate(ctx)
|
||||
|
||||
|
||||
# -- Geometry-based spacing helpers -------------------------------------------------
|
||||
|
||||
func _get_template_size(template_node: Node) -> Vector3:
|
||||
if template_node == null or not (template_node is Node3D):
|
||||
return Vector3.ONE
|
||||
var aabb := _get_combined_aabb(template_node)
|
||||
var size: Vector3 = aabb.size
|
||||
if size.x <= 0.0001: size.x = 1.0
|
||||
if size.y <= 0.0001: size.y = 1.0
|
||||
if size.z <= 0.0001: size.z = 1.0
|
||||
return size
|
||||
|
||||
func _get_combined_aabb(node: Node) -> AABB:
|
||||
var found := false
|
||||
var combined := AABB()
|
||||
if node is Node3D and node.has_method("get_aabb"):
|
||||
var aabb = node.get_aabb()
|
||||
combined = aabb
|
||||
found = true
|
||||
for child in node.get_children():
|
||||
if child is Node3D:
|
||||
var child_aabb = _get_combined_aabb(child)
|
||||
if child_aabb.size != Vector3.ZERO:
|
||||
if not found:
|
||||
combined = child_aabb
|
||||
found = true
|
||||
else:
|
||||
combined = combined.merge(child_aabb)
|
||||
return combined if found else AABB(Vector3.ZERO, Vector3.ZERO)
|
||||
|
||||
func _apply_material_recursive(node: Node, material: Material):
|
||||
if node is CSGShape3D:
|
||||
node.material_override = material
|
||||
for child in node.get_children():
|
||||
_apply_material_recursive(child, material)
|
||||
|
||||
|
||||
func _apply_variations(instance: Node3D):
|
||||
if _randomize_rotation:
|
||||
var final_rot := instance.rotation
|
||||
if _randomize_rot_x:
|
||||
if _rotation_variance_x_deg > 0.0:
|
||||
final_rot.x += rng.randf_range(-deg_to_rad(_rotation_variance_x_deg), deg_to_rad(_rotation_variance_x_deg))
|
||||
else:
|
||||
final_rot.x = rng.randf() * TAU
|
||||
if _randomize_rot_y:
|
||||
if _rotation_variance_y_deg > 0.0:
|
||||
final_rot.y += rng.randf_range(-deg_to_rad(_rotation_variance_y_deg), deg_to_rad(_rotation_variance_y_deg))
|
||||
else:
|
||||
final_rot.y = rng.randf() * TAU
|
||||
if _randomize_rot_z:
|
||||
if _rotation_variance_z_deg > 0.0:
|
||||
final_rot.z += rng.randf_range(-deg_to_rad(_rotation_variance_z_deg), deg_to_rad(_rotation_variance_z_deg))
|
||||
else:
|
||||
final_rot.z = rng.randf() * TAU
|
||||
instance.rotation = final_rot
|
||||
if _randomize_scale:
|
||||
# If any axis toggles are on, apply independent variance per axis; else uniform.
|
||||
var use_axes = _randomize_scale_x or _randomize_scale_y or _randomize_scale_z
|
||||
if use_axes:
|
||||
var sx = instance.scale.x
|
||||
var sy = instance.scale.y
|
||||
var sz = instance.scale.z
|
||||
if _randomize_scale_x:
|
||||
var vx = (_scale_variance_x if _scale_variance_x > 0.0 else _scale_variance)
|
||||
sx *= max(0.1, 1.0 + rng.randf_range(-vx, vx))
|
||||
if _randomize_scale_y:
|
||||
var vy = (_scale_variance_y if _scale_variance_y > 0.0 else _scale_variance)
|
||||
sy *= max(0.1, 1.0 + rng.randf_range(-vy, vy))
|
||||
if _randomize_scale_z:
|
||||
var vz = (_scale_variance_z if _scale_variance_z > 0.0 else _scale_variance)
|
||||
sz *= max(0.1, 1.0 + rng.randf_range(-vz, vz))
|
||||
instance.scale = Vector3(sx, sy, sz)
|
||||
else:
|
||||
var scale_factor = max(0.1, 1.0 + rng.randf_range(-_scale_variance, _scale_variance))
|
||||
instance.scale *= scale_factor
|
||||
|
||||
func regenerate():
|
||||
_mark_dirty()
|
||||
|
||||
# -- Custom property list (Godot 4.5 group enable support) -------------------------
|
||||
func _get_property_list() -> Array:
|
||||
var props: Array = []
|
||||
|
||||
# Keep default exported properties (engine already exposes them). Only inject
|
||||
# the rotation variation cluster with group enable + subgroup organization.
|
||||
|
||||
# Group header for random rotation feature.
|
||||
# Variation Options parent group
|
||||
props.append({
|
||||
"name": "Variation Options",
|
||||
"type": TYPE_NIL,
|
||||
"usage": PROPERTY_USAGE_GROUP
|
||||
})
|
||||
# Rotation subgroup under Variation Options
|
||||
props.append({
|
||||
"name": "Rotation Randomization",
|
||||
"type": TYPE_NIL,
|
||||
"usage": PROPERTY_USAGE_SUBGROUP
|
||||
})
|
||||
# Enabling checkbox on group header via PROPERTY_HINT_GROUP_ENABLE.
|
||||
props.append({
|
||||
"name": "randomize_rotation",
|
||||
"type": TYPE_BOOL,
|
||||
"usage": PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR,
|
||||
"hint": PROPERTY_HINT_GROUP_ENABLE
|
||||
})
|
||||
# Per-axis random toggles
|
||||
props.append(_prop_bool("randomize_rot_x"))
|
||||
if _randomize_rotation and _randomize_rot_x:
|
||||
props.append({
|
||||
"name": "rotation_variance_x_deg",
|
||||
"type": TYPE_FLOAT,
|
||||
"hint": PROPERTY_HINT_RANGE,
|
||||
"hint_string": "0,360,0.1,degrees",
|
||||
"usage": PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR
|
||||
})
|
||||
props.append(_prop_bool("randomize_rot_y"))
|
||||
if _randomize_rotation and _randomize_rot_y:
|
||||
props.append({
|
||||
"name": "rotation_variance_y_deg",
|
||||
"type": TYPE_FLOAT,
|
||||
"hint": PROPERTY_HINT_RANGE,
|
||||
"hint_string": "0,360,0.1,degrees",
|
||||
"usage": PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR
|
||||
})
|
||||
props.append(_prop_bool("randomize_rot_z"))
|
||||
if _randomize_rotation and _randomize_rot_z:
|
||||
props.append({
|
||||
"name": "rotation_variance_z_deg",
|
||||
"type": TYPE_FLOAT,
|
||||
"hint": PROPERTY_HINT_RANGE,
|
||||
"hint_string": "0,360,0.1,degrees",
|
||||
"usage": PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR
|
||||
})
|
||||
|
||||
# Subgroup for locked rotations (should reside inside Rotation Randomization group)
|
||||
# (Locked rotations removed as per user request)
|
||||
|
||||
# Scale variation subgroup under Variation Options
|
||||
props.append({
|
||||
"name": "Scale Variation",
|
||||
"type": TYPE_NIL,
|
||||
"usage": PROPERTY_USAGE_SUBGROUP
|
||||
})
|
||||
props.append({
|
||||
"name": "randomize_scale",
|
||||
"type": TYPE_BOOL,
|
||||
"usage": PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR,
|
||||
"hint": PROPERTY_HINT_GROUP_ENABLE
|
||||
})
|
||||
props.append(_prop_float_range("scale_variance", "0,1,0.01"))
|
||||
props.append(_prop_bool("randomize_scale_x"))
|
||||
if _randomize_scale and _randomize_scale_x:
|
||||
props.append(_prop_float_range("scale_variance_x", "0,1,0.01"))
|
||||
props.append(_prop_bool("randomize_scale_y"))
|
||||
if _randomize_scale and _randomize_scale_y:
|
||||
props.append(_prop_float_range("scale_variance_y", "0,1,0.01"))
|
||||
props.append(_prop_bool("randomize_scale_z"))
|
||||
if _randomize_scale and _randomize_scale_z:
|
||||
props.append(_prop_float_range("scale_variance_z", "0,1,0.01"))
|
||||
|
||||
return props
|
||||
|
||||
func _prop_bool(name: String) -> Dictionary:
|
||||
return {
|
||||
"name": name,
|
||||
"type": TYPE_BOOL,
|
||||
"usage": PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR
|
||||
}
|
||||
|
||||
func _prop_float_deg(name: String, value: float) -> Dictionary:
|
||||
return {
|
||||
"name": name,
|
||||
"type": TYPE_FLOAT,
|
||||
"hint": PROPERTY_HINT_RANGE,
|
||||
"hint_string": "-360,360,0.1,degrees",
|
||||
"usage": PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR
|
||||
}
|
||||
|
||||
func _prop_float_range(name: String, hint_str: String) -> Dictionary:
|
||||
return {
|
||||
"name": name,
|
||||
"type": TYPE_FLOAT,
|
||||
"hint": PROPERTY_HINT_RANGE,
|
||||
"hint_string": hint_str,
|
||||
"usage": PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR
|
||||
}
|
||||
|
||||
func get_instance_count() -> int:
|
||||
if pattern == null:
|
||||
return 0
|
||||
var ctx := {"template_size": Vector3.ONE, "rng": rng, "position_jitter": _position_jitter}
|
||||
return max(0, pattern.get_estimated_count(ctx) - 1)
|
||||
|
||||
func apply_template():
|
||||
if get_child_count() == 0:
|
||||
return
|
||||
var stack = []
|
||||
stack.append_array(get_children())
|
||||
while stack.size() > 0:
|
||||
var node = stack.pop_back()
|
||||
node.set_owner(owner)
|
||||
stack.append_array(node.get_children())
|
||||
|
||||
# Alias for clarity in UI
|
||||
func bake_instances():
|
||||
apply_template()
|
||||
Reference in New Issue
Block a user