fix(studio): Add solid floor collision, live 3D gizmo dragging, inspector property sync, and nudge shortcuts

scripts/studio/gizmos/transform_gizmo_3d.gd

@@ -1,6 +1,8 @@
 class_name TransformGizmo3D
 extends Node3D
 ## Interactive 3D manipulator gizmo supporting Translate, Rotate, and Scale modes with snapping.
+## Renders visually clear axis handles (arrows for move, rings for rotate, cubes for scale)
+## with priority depth rendering and geometric raycast picking.
 
 signal transform_started
 signal transform_updated(mode: String, delta: Variant)
@@ -24,17 +26,26 @@ var _drag_start_pos: Vector3 = Vector3.ZERO
 var _drag_start_rot: Vector3 = Vector3.ZERO
 var _drag_start_scale: Vector3 = Vector3.ONE
 
+# Mode visual root nodes
+var _translate_root: Node3D
+var _rotate_root: Node3D
+var _scale_root: Node3D
+
 
 func _ready() -> void:
 	_build_gizmo_visuals()
+	_update_visual_mode()
 
 
 func attach_to_node(node: Node3D) -> void:
 	target_node = node
-	if target_node != null:
-		visible = true
-		global_position = target_node.global_position
-		global_rotation = target_node.global_rotation
+	if target_node != null and is_instance_valid(target_node):
+		visible = (current_mode != Mode.NONE)
+		position = target_node.position
+		if current_mode == Mode.ROTATE or current_mode == Mode.SCALE:
+			quaternion = target_node.quaternion
+		else:
+			quaternion = Quaternion.IDENTITY
 	else:
 		visible = false
 
@@ -42,6 +53,8 @@ func attach_to_node(node: Node3D) -> void:
 func set_mode(new_mode: Mode) -> void:
 	current_mode = new_mode
 	_update_visual_mode()
+	if target_node != null and is_instance_valid(target_node):
+		attach_to_node(target_node)
 
 
 func set_snap(enabled: bool, translate_step: float = 1.0, rotate_step: float = 15.0) -> void:
@@ -50,63 +63,269 @@ func set_snap(enabled: bool, translate_step: float = 1.0, rotate_step: float = 1
 	snap_rotate_deg = rotate_step
 
 
+func _update_visual_mode() -> void:
+	if _translate_root != null:
+		_translate_root.visible = (current_mode == Mode.TRANSLATE)
+	if _rotate_root != null:
+		_rotate_root.visible = (current_mode == Mode.ROTATE)
+	if _scale_root != null:
+		_scale_root.visible = (current_mode == Mode.SCALE)
+	visible = (target_node != null and current_mode != Mode.NONE)
+
+
+# ── Visual Construction ───────────────────────────────────────────────
+
+func _make_gizmo_mat(color: Color) -> StandardMaterial3D:
+	var mat := StandardMaterial3D.new()
+	mat.albedo_color = color
+	mat.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED
+	mat.no_depth_test = true
+	mat.render_priority = 10
+	return mat
+
+
 func _build_gizmo_visuals() -> void:
-	# Build colored 3D axis handles for X (Red), Y (Green), Z (Blue)
-	var x_mat := StandardMaterial3D.new()
-	x_mat.albedo_color = Color(0.9, 0.2, 0.2)
-	x_mat.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED
+	var x_mat := _make_gizmo_mat(Color(0.95, 0.22, 0.22))
+	var y_mat := _make_gizmo_mat(Color(0.22, 0.90, 0.25))
+	var z_mat := _make_gizmo_mat(Color(0.25, 0.50, 0.98))
+	var center_mat := _make_gizmo_mat(Color(1.0, 0.88, 0.20))
 
-	var y_mat := StandardMaterial3D.new()
-	y_mat.albedo_color = Color(0.2, 0.85, 0.2)
-	y_mat.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED
+	# 1. TRANSLATE Visuals (Arrows + Center Ground Plane Quad)
+	_translate_root = Node3D.new()
+	_translate_root.name = "TranslateRoot"
+	add_child(_translate_root)
 
-	var z_mat := StandardMaterial3D.new()
-	z_mat.albedo_color = Color(0.2, 0.4, 0.95)
-	z_mat.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED
+	_translate_root.add_child(_create_arrow(Vector3(1, 0, 0), x_mat, "ArrowX"))
+	_translate_root.add_child(_create_arrow(Vector3(0, 1, 0), y_mat, "ArrowY"))
+	_translate_root.add_child(_create_arrow(Vector3(0, 0, 1), z_mat, "ArrowZ"))
 
-	# X axis line + arrow
-	var x_axis := _create_axis_cylinder(Vector3(1, 0, 0), x_mat)
-	x_axis.name = "AxisX"
-	add_child(x_axis)
+	# Center ground plane indicator
+	var plane_inst := MeshInstance3D.new()
+	var plane_mesh := BoxMesh.new()
+	plane_mesh.size = Vector3(0.4, 0.02, 0.4)
+	plane_inst.mesh = plane_mesh
+	plane_inst.material_override = center_mat
+	plane_inst.position = Vector3(0.2, 0.01, 0.2)
+	_translate_root.add_child(plane_inst)
 
-	# Y axis line + arrow
-	var y_axis := _create_axis_cylinder(Vector3(0, 1, 0), y_mat)
-	y_axis.name = "AxisY"
-	add_child(y_axis)
+	# 2. ROTATE Visuals (Rings)
+	_rotate_root = Node3D.new()
+	_rotate_root.name = "RotateRoot"
+	add_child(_rotate_root)
 
-	# Z axis line + arrow
-	var z_axis := _create_axis_cylinder(Vector3(0, 0, 1), z_mat)
-	z_axis.name = "AxisZ"
-	add_child(z_axis)
+	_rotate_root.add_child(_create_torus(Vector3.UP, y_mat, "RingYaw"))
+	_rotate_root.add_child(_create_torus(Vector3.RIGHT, x_mat, "RingPitch"))
+	_rotate_root.add_child(_create_torus(Vector3.FORWARD, z_mat, "RingRoll"))
+
+	# 3. SCALE Visuals (Lines + End Cubes)
+	_scale_root = Node3D.new()
+	_scale_root.name = "ScaleRoot"
+	add_child(_scale_root)
+
+	_scale_root.add_child(_create_scale_handle(Vector3(1, 0, 0), x_mat, "ScaleX"))
+	_scale_root.add_child(_create_scale_handle(Vector3(0, 1, 0), y_mat, "ScaleY"))
+	_scale_root.add_child(_create_scale_handle(Vector3(0, 0, 1), z_mat, "ScaleZ"))
+
+	# Center uniform scale cube
+	var center_cube := MeshInstance3D.new()
+	var c_box := BoxMesh.new()
+	c_box.size = Vector3(0.25, 0.25, 0.25)
+	center_cube.mesh = c_box
+	center_cube.material_override = center_mat
+	_scale_root.add_child(center_cube)
 
 
-func _create_axis_cylinder(dir: Vector3, mat: Material) -> Node3D:
+func _create_arrow(dir: Vector3, mat: Material, node_name: String) -> Node3D:
 	var container := Node3D.new()
+	container.name = node_name
+
+	# Shaft
 	var shaft := MeshInstance3D.new()
 	var cyl := CylinderMesh.new()
-	cyl.top_radius = 0.03
-	cyl.bottom_radius = 0.03
-	cyl.height = 1.5
-	cyl.material = mat
+	cyl.top_radius = 0.035
+	cyl.bottom_radius = 0.035
+	cyl.height = 1.3
 	shaft.mesh = cyl
+	shaft.material_override = mat
+
+	# Cone Head
+	var head := MeshInstance3D.new()
+	var cone := CylinderMesh.new()
+	cone.top_radius = 0.0
+	cone.bottom_radius = 0.12
+	cone.height = 0.35
+	head.mesh = cone
+	head.material_override = mat
 
-	# Point cylinder along direction
 	if dir == Vector3(1, 0, 0):
 		shaft.rotation_degrees = Vector3(0, 0, -90)
-		shaft.position = Vector3(0.75, 0, 0)
+		shaft.position = Vector3(0.65, 0, 0)
+		head.rotation_degrees = Vector3(0, 0, -90)
+		head.position = Vector3(1.45, 0, 0)
 	elif dir == Vector3(0, 1, 0):
-		shaft.position = Vector3(0, 0.75, 0)
+		shaft.position = Vector3(0, 0.65, 0)
+		head.position = Vector3(0, 1.45, 0)
 	elif dir == Vector3(0, 0, 1):
 		shaft.rotation_degrees = Vector3(90, 0, 0)
-		shaft.position = Vector3(0, 0, 0.75)
+		shaft.position = Vector3(0, 0, 0.65)
+		head.rotation_degrees = Vector3(90, 0, 0)
+		head.position = Vector3(0, 0, 1.45)
 
 	container.add_child(shaft)
+	container.add_child(head)
 	return container
 
 
-func _update_visual_mode() -> void:
-	visible = (target_node != null and current_mode != Mode.NONE)
+func _create_torus(normal: Vector3, mat: Material, node_name: String) -> Node3D:
+	var inst := MeshInstance3D.new()
+	inst.name = node_name
+	var torus := TorusMesh.new()
+	torus.inner_radius = 1.25
+	torus.outer_radius = 1.35
+	torus.rings = 32
+	torus.ring_segments = 8
+	inst.mesh = torus
+	inst.material_override = mat
 
+	if normal == Vector3.RIGHT:
+		inst.rotation_degrees = Vector3(0, 0, 90)
+	elif normal == Vector3.FORWARD:
+		inst.rotation_degrees = Vector3(90, 0, 0)
+
+	return inst
+
+
+func _create_scale_handle(dir: Vector3, mat: Material, node_name: String) -> Node3D:
+	var container := Node3D.new()
+	container.name = node_name
+
+	# Shaft
+	var shaft := MeshInstance3D.new()
+	var cyl := CylinderMesh.new()
+	cyl.top_radius = 0.035
+	cyl.bottom_radius = 0.035
+	cyl.height = 1.3
+	shaft.mesh = cyl
+	shaft.material_override = mat
+
+	# Cube Tip
+	var tip := MeshInstance3D.new()
+	var box := BoxMesh.new()
+	box.size = Vector3(0.2, 0.2, 0.2)
+	tip.mesh = box
+	tip.material_override = mat
+
+	if dir == Vector3(1, 0, 0):
+		shaft.rotation_degrees = Vector3(0, 0, -90)
+		shaft.position = Vector3(0.65, 0, 0)
+		tip.position = Vector3(1.35, 0, 0)
+	elif dir == Vector3(0, 1, 0):
+		shaft.position = Vector3(0, 0.65, 0)
+		tip.position = Vector3(0, 1.35, 0)
+	elif dir == Vector3(0, 0, 1):
+		shaft.rotation_degrees = Vector3(90, 0, 0)
+		shaft.position = Vector3(0, 0, 0.65)
+		tip.position = Vector3(0, 0, 1.35)
+
+	container.add_child(shaft)
+	container.add_child(tip)
+	return container
+
+
+# ── Geometric Axis Picking ────────────────────────────────────────────
+
+func pick_axis(ray_origin: Vector3, ray_dir: Vector3) -> Axis:
+	if not visible or target_node == null:
+		return Axis.NONE
+
+	var origin := position
+	# 1. Center / Ground plane handle test (radius 0.45)
+	var d_center := _point_to_ray_dist(origin, ray_origin, ray_dir)
+	if d_center < 0.45:
+		return Axis.XY
+
+	match current_mode:
+		Mode.TRANSLATE:
+			var d_x := get_ray_segment_distance(ray_origin, ray_dir, origin, origin + Vector3(1.6, 0, 0))
+			var d_y := get_ray_segment_distance(ray_origin, ray_dir, origin, origin + Vector3(0, 1.6, 0))
+			var d_z := get_ray_segment_distance(ray_origin, ray_dir, origin, origin + Vector3(0, 0, 1.6))
+			var min_d := minf(d_x, minf(d_y, d_z))
+			if min_d < 0.35:
+				if min_d == d_y: return Axis.Y
+				if min_d == d_x: return Axis.X
+				if min_d == d_z: return Axis.Z
+
+		Mode.ROTATE:
+			var d_yaw := _ray_ring_distance(ray_origin, ray_dir, origin, Vector3.UP, 1.3)
+			var d_pitch := _ray_ring_distance(ray_origin, ray_dir, origin, Vector3.RIGHT, 1.3)
+			var d_roll := _ray_ring_distance(ray_origin, ray_dir, origin, Vector3.FORWARD, 1.3)
+			var min_r := minf(d_yaw, minf(d_pitch, d_roll))
+			if min_r < 0.40:
+				if min_r == d_yaw: return Axis.Y
+				if min_r == d_pitch: return Axis.X
+				if min_r == d_roll: return Axis.Z
+
+		Mode.SCALE:
+			var d_x := get_ray_segment_distance(ray_origin, ray_dir, origin, origin + Vector3(1.5, 0, 0))
+			var d_y := get_ray_segment_distance(ray_origin, ray_dir, origin, origin + Vector3(0, 1.5, 0))
+			var d_z := get_ray_segment_distance(ray_origin, ray_dir, origin, origin + Vector3(0, 0, 1.5))
+			var min_d := minf(d_x, minf(d_y, d_z))
+			if min_d < 0.35:
+				if min_d == d_y: return Axis.Y
+				if min_d == d_x: return Axis.X
+				if min_d == d_z: return Axis.Z
+
+	return Axis.NONE
+
+
+static func _point_to_ray_dist(p: Vector3, ray_origin: Vector3, ray_dir: Vector3) -> float:
+	var u := ray_dir.normalized()
+	var to_p := p - ray_origin
+	var proj := to_p.dot(u)
+	if proj < 0.0:
+		return 1e9
+	var closest := ray_origin + u * proj
+	return p.distance_to(closest)
+
+
+static func _ray_ring_distance(ray_origin: Vector3, ray_dir: Vector3, ring_center: Vector3, ring_normal: Vector3, ring_radius: float) -> float:
+	var denom := ray_dir.dot(ring_normal)
+	if absf(denom) < 1e-5:
+		return 1e9
+	var t := (ring_center - ray_origin).dot(ring_normal) / denom
+	if t < 0.0:
+		return 1e9
+	var hit := ray_origin + ray_dir * t
+	var d_from_center := hit.distance_to(ring_center)
+	return absf(d_from_center - ring_radius)
+
+
+static func get_ray_segment_distance(ray_origin: Vector3, ray_dir: Vector3, seg_a: Vector3, seg_b: Vector3) -> float:
+	var u := ray_dir.normalized()
+	var v := seg_b - seg_a
+	var w0 := ray_origin - seg_a
+	var a := u.dot(u)
+	var b := u.dot(v)
+	var c := v.dot(v)
+	var d := u.dot(w0)
+	var e := v.dot(w0)
+	var denom := a * c - b * b
+	var s: float = 0.0
+	var t: float = 0.0
+	if denom > 1e-6:
+		s = (b * e - c * d) / denom
+		t = (a * e - b * d) / denom
+	else:
+		s = 0.0
+		t = e / c if c > 1e-6 else 0.0
+	s = maxf(0.0, s)
+	t = clampf(t, 0.0, 1.0)
+	var pt_ray := ray_origin + u * s
+	var pt_seg := seg_a + v * t
+	return pt_ray.distance_to(pt_seg)
+
+
+# ── Drag Lifecycle (Backwards Compatibility) ──────────────────────────
 
 func start_drag(axis: Axis) -> void:
 	if target_node == null: