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",
    "controls": [
        {"id": "up", "label": "Up", "action": "move_up"},
        {"id": "down", "label": "Down", "action": "move_down"}
    ]
}
 
var overlay:Control
var options := DEFAULT_OPTIONS.duplicate(true)
var pressed := {}
var buttons := {}
var queued_presses := []
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"
    root.mouse_filter = Control.MOUSE_FILTER_PASS
    root.set_anchors_preset(Control.PRESET_FULL_RECT)
    root.visible = bool(options.get("visible", true))
 
    var pad:Control
    if 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")) == "dpad":
        _build_dpad(pad)
    else:
        for control in options.get("controls", []):
            var button = _make_button(control)
            pad.add_child(button)
    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()
 
 
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:
    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:
    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")),
        "controls": options.get("controls", [])
    }
 
 
 
func get_stats() -> Dictionary:
    return {
        "overlays_created": overlays_created,
        "buttons": buttons.size(),
        "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:
            _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_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:
    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 _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