sprite_render_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
var draw_calls:int = 0
var sprite_hits:int = 0
var fallbacks:int = 0
var missing:int = 0
var rotated:int = 0
var requests_recorded:int = 0
 
 
 
func draw_sprite(canvas:CanvasItem, sprite_manager, sprite_id:String, rect:Rect2, options:Dictionary = {}) -> bool:
    draw_calls += 1
    if canvas == null or sprite_manager == null or sprite_id == "":
        missing += 1
        _draw_fallback_rect(canvas, rect, options)
        return false
    var metadata = options.get("manifest", {})
    if sprite_manager.has_method("record_sprite_request"):
        sprite_manager.record_sprite_request(sprite_id, metadata if metadata is Dictionary else {})
        requests_recorded += 1
    var texture = sprite_manager.get_texture(sprite_id) if sprite_manager.has_method("get_texture") else null
    if texture == null:
        missing += 1
        _draw_fallback_rect(canvas, rect, options)
        return false
    var modulate:Color = Color(options.get("modulate", Color.WHITE))
    var rotation:float = float(options.get("rotation", 0.0))
    if abs(rotation) > 0.0001:
        rotated += 1
        canvas.draw_set_transform(rect.get_center(), rotation, Vector2.ONE)
        canvas.draw_texture_rect(texture, Rect2(-rect.size * 0.5, rect.size), false, modulate)
        canvas.draw_set_transform(Vector2.ZERO, 0.0, Vector2.ONE)
    else:
        canvas.draw_texture_rect(texture, rect, false, modulate)
    sprite_hits += 1
    return true
 
 
 
func draw_sprite_with_fallback(canvas:CanvasItem, sprite_manager, sprite_ids:Array, rect:Rect2, options:Dictionary = {}) -> bool:
    for sprite_id in sprite_ids:
        if sprite_id == null:
            continue
        var id = str(sprite_id)
        if id == "":
            continue
        var sprite_options = options.duplicate(true)
        sprite_options["draw_fallback"] = false
        if draw_sprite(canvas, sprite_manager, id, rect, sprite_options):
            return true
    _draw_fallback_rect(canvas, rect, options)
    return false
 
 
 
func draw_directional_sprite(canvas:CanvasItem, sprite_manager, sprite_ids:Array, rect:Rect2, direction:Vector2, base_direction:String = "right", options:Dictionary = {}) -> bool:
    var rotation:float = 0.0
    if sprite_manager != null and sprite_manager.has_method("rotation_for_vector"):
        rotation = sprite_manager.rotation_for_vector(direction, base_direction)
    var next_options:Dictionary = options.duplicate(true)
    next_options["rotation"] = rotation + float(options.get("rotation_offset", 0.0))
    return draw_sprite_with_fallback(canvas, sprite_manager, sprite_ids, rect, next_options)
 
 
func _draw_fallback_rect(canvas:CanvasItem, rect:Rect2, options:Dictionary) -> void:
    if canvas == null or not bool(options.get("draw_fallback", true)):
        return
    fallbacks += 1
    canvas.draw_rect(rect, Color(options.get("fallback_color", Color.WHITE)), true)
 
 
 
func reset_stats() -> void:
    draw_calls = 0
    sprite_hits = 0
    fallbacks = 0
    missing = 0
    rotated = 0
    requests_recorded = 0
 
 
 
func get_cache_stats() -> Dictionary:
    return get_stats()
 
 
func get_stats() -> Dictionary:
    return {
        "draw_calls": draw_calls,
        "sprite_hits": sprite_hits,
        "fallbacks": fallbacks,
        "missing": missing,
        "rotated": rotated,
        "requests_recorded": requests_recorded
    }