render_node_pool.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
var parent:Control = null
var pools := {}
var used_counts := {}
var render_index := 0
var total_acquired:int = 0
var total_created:int = 0
var total_reused:int = 0
var pass_acquired:int = 0
var pass_created:int = 0
var pass_reused:int = 0
var last_hidden:int = 0
 
 
func begin(next_parent:Control) -> void:
    parent = next_parent
    used_counts.clear()
    render_index = 0
    pass_acquired = 0
    pass_created = 0
    pass_reused = 0
    last_hidden = 0
 
 
func end() -> void:
    for key in pools.keys():
        var bucket = pools[key]
        if not bucket is Array:
            continue
        var used = int(used_counts.get(key, 0))
        for index in range(used, bucket.size()):
            var node = bucket[index]
            if node is CanvasItem:
                node.visible = false
                last_hidden += 1
 
 
func rect(rect:Rect2, color:Color, name_prefix:String = "Rect") -> ColorRect:
    var node = _acquire("rect:%s" % name_prefix, name_prefix, func():
        var created = ColorRect.new()
        created.mouse_filter = Control.MOUSE_FILTER_IGNORE
        return created
    ) as ColorRect
    node.color = color
    _apply_control_rect(node, rect)
    return node
 
 
func sprite(sprite_manager, sprite_id:String, rect:Rect2, name_prefix:String = "Sprite", options:Dictionary = {}) -> TextureRect:
    if sprite_id == "" or sprite_manager == null:
        return null
    var key = "sprite:%s:%s" % [name_prefix, sprite_id]
    var node = _acquire(key, name_prefix, func():
        var created = sprite_manager.create_texture_node(sprite_id, options)
        if created == null:
            return null
        created.mouse_filter = Control.MOUSE_FILTER_IGNORE
        return created
    ) as TextureRect
    if node == null:
        return null
    node.stretch_mode = TextureRect.STRETCH_KEEP_ASPECT_CENTERED
    node.expand_mode = TextureRect.EXPAND_IGNORE_SIZE
    _apply_control_rect(node, rect)
    return node
 
 
func label(rect:Rect2, text:String, name_prefix:String = "Label", options:Dictionary = {}) -> Label:
    var node = _acquire("label:%s" % name_prefix, name_prefix, func():
        var created = Label.new()
        created.mouse_filter = Control.MOUSE_FILTER_IGNORE
        return created
    ) as Label
    node.text = text
    node.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART if bool(options.get("wrap", true)) else TextServer.AUTOWRAP_OFF
    node.clip_text = true
    node.max_lines_visible = int(options.get("max_lines", 4))
    node.horizontal_alignment = int(options.get("horizontal_alignment", HORIZONTAL_ALIGNMENT_LEFT))
    node.vertical_alignment = int(options.get("vertical_alignment", VERTICAL_ALIGNMENT_TOP))
    node.add_theme_font_size_override("font_size", int(options.get("font_size", 12)))
    node.add_theme_color_override("font_color", Color(str(options.get("font_color", "#eef3f8"))))
    if options.has("outline_color"):
        node.add_theme_color_override("font_outline_color", Color(str(options.get("outline_color", "#000000"))))
        node.add_theme_constant_override("outline_size", int(options.get("outline_size", 1)))
    _apply_control_rect(node, rect)
    return node
 
 
func clear() -> void:
    for bucket in pools.values():
        if not bucket is Array:
            continue
        for node in bucket:
            if is_instance_valid(node):
                node.queue_free()
    pools.clear()
    used_counts.clear()
    parent = null
    render_index = 0
    total_acquired = 0
    total_created = 0
    total_reused = 0
    pass_acquired = 0
    pass_created = 0
    pass_reused = 0
    last_hidden = 0
 
 
func get_stats() -> Dictionary:
    var total := 0
    var visible := 0
    for bucket in pools.values():
        if not bucket is Array:
            continue
        total += bucket.size()
        for node in bucket:
            if node is CanvasItem and node.visible:
                visible += 1
    return {
        "pools": pools.size(),
        "nodes": total,
        "visible": visible,
        "hidden_last_pass": last_hidden,
        "pass_acquired": pass_acquired,
        "pass_created": pass_created,
        "pass_reused": pass_reused,
        "total_acquired": total_acquired,
        "total_created": total_created,
        "total_reused": total_reused
    }
 
 
func _acquire(key:String, name_prefix:String, factory:Callable) -> Control:
    if parent == null:
        return null
    var bucket = pools.get(key, [])
    var index = int(used_counts.get(key, 0))
    var node = null
    if index < bucket.size():
        node = bucket[index]
        pass_reused += 1
        total_reused += 1
    else:
        node = factory.call()
        if node == null:
            return null
        bucket.append(node)
        parent.add_child(node)
        pools[key] = bucket
        pass_created += 1
        total_created += 1
    used_counts[key] = index + 1
    pass_acquired += 1
    total_acquired += 1
    node.name = name_prefix if index == 0 else "%s%d" % [name_prefix, index]
    node.visible = true
    node.mouse_filter = Control.MOUSE_FILTER_IGNORE
    if node.get_parent() != parent:
        if node.get_parent() != null:
            node.get_parent().remove_child(node)
        parent.add_child(node)
    parent.move_child(node, min(render_index, parent.get_child_count() - 1))
    render_index += 1
    return node
 
 
func _apply_control_rect(node:Control, rect:Rect2) -> void:
    node.position = rect.position
    node.size = rect.size