onscreen_control_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
const DEFAULT_OPTIONS := {
    "visible": true,
    "side": "left",
    "anchor_y": 0.5,
    "margin": 14.0,
    "button_size": Vector2(72, 64),
    "gap": 10.0,
    "opacity": 0.34,
    "fill_parent_height": false,
    "layout": "vertical",
    "analog_position": Vector2(0.16, 0.76),
    "analog_radius": 66.0,
    "analog_knob_radius": 25.0,
    "analog_deadzone": 0.12,
    "analog_axis": "free",
    "repositionable": true,
    "actions": [],
    "action_button_size": Vector2(58, 54),
    "action_margin": 14.0,
    "controls": [
        {"id": "up", "label": "Up", "action": "move_up"},
        {"id": "down", "label": "Down", "action": "move_down"}
    ]
}
 
signal analog_position_changed(position:Vector2)
signal action_pressed(action_id:String)
 
class AnalogPad extends Control:
    signal vector_changed(value:Vector2)
    signal reposition_dragged(relative:Vector2)
    var radius:float = 66.0
    var knob_radius:float = 25.0
    var deadzone:float = 0.12
    var opacity:float = 0.42
    var repositionable:bool = true
    var axis_mode:String = "free"
    var value := Vector2.ZERO
    var active_pointer := -1
    var repositioning := false
 
    func configure(config:Dictionary) -> void:
        radius = maxf(36.0, float(config.get("analog_radius", radius)))
        knob_radius = clampf(float(config.get("analog_knob_radius", knob_radius)), 14.0, radius * 0.55)
        deadzone = clampf(float(config.get("analog_deadzone", deadzone)), 0.0, 0.75)
        opacity = clampf(float(config.get("opacity", opacity)), 0.08, 0.85)
        repositionable = bool(config.get("repositionable", true))
        axis_mode = str(config.get("analog_axis", "free"))
        if axis_mode not in ["free", "vertical", "horizontal"]:
            axis_mode = "free"
        custom_minimum_size = Vector2.ONE * (radius * 2.0 + 56.0)
        size = custom_minimum_size
        mouse_filter = Control.MOUSE_FILTER_STOP
        focus_mode = Control.FOCUS_NONE
        queue_redraw()
 
    func _center() -> Vector2:
        return Vector2.ONE * (radius + 28.0)
 
    func _handle_center() -> Vector2:
        if axis_mode == "vertical":
            return _center() + Vector2(radius * 0.54 + 18.0, -radius - 9.0)
        if axis_mode == "horizontal":
            return _center() + Vector2(radius + 9.0, -radius * 0.54 - 18.0)
        return _center() + Vector2(radius * 0.92, -radius * 0.92)
 
    func _draw() -> void:
        var center := _center()
        if axis_mode == "free":
            draw_circle(center, radius, Color(0.04, 0.08, 0.11, opacity))
            draw_circle(center, radius, Color(0.82, 0.90, 0.92, minf(0.72, opacity + 0.20)), false, 3.0)
            draw_circle(center, radius * deadzone, Color(0.65, 0.76, 0.78, opacity * 0.45), false, 1.0)
        else:
            var half_width := radius * 0.48
            var track_rect := Rect2()
            if axis_mode == "vertical":
                track_rect = Rect2(center - Vector2(half_width, radius), Vector2(half_width * 2.0, radius * 2.0))
            else:
                track_rect = Rect2(center - Vector2(radius, half_width), Vector2(radius * 2.0, half_width * 2.0))
            var track := StyleBoxFlat.new()
            track.bg_color = Color(0.04, 0.08, 0.11, opacity)
            track.border_color = Color(0.82, 0.90, 0.92, minf(0.72, opacity + 0.20))
            track.set_border_width_all(3)
            track.set_corner_radius_all(int(half_width))
            draw_style_box(track, track_rect)
        var knob_center := center + value * (radius - knob_radius * 0.55)
        draw_circle(knob_center, knob_radius, Color(0.65, 0.82, 0.84, minf(0.88, opacity + 0.30)))
        draw_circle(knob_center, knob_radius, Color(1, 1, 1, minf(0.9, opacity + 0.35)), false, 2.0)
        if repositionable:
            var handle := _handle_center()
            draw_circle(handle, 14.0, Color(0.08, 0.13, 0.18, minf(0.86, opacity + 0.28)))
            for offset in [Vector2(-4,-4), Vector2(4,-4), Vector2(-4,4), Vector2(4,4)]:
                draw_circle(handle + offset, 1.7, Color(1, 1, 1, 0.82))
 
    func _gui_input(event:InputEvent) -> void:
        if event is InputEventScreenTouch:
            if event.pressed and active_pointer < 0:
                active_pointer = event.index
                _begin_pointer(event.position)
            elif not event.pressed and event.index == active_pointer:
                _end_pointer()
            accept_event()
        elif event is InputEventScreenDrag and event.index == active_pointer:
            _update_pointer(event.position, event.relative)
            accept_event()
        elif event is InputEventMouseButton and event.button_index == MOUSE_BUTTON_LEFT:
            if event.pressed:
                active_pointer = 0
                _begin_pointer(event.position)
            else:
                _end_pointer()
            accept_event()
        elif event is InputEventMouseMotion and active_pointer == 0 and Input.is_mouse_button_pressed(MOUSE_BUTTON_LEFT):
            _update_pointer(event.position, event.relative)
            accept_event()
 
    func _begin_pointer(local_position:Vector2) -> void:
        repositioning = repositionable and local_position.distance_to(_handle_center()) <= 20.0
        if not repositioning:
            _set_value_from_position(local_position)
 
    func _update_pointer(local_position:Vector2, relative:Vector2) -> void:
        if repositioning:
            reposition_dragged.emit(relative)
        else:
            _set_value_from_position(local_position)
 
    func _end_pointer() -> void:
        active_pointer = -1
        repositioning = false
        _set_value(Vector2.ZERO)
 
    func _set_value_from_position(local_position:Vector2) -> void:
        var raw := (local_position - _center()) / radius
        if axis_mode == "vertical":
            raw.x = 0.0
        elif axis_mode == "horizontal":
            raw.y = 0.0
        var magnitude := minf(1.0, raw.length())
        if magnitude <= deadzone:
            _set_value(Vector2.ZERO)
            return
        var scaled_magnitude := (magnitude - deadzone) / maxf(0.001, 1.0 - deadzone)
        _set_value(raw.normalized() * scaled_magnitude)
 
    func _set_value(next_value:Vector2) -> void:
        if axis_mode == "vertical":
            next_value.x = 0.0
        elif axis_mode == "horizontal":
            next_value.y = 0.0
        value = next_value.limit_length(1.0)
        vector_changed.emit(value)
        queue_redraw()
 
var overlay:Control
var options := DEFAULT_OPTIONS.duplicate(true)
var pressed := {}
var buttons := {}
var queued_presses := []
var analog_pad:AnalogPad
var analog_vector := Vector2.ZERO
var overlays_created:int = 0
var visibility_changes:int = 0
 
 
func attach(parent:Control, next_options:Dictionary = {}) -> Control:
    if overlay != null and is_instance_valid(overlay) and overlay.get_parent() != null:
        overlay.get_parent().remove_child(overlay)
    overlay = create_overlay(next_options)
    parent.add_child(overlay)
    return overlay
 
 
func create_overlay(next_options:Dictionary = {}) -> Control:
    options = DEFAULT_OPTIONS.duplicate(true)
    for key in next_options.keys():
        options[key] = next_options[key]
    pressed.clear()
    buttons.clear()
    queued_presses.clear()
    var root = Control.new()
    overlays_created += 1
    root.name = "OnscreenControls"
    # Empty overlay space must remain transparent to underlying sliders and UI.
    # The analog pad and action buttons still stop their own pointer events.
    root.mouse_filter = Control.MOUSE_FILTER_IGNORE
    root.set_anchors_preset(Control.PRESET_FULL_RECT)
    root.visible = bool(options.get("visible", true))
 
    var pad:Control
    if str(options.get("layout", "vertical")) == "analog":
        analog_pad = AnalogPad.new()
        analog_pad.configure(options)
        analog_pad.vector_changed.connect(func(value): analog_vector = value)
        analog_pad.reposition_dragged.connect(_move_analog_pad)
        pad = analog_pad
    elif str(options.get("layout", "vertical")) == "dpad":
        pad = GridContainer.new()
        pad.set("columns", 3)
    else:
        pad = VBoxContainer.new()
    pad.name = "Pad"
    pad.mouse_filter = Control.MOUSE_FILTER_PASS
    pad.add_theme_constant_override("separation", int(options.get("gap", 10.0)))
    root.add_child(pad)
    _apply_pad_layout(pad)
 
    if str(options.get("layout", "vertical")) == "analog":
        pass
    elif str(options.get("layout", "vertical")) == "dpad":
        _build_dpad(pad)
    else:
        for control in options.get("controls", []):
            var button = _make_button(control)
            pad.add_child(button)
    _build_action_bar(root)
    return root
 
 
func set_visible(enabled:bool) -> void:
    if is_visible() == enabled and bool(options.get("visible", true)) == enabled:
        return
    options["visible"] = enabled
    visibility_changes += 1
    if overlay != null and is_instance_valid(overlay):
        overlay.visible = enabled
    if not enabled:
        pressed.clear()
        queued_presses.clear()
        analog_vector = Vector2.ZERO
        if analog_pad != null and is_instance_valid(analog_pad):
            analog_pad._end_pointer()
 
 
func is_visible() -> bool:
    if overlay == null or not is_instance_valid(overlay):
        return bool(options.get("visible", true))
    return overlay.visible
 
 
func get_axis(negative_id:String = "up", positive_id:String = "down") -> float:
    if str(options.get("layout", "vertical")) == "analog":
        if negative_id == "left" and positive_id == "right":
            return analog_vector.x
        if negative_id == "up" and positive_id == "down":
            return analog_vector.y
    var axis := 0.0
    if bool(pressed.get(negative_id, false)):
        axis -= 1.0
    if bool(pressed.get(positive_id, false)):
        axis += 1.0
    return axis
 
 
func get_vector(left_id:String = "left", right_id:String = "right", up_id:String = "up", down_id:String = "down") -> Vector2:
    if str(options.get("layout", "vertical")) == "analog":
        return analog_vector
    return Vector2(
        get_axis(left_id, right_id),
        get_axis(up_id, down_id)
    )
 
 
 
func consume_vector(left_id:String = "left", right_id:String = "right", up_id:String = "up", down_id:String = "down") -> Vector2:
    while not queued_presses.is_empty():
        var control_id = str(queued_presses.pop_front())
        if control_id == left_id:
            return Vector2.LEFT
        if control_id == right_id:
            return Vector2.RIGHT
        if control_id == up_id:
            return Vector2.UP
        if control_id == down_id:
            return Vector2.DOWN
    return Vector2.ZERO
 
 
func get_state() -> Dictionary:
    return {
        "visible": bool(options.get("visible", true)),
        "side": str(options.get("side", "left")),
        "anchor_y": float(options.get("anchor_y", 0.5)),
        "margin": float(options.get("margin", 14.0)),
        "button_size": options.get("button_size", Vector2(72, 64)),
        "gap": float(options.get("gap", 10.0)),
        "opacity": float(options.get("opacity", 0.34)),
        "fill_parent_height": bool(options.get("fill_parent_height", false)),
        "layout": str(options.get("layout", "vertical")),
        "analog_position": options.get("analog_position", Vector2(0.16, 0.76)),
        "analog_radius": float(options.get("analog_radius", 66.0)),
        "analog_deadzone": float(options.get("analog_deadzone", 0.12)),
        "analog_axis": str(options.get("analog_axis", "free")),
        "actions": options.get("actions", []),
        "controls": options.get("controls", [])
    }
 
 
 
func get_stats() -> Dictionary:
    return {
        "overlays_created": overlays_created,
        "buttons": buttons.size(),
        "analog": 1 if analog_pad != null and is_instance_valid(analog_pad) else 0,
        "analog_strength": analog_vector.length(),
        "queued_presses": queued_presses.size(),
        "visibility_changes": visibility_changes,
        "visible": is_visible()
    }
 
 
func get_cache_stats() -> Dictionary:
    return get_stats()
 
 
func apply_state(state:Dictionary) -> void:
    for key in state.keys():
        options[key] = state[key]
    if overlay != null and is_instance_valid(overlay):
        overlay.visible = bool(options.get("visible", true))
        var pad = overlay.get_node_or_null("Pad")
        if pad != null:
            if pad is AnalogPad:
                pad.configure(options)
            _apply_pad_layout(pad)
            for child in pad.get_children():
                if child is Button:
                    _style_button(child)
 
 
func set_layout(next_options:Dictionary) -> void:
    apply_state(next_options)
 
 
func _make_button(control:Dictionary) -> Button:
    var control_id = str(control.get("id", "control"))
    pressed[control_id] = false
    var button = Button.new()
    button.name = "%sButton" % control_id.capitalize()
    button.text = str(control.get("label", control_id.capitalize()))
    button.focus_mode = Control.FOCUS_NONE
    button.custom_minimum_size = options.get("button_size", Vector2(72, 64))
    if bool(options.get("fill_parent_height", false)):
        button.custom_minimum_size.y = 0
        button.size_flags_vertical = Control.SIZE_EXPAND_FILL
        button.size_flags_horizontal = Control.SIZE_EXPAND_FILL
    button.mouse_filter = Control.MOUSE_FILTER_STOP
    buttons[control_id] = button
    button.button_down.connect(func():
        pressed[control_id] = true
        queued_presses.append(control_id)
    )
    button.button_up.connect(func(): pressed[control_id] = false)
    button.visibility_changed.connect(func():
        if not button.visible:
            pressed[control_id] = false
    )
    _style_button(button)
    return button
 
 
func _build_action_bar(root:Control) -> void:
    var actions:Array = options.get("actions", [])
    if actions.is_empty():
        return
    var bar := HBoxContainer.new()
    bar.name = "ActionBar"
    bar.set_anchors_preset(Control.PRESET_BOTTOM_RIGHT)
    bar.add_theme_constant_override("separation", int(options.get("gap", 10.0)))
    bar.mouse_filter = Control.MOUSE_FILTER_PASS
    root.add_child(bar)
    var button_size:Vector2 = options.get("action_button_size", Vector2(58, 54))
    var gap := float(options.get("gap", 10.0))
    var width:float = button_size.x * float(actions.size()) + gap * float(maxi(0, actions.size() - 1))
    var margin := float(options.get("action_margin", 14.0))
    bar.offset_left = -width - margin
    bar.offset_right = -margin
    bar.offset_top = -button_size.y - margin
    bar.offset_bottom = -margin
    for action in actions:
        if not action is Dictionary:
            continue
        var action_id := str(action.get("id", "action"))
        var button := Button.new()
        button.name = "%sAction" % action_id.capitalize()
        button.text = str(action.get("label", action_id.capitalize()))
        button.tooltip_text = str(action.get("tooltip", button.text))
        button.custom_minimum_size = button_size
        button.focus_mode = Control.FOCUS_NONE
        button.mouse_filter = Control.MOUSE_FILTER_STOP
        var icon_path := str(action.get("icon", ""))
        if icon_path != "" and ResourceLoader.exists(icon_path):
            button.icon = load(icon_path)
            button.text = ""
            button.expand_icon = true
        button.pressed.connect(func(): action_pressed.emit(action_id))
        _style_button(button)
        bar.add_child(button)
 
 
func _build_dpad(pad:Control) -> void:
    var controls_by_id := {}
    for control in options.get("controls", []):
        controls_by_id[str(control.get("id", ""))] = control
    var cells = [
        {}, controls_by_id.get("up", {"id": "up", "label": "Up"}), {},
        controls_by_id.get("left", {"id": "left", "label": "Left"}), {}, controls_by_id.get("right", {"id": "right", "label": "Right"}),
        {}, controls_by_id.get("down", {"id": "down", "label": "Down"}), {}
    ]
    for cell in cells:
        if cell.is_empty():
            var spacer = Control.new()
            spacer.custom_minimum_size = options.get("button_size", Vector2(72, 64))
            pad.add_child(spacer)
        else:
            pad.add_child(_make_button(cell))
 
 
func _apply_pad_layout(pad:Control) -> void:
    if str(options.get("layout", "vertical")) == "analog":
        var position_value:Vector2 = options.get("analog_position", Vector2(0.16, 0.76))
        pad.anchor_left = clampf(position_value.x, 0.0, 1.0)
        pad.anchor_right = pad.anchor_left
        pad.anchor_top = clampf(position_value.y, 0.0, 1.0)
        pad.anchor_bottom = pad.anchor_top
        pad.offset_left = -pad.custom_minimum_size.x * 0.5
        pad.offset_right = pad.custom_minimum_size.x * 0.5
        pad.offset_top = -pad.custom_minimum_size.y * 0.5
        pad.offset_bottom = pad.custom_minimum_size.y * 0.5
        return
    var button_size = options.get("button_size", Vector2(72, 64))
    var controls_count = max(1, options.get("controls", []).size())
    var is_dpad = str(options.get("layout", "vertical")) == "dpad"
    var width = float(button_size.x)
    var height = float(button_size.y) * controls_count + float(options.get("gap", 10.0)) * max(0, controls_count - 1)
    if is_dpad:
        width = float(button_size.x) * 3.0 + float(options.get("gap", 10.0)) * 2.0
        height = float(button_size.y) * 3.0 + float(options.get("gap", 10.0)) * 2.0
    var margin = float(options.get("margin", 14.0))
    var anchor_y = clamp(float(options.get("anchor_y", 0.5)), 0.0, 1.0)
    if bool(options.get("fill_parent_height", false)):
        pad.custom_minimum_size = Vector2(width, 0)
        pad.anchor_top = 0.0
        pad.anchor_bottom = 1.0
        pad.offset_top = margin
        pad.offset_bottom = -margin
    else:
        pad.custom_minimum_size = Vector2(width, height)
        pad.anchor_top = anchor_y
        pad.anchor_bottom = anchor_y
        pad.offset_top = -height * 0.5
        pad.offset_bottom = height * 0.5
    if str(options.get("side", "left")) == "right":
        pad.anchor_left = 1.0
        pad.anchor_right = 1.0
        pad.offset_left = -width - margin
        pad.offset_right = -margin
    else:
        pad.anchor_left = 0.0
        pad.anchor_right = 0.0
        pad.offset_left = margin
        pad.offset_right = margin + width
 
 
func _move_analog_pad(relative:Vector2) -> void:
    if overlay == null or overlay.size.x <= 0.0 or overlay.size.y <= 0.0:
        return
    var position_value:Vector2 = options.get("analog_position", Vector2(0.16, 0.76))
    position_value += Vector2(relative.x / overlay.size.x, relative.y / overlay.size.y)
    var radius_fraction := Vector2(
        analog_pad.custom_minimum_size.x * 0.5 / overlay.size.x,
        analog_pad.custom_minimum_size.y * 0.5 / overlay.size.y
    )
    position_value.x = clampf(position_value.x, radius_fraction.x, 1.0 - radius_fraction.x)
    position_value.y = clampf(position_value.y, radius_fraction.y, 1.0 - radius_fraction.y)
    options["analog_position"] = position_value
    _apply_pad_layout(analog_pad)
    analog_position_changed.emit(position_value)
 
 
func _style_button(button:Button) -> void:
    var opacity = clamp(float(options.get("opacity", 0.34)), 0.05, 0.85)
    button.self_modulate = Color(1, 1, 1, opacity)
    var normal = _make_style(Color(0.08, 0.13, 0.18, 1.0), Color(1.0, 1.0, 1.0, 0.55))
    var hover = _make_style(Color(0.12, 0.20, 0.28, 1.0), Color(1.0, 1.0, 1.0, 0.7))
    var pressed_style = _make_style(Color(0.22, 0.42, 0.58, 1.0), Color(1.0, 1.0, 1.0, 0.85))
    button.add_theme_stylebox_override("normal", normal)
    button.add_theme_stylebox_override("hover", hover)
    button.add_theme_stylebox_override("pressed", pressed_style)
    button.add_theme_stylebox_override("focus", hover)
    button.add_theme_stylebox_override("disabled", normal)
    button.add_theme_color_override("font_color", Color(1, 1, 1, 0.92))
    button.add_theme_color_override("font_hover_color", Color.WHITE)
    button.add_theme_color_override("font_pressed_color", Color.WHITE)
    button.add_theme_font_size_override("font_size", 18)
 
 
func _make_style(fill:Color, border:Color) -> StyleBoxFlat:
    var style = StyleBoxFlat.new()
    style.bg_color = fill
    style.border_color = border
    style.draw_center = true
    style.set_border_width_all(1)
    style.set_corner_radius_all(8)
    style.content_margin_left = 4
    style.content_margin_right = 4
    style.content_margin_top = 4
    style.content_margin_bottom = 4
    return style