ryan/stickman
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Enhance selection and grid functionality in sandbox stage and gizmos

Browse Source
This commit is contained in:
ryan
2026-08-29 00:18:57 -04:00
parent 2a6b4aa965
commit badff571f0
5 changed files with 128 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files
scripts/stage_gizmos.gd
+59 -34
View File
@@ -1,11 +1,12 @@
class_name StageGizmos
extends Node2D
## StageGizmos - Hover highlight, selection outline and a rotate gizmo for the
## StageGizmos - Hover highlight, selection outlines and a rotate ring for the
## Sandbox Stage Builder (Phase 2).
##
## Translation is done by dragging the object directly (no translate handle);
## only the rotate ring is a dedicated handle. Pure drawing + distance-based
## handle hit-testing (no Area2D). Dragging drives global_position /
## Translation is done by dragging an object directly (no move handle); a drag
## moves the whole multi-selection. The rotate ring only appears when exactly one
## object is selected (rotating a multi-selection isn't useful). Pure drawing +
## distance-based hit-testing (no Area2D). Dragging drives global_position /
## global_rotation so it works for any Node2D. Hidden and disabled in PLAY mode.
const STAGE_SELECTION := preload("res://scripts/stage_selection.gd")
@@ -20,7 +21,7 @@ enum Handle { NONE, TRANSLATE, ROTATE }
# Signals
# ---------------------------------------------------------------------------
signal transform_committed(node: Node2D)
signal transform_committed(nodes: Array[Node2D])
# ---------------------------------------------------------------------------
# Style constants (screen-space px; divided by zoom for world-space drawing)
@@ -47,18 +48,22 @@ var camera: Camera2D = null
var snap_size: float = 0.0
var _enabled: bool = true
var _target: Node2D = null
var _targets: Array[Node2D] = []
var _hovered: Node2D = null
var _dragging: Handle = Handle.NONE
var _drag_last: Vector2 = Vector2.ZERO
var _drag_anchor: Node2D = null
var _rotate_start_rotation: float = 0.0
var _rotate_start_angle: float = 0.0
var _rotate_center: Vector2 = Vector2.ZERO
var _box_rect: Rect2 = Rect2()
# ---------------------------------------------------------------------------
# Public API
# ---------------------------------------------------------------------------
func set_target(node: Node2D) -> void:
_target = node
func set_targets(nodes: Array[Node2D]) -> void:
_targets = nodes.duplicate()
queue_redraw()
@@ -73,20 +78,19 @@ func set_enabled(enabled: bool) -> void:
queue_redraw()
func get_target() -> Node2D:
return _target
func set_box_rect(rect: Rect2) -> void:
_box_rect = rect
queue_redraw()
## Returns ROTATE if the cursor is on the rotate ring of the primary selection.
## Returns ROTATE if the cursor is on the rotate ring (single selection only).
func hit_test(world_pos: Vector2) -> Handle:
if _target == null or not is_instance_valid(_target) or not _enabled:
if not _enabled or _targets.size() != 1:
return Handle.NONE
var rect := STAGE_SELECTION.get_world_aabb(_target)
var target := _targets[0]
if target == null or not is_instance_valid(target):
return Handle.NONE
var rect := STAGE_SELECTION.get_world_aabb(target)
var ring := _rotate_ring_radius(rect)
if absf(world_pos.distance_to(rect.get_center()) - ring) <= ROTATE_RING_TOLERANCE_PX / _zoom():
return Handle.ROTATE
@@ -97,36 +101,53 @@ func hit_test(world_pos: Vector2) -> Handle:
func begin_drag(world_pos: Vector2) -> void:
_dragging = hit_test(world_pos)
_drag_last = world_pos
if _dragging == Handle.ROTATE and _targets.size() == 1 and is_instance_valid(_targets[0]):
_rotate_center = STAGE_SELECTION.get_world_aabb(_targets[0]).get_center()
_rotate_start_rotation = _targets[0].global_rotation
_rotate_start_angle = (world_pos - _rotate_center).angle()
## Begins a translate drag on `node` (used when an object body is clicked).
## Begins a translate drag anchored on `node` (used when an object body is
## clicked). The drag moves the whole current selection (`_targets`); if `node`
## is not currently selected, the drag targets just `node`.
func begin_translate_drag(node: Node2D, world_pos: Vector2) -> void:
_target = node
_drag_anchor = node
if not _targets.has(node):
_targets = [node]
_dragging = Handle.TRANSLATE
_drag_last = world_pos
func drag_to(world_pos: Vector2) -> void:
if _target == null or not is_instance_valid(_target) or _dragging == Handle.NONE:
if _dragging == Handle.NONE or _targets.is_empty():
return
var delta := world_pos - _drag_last
if _dragging == Handle.TRANSLATE:
_target.global_position += delta
if snap_size > 0.0:
_target.global_position = _snap(_target.global_position)
var actual := delta
if snap_size > 0.0 and _drag_anchor != null and is_instance_valid(_drag_anchor):
var old := _drag_anchor.global_position
actual = _snap(old + delta) - old
for node: Node2D in _targets:
if is_instance_valid(node):
node.global_position += actual
elif _dragging == Handle.ROTATE:
var center := STAGE_SELECTION.get_world_aabb(_target).get_center()
var before := (_drag_last - center).angle()
var after := (world_pos - center).angle()
_target.global_rotation += after - before
if _targets.size() == 1 and is_instance_valid(_targets[0]):
var target := _targets[0]
var current_angle := (world_pos - _rotate_center).angle()
var angle_delta := current_angle - _rotate_start_angle
var new_rotation := _rotate_start_rotation + angle_delta
if Input.is_key_pressed(KEY_CTRL):
new_rotation = snappedf(new_rotation, deg_to_rad(15.0))
target.global_rotation = new_rotation
_drag_last = world_pos
queue_redraw()
func end_drag() -> void:
if _dragging != Handle.NONE and _target != null and is_instance_valid(_target):
transform_committed.emit(_target)
if _dragging != Handle.NONE and not _targets.is_empty():
transform_committed.emit(_targets.duplicate())
_dragging = Handle.NONE
_drag_anchor = null
func is_dragging() -> bool:
@@ -137,7 +158,7 @@ func is_dragging() -> bool:
# ---------------------------------------------------------------------------
func _process(_delta: float) -> void:
if _enabled and (_target != null or _hovered != null or _box_rect.has_area()):
if _enabled and (_targets.size() > 0 or _hovered != null or _box_rect.size != Vector2.ZERO):
queue_redraw()
@@ -145,14 +166,18 @@ func _draw() -> void:
if not _enabled:
return
var zoom := _zoom()
if _hovered != null and is_instance_valid(_hovered) and _hovered != _target:
if _hovered != null and is_instance_valid(_hovered) and not _targets.has(_hovered):
draw_rect(STAGE_SELECTION.get_world_aabb(_hovered), HOVER_COLOR, false, HOVER_WIDTH / zoom)
if _target != null and is_instance_valid(_target):
var rect := STAGE_SELECTION.get_world_aabb(_target)
draw_rect(rect, SELECTION_COLOR, false, SELECTION_WIDTH / zoom)
# A selection outline for every selected object.
for node: Node2D in _targets:
if node != null and is_instance_valid(node):
draw_rect(STAGE_SELECTION.get_world_aabb(node), SELECTION_COLOR, false, SELECTION_WIDTH / zoom)
# Rotate ring only for a single selection.
if _targets.size() == 1 and is_instance_valid(_targets[0]):
var rect := STAGE_SELECTION.get_world_aabb(_targets[0])
draw_arc(rect.get_center(), _rotate_ring_radius(rect), 0.0, TAU, 64, ROTATE_COLOR, ROTATE_WIDTH / zoom, true)
if _box_rect.has_area():
draw_rect(_box_rect, HOVER_COLOR, false, HOVER_WIDTH / zoom)
if _box_rect.size != Vector2.ZERO:
draw_rect(_box_rect.abs(), HOVER_COLOR, false, HOVER_WIDTH / zoom)
# ---------------------------------------------------------------------------
# Internal helpers