358 lines
10 KiB
GDScript
358 lines
10 KiB
GDScript
class_name BubbleButton
|
||
extends Button
|
||
|
||
const ICON_FILL_RATIO: float = 0.76
|
||
const LABELED_ICON_FILL_RATIO: float = 0.58
|
||
const BubbleGradientBackgroundType = preload(
|
||
"res://ui/components/bubble_menu/bubble_gradient_background.gd"
|
||
)
|
||
const BubbleHoverDrawerType = preload(
|
||
"res://ui/components/bubble_menu/bubble_hover_drawer.gd"
|
||
)
|
||
|
||
@export var profile: BubbleMenuProfile
|
||
|
||
@export_group("Authored Layout")
|
||
@export var neutral_size: Vector2 = Vector2(120.0, 116.0)
|
||
@export var desktop_anchor: Vector2 = Vector2.ZERO
|
||
@export var compact_anchor: Vector2 = Vector2.ZERO
|
||
@export var compact_minimum_size: Vector2 = Vector2.ZERO
|
||
|
||
@export_group("Typography")
|
||
@export var label_control_path: NodePath
|
||
@export_range(1, 256, 1) var minimum_font_size: int = 14
|
||
@export_range(1, 256, 1) var maximum_font_size: int = 32
|
||
|
||
@export_group("Icon")
|
||
@export_range(0.0, 1.0, 0.01) var icon_fill_ratio_override: float = 0.0
|
||
|
||
@export_group("Motion")
|
||
@export_range(0.0, 32.0, 0.1) var horizontal_amplitude: float = 1.8
|
||
@export_range(0.0, 32.0, 0.1) var vertical_amplitude: float = 4.0
|
||
@export_range(0.1, 30.0, 0.1) var motion_period: float = 5.0
|
||
@export_range(0.0, TAU, 0.01) var motion_phase: float = 0.0
|
||
@export_range(0.0, 0.2, 0.001) var deformation_amplitude: float = 0.016
|
||
@export_range(0.1, 30.0, 0.1) var deformation_period: float = 6.0
|
||
@export var hover_wiggle_amplitude: Vector2 = Vector2.ZERO
|
||
@export_range(0.1, 30.0, 0.1) var hover_wiggle_period: float = 2.0
|
||
|
||
@export_group("Hover Drawer")
|
||
@export var hover_drawer_text: String = ""
|
||
@export_enum("Right", "Left Vertical") var hover_drawer_mode: int = 0
|
||
@export_range(0.1, 12.0, 0.1) var hover_drawer_speed: float = 4.0
|
||
|
||
@export_group("Hit Area")
|
||
@export var elliptical_hit_area: bool = true
|
||
|
||
var neutral_position: Vector2 = Vector2.ZERO
|
||
var presented_size: Vector2 = Vector2.ZERO
|
||
var emphasis: float = 0.0
|
||
var _hovered: bool = false
|
||
var _drawer_focused: bool = false
|
||
var _drawer_reveal: float = 0.0
|
||
var _gradient_background: BubbleGradientBackground
|
||
var _hover_drawer: BubbleHoverDrawer
|
||
|
||
|
||
func _ready() -> void:
|
||
mouse_entered.connect(_set_hovered.bind(true))
|
||
mouse_exited.connect(_set_hovered.bind(false))
|
||
focus_entered.connect(_set_drawer_focused.bind(true))
|
||
focus_exited.connect(_set_drawer_focused.bind(false))
|
||
resized.connect(_update_pivot)
|
||
_update_pivot()
|
||
apply_profile()
|
||
_apply_icon_presentation(neutral_size)
|
||
_update_hover_drawer()
|
||
|
||
|
||
func _gui_input(event: InputEvent) -> void:
|
||
if _adjustment_direction(self) == 0:
|
||
return
|
||
var direction: int = 0
|
||
if event.is_action_pressed(&"ui_left"):
|
||
direction = -1
|
||
elif event.is_action_pressed(&"ui_right"):
|
||
direction = 1
|
||
if direction == 0:
|
||
return
|
||
var adjustment_button: BaseButton = _find_adjustment_button(direction)
|
||
if adjustment_button == null:
|
||
return
|
||
adjustment_button.pressed.emit()
|
||
accept_event()
|
||
|
||
|
||
func _find_adjustment_button(direction: int) -> BaseButton:
|
||
var parent_node: Node = get_parent()
|
||
if parent_node == null:
|
||
return null
|
||
for child: Node in parent_node.get_children():
|
||
var button := child as BaseButton
|
||
if (
|
||
button != null
|
||
and button.visible
|
||
and not button.disabled
|
||
and _adjustment_direction(button) == direction
|
||
):
|
||
return button
|
||
return null
|
||
|
||
|
||
func _adjustment_direction(button: BaseButton) -> int:
|
||
var descriptions: Array[String] = [
|
||
button.text.strip_edges().to_lower(),
|
||
button.tooltip_text.strip_edges().to_lower(),
|
||
button.accessibility_name.strip_edges().to_lower(),
|
||
]
|
||
for description: String in descriptions:
|
||
if description in ["-", "−", "minus", "decrease"]:
|
||
return -1
|
||
if description in ["+", "plus", "increase"]:
|
||
return 1
|
||
return 0
|
||
|
||
|
||
func apply_layout(
|
||
center: Vector2,
|
||
bubble_size: Vector2,
|
||
font_size_ratio: float,
|
||
) -> void:
|
||
position = center - bubble_size * 0.5
|
||
size = bubble_size
|
||
neutral_position = position
|
||
presented_size = bubble_size
|
||
_update_pivot()
|
||
_apply_icon_presentation(bubble_size)
|
||
if _hover_drawer != null:
|
||
_hover_drawer.refresh_layout()
|
||
var label_control: Control = get_label_control()
|
||
var font_size := clampi(
|
||
roundi(minf(bubble_size.x, bubble_size.y) * font_size_ratio),
|
||
minimum_font_size,
|
||
maximum_font_size
|
||
)
|
||
label_control.add_theme_font_size_override("font_size", font_size)
|
||
|
||
|
||
func get_layout_size(layout_scale: float, compact: bool) -> Vector2:
|
||
var bubble_size: Vector2 = neutral_size * layout_scale
|
||
if compact:
|
||
bubble_size.x = maxf(bubble_size.x, compact_minimum_size.x)
|
||
bubble_size.y = maxf(bubble_size.y, compact_minimum_size.y)
|
||
if _uses_icon_only_presentation():
|
||
var diameter: float = maxf(bubble_size.x, bubble_size.y)
|
||
bubble_size = Vector2(diameter, diameter)
|
||
return bubble_size
|
||
|
||
|
||
func get_authored_anchor(compact: bool) -> Vector2:
|
||
return compact_anchor if compact else desktop_anchor
|
||
|
||
|
||
func get_label_control() -> Control:
|
||
if not label_control_path.is_empty():
|
||
var custom_label := get_node_or_null(label_control_path) as Control
|
||
if custom_label != null:
|
||
return custom_label
|
||
return self
|
||
|
||
|
||
func _uses_icon_only_presentation() -> bool:
|
||
return icon != null and text.is_empty() and label_control_path.is_empty()
|
||
|
||
|
||
func _apply_icon_presentation(bubble_size: Vector2) -> void:
|
||
if icon == null:
|
||
return
|
||
vertical_icon_alignment = VERTICAL_ALIGNMENT_CENTER
|
||
expand_icon = true
|
||
texture_filter = CanvasItem.TEXTURE_FILTER_NEAREST
|
||
var fill_ratio: float = (
|
||
ICON_FILL_RATIO
|
||
if _uses_icon_only_presentation()
|
||
else LABELED_ICON_FILL_RATIO
|
||
)
|
||
if _uses_icon_only_presentation() and icon_fill_ratio_override > 0.0:
|
||
fill_ratio = icon_fill_ratio_override
|
||
add_theme_constant_override(
|
||
"icon_max_width",
|
||
maxi(1, roundi(minf(bubble_size.x, bubble_size.y) * fill_ratio)),
|
||
)
|
||
if not _uses_icon_only_presentation():
|
||
return
|
||
alignment = HORIZONTAL_ALIGNMENT_CENTER
|
||
icon_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
||
|
||
|
||
func advance_emphasis(delta: float) -> void:
|
||
var target: float = 1.0 if _hovered else 0.0
|
||
emphasis = move_toward(
|
||
emphasis,
|
||
target,
|
||
profile.emphasis_speed * delta
|
||
)
|
||
if _gradient_background != null:
|
||
_gradient_background.queue_redraw()
|
||
var drawer_target: float = 1.0 if (_hovered or _drawer_focused) else 0.0
|
||
_drawer_reveal = move_toward(
|
||
_drawer_reveal,
|
||
drawer_target,
|
||
hover_drawer_speed * delta,
|
||
)
|
||
if _hover_drawer != null:
|
||
_hover_drawer.set_reveal(_drawer_reveal)
|
||
|
||
|
||
func reset_hover_presentation() -> void:
|
||
_hovered = false
|
||
_drawer_focused = false
|
||
emphasis = 0.0
|
||
_drawer_reveal = 0.0
|
||
if _gradient_background != null:
|
||
_gradient_background.queue_redraw()
|
||
if _hover_drawer != null:
|
||
_hover_drawer.set_reveal(0.0)
|
||
|
||
|
||
func calculate_target(
|
||
elapsed: float,
|
||
layout_scale: float,
|
||
motion_scale: float,
|
||
) -> Vector2:
|
||
var phase: float = (
|
||
elapsed / motion_period * TAU
|
||
+ motion_phase
|
||
)
|
||
var idle_offset := Vector2(
|
||
sin(phase * 0.73 + motion_phase) * horizontal_amplitude,
|
||
sin(phase) * vertical_amplitude
|
||
) * layout_scale * motion_scale
|
||
var hover_phase: float = elapsed / hover_wiggle_period * TAU
|
||
var hover_offset := Vector2(
|
||
sin(hover_phase),
|
||
sin(hover_phase * 2.0 + motion_phase) * 0.5,
|
||
) * hover_wiggle_amplitude * emphasis * layout_scale * motion_scale
|
||
idle_offset.y -= (
|
||
profile.hover_focus_lift
|
||
* emphasis
|
||
* layout_scale
|
||
)
|
||
return neutral_position + idle_offset + hover_offset
|
||
|
||
|
||
func calculate_visual_scale(
|
||
elapsed: float,
|
||
motion_scale: float,
|
||
) -> Vector2:
|
||
var deformation_phase: float = (
|
||
elapsed / deformation_period * TAU
|
||
+ motion_phase * 1.37
|
||
)
|
||
var deformation_amount: float = (
|
||
sin(deformation_phase)
|
||
* deformation_amplitude
|
||
* motion_scale
|
||
* lerpf(1.0, profile.emphasized_deformation_scale, emphasis)
|
||
)
|
||
if _uses_icon_only_presentation():
|
||
deformation_amount = 0.0
|
||
var hover_scale: float = lerpf(
|
||
1.0,
|
||
profile.hover_focus_scale,
|
||
emphasis
|
||
)
|
||
return Vector2(
|
||
1.0 + deformation_amount,
|
||
1.0 - deformation_amount
|
||
) * hover_scale
|
||
|
||
|
||
func get_visual_radius(visual_scale: Vector2) -> float:
|
||
var visual_size: Vector2 = presented_size * visual_scale
|
||
return (visual_size.x + visual_size.y) * 0.25
|
||
|
||
|
||
func apply_presentation(
|
||
target_position: Vector2,
|
||
visual_scale: Vector2,
|
||
position_weight: float,
|
||
) -> void:
|
||
position = position.lerp(target_position, position_weight)
|
||
scale = visual_scale
|
||
|
||
|
||
func _has_point(point: Vector2) -> bool:
|
||
if not elliptical_hit_area:
|
||
return Rect2(Vector2.ZERO, size).has_point(point)
|
||
var radius: Vector2 = size * 0.5
|
||
if radius.x <= 0.0 or radius.y <= 0.0:
|
||
return false
|
||
var normalized: Vector2 = (point - radius) / radius
|
||
return normalized.length_squared() <= 1.0
|
||
|
||
|
||
func _set_hovered(value: bool) -> void:
|
||
_hovered = value
|
||
if _gradient_background != null:
|
||
_gradient_background.queue_redraw()
|
||
|
||
|
||
func _set_drawer_focused(value: bool) -> void:
|
||
_drawer_focused = value
|
||
|
||
|
||
func _update_pivot() -> void:
|
||
pivot_offset = size * 0.5
|
||
|
||
|
||
func apply_profile() -> void:
|
||
if profile == null:
|
||
return
|
||
_update_gradient_background()
|
||
add_theme_stylebox_override("normal", profile.make_normal_style())
|
||
var hover_style: StyleBoxFlat = profile.make_hover_style()
|
||
add_theme_stylebox_override("hover", hover_style)
|
||
add_theme_stylebox_override("focus", profile.make_normal_style())
|
||
add_theme_stylebox_override("pressed", profile.make_pressed_style())
|
||
add_theme_stylebox_override("disabled", profile.make_disabled_style())
|
||
add_theme_color_override("font_color", profile.text_color)
|
||
add_theme_color_override("font_hover_color", profile.text_hover_color)
|
||
add_theme_color_override("font_focus_color", profile.text_color)
|
||
add_theme_color_override("font_pressed_color", profile.text_pressed_color)
|
||
add_theme_color_override("font_disabled_color", profile.text_disabled_color)
|
||
var label_control: Control = get_label_control()
|
||
if label_control != self:
|
||
label_control.add_theme_color_override("font_color", profile.text_color)
|
||
|
||
|
||
func _update_gradient_background() -> void:
|
||
if not profile.gradient_enabled:
|
||
if _gradient_background != null:
|
||
_gradient_background.queue_free()
|
||
_gradient_background = null
|
||
return
|
||
if _gradient_background == null:
|
||
_gradient_background = BubbleGradientBackgroundType.new()
|
||
_gradient_background.name = "GradientBackground"
|
||
add_child(_gradient_background)
|
||
move_child(_gradient_background, 0)
|
||
_gradient_background.configure(self, profile)
|
||
|
||
|
||
func _update_hover_drawer() -> void:
|
||
if hover_drawer_text.is_empty():
|
||
if _hover_drawer != null:
|
||
_hover_drawer.queue_free()
|
||
_hover_drawer = null
|
||
return
|
||
if _hover_drawer == null:
|
||
_hover_drawer = BubbleHoverDrawerType.new()
|
||
_hover_drawer.name = "HoverDrawer"
|
||
add_child(_hover_drawer)
|
||
move_child(_hover_drawer, 0)
|
||
_hover_drawer.configure(
|
||
self,
|
||
hover_drawer_text,
|
||
hover_drawer_mode as BubbleHoverDrawer.DrawerMode,
|
||
)
|