palette_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
const DataCacheManager = preload("res://scripts/systems/dataCacheManager/data_cache_manager.gd")
 
var palettes := {}
var texture_cache := {}
var data_cache_manager = DataCacheManager.new()
 
 
 
func load_palettes(file_path:String) -> void:
    var data = data_cache_manager.load_json(file_path)
    if not data is Dictionary:
        return
    for palette_id in data.get("palettes", {}).keys():
        palettes[str(palette_id)] = _parse_palette(data["palettes"][palette_id])
 
 
 
func get_palette(palette_id:String) -> Array:
    return palettes.get(palette_id, []).duplicate()
 
 
 
func has_palette(palette_id:String) -> bool:
    return palettes.has(palette_id)
 
 
 
func recolor_image(source_image:Image, source_palette_id:String, target_palette_id:String) -> Image:
    var source_palette = get_palette(source_palette_id)
    var target_palette = get_palette(target_palette_id)
    if source_image == null or source_palette.is_empty() or target_palette.is_empty():
        return source_image
    var limit = min(source_palette.size(), target_palette.size())
    var image = source_image.duplicate()
    for y in range(image.get_height()):
        for x in range(image.get_width()):
            var pixel = image.get_pixel(x, y)
            if pixel.a <= 0.0:
                continue
            var index = _nearest_palette_index(pixel, source_palette, limit)
            var replacement:Color = target_palette[index]
            replacement.a = pixel.a
            image.set_pixel(x, y, replacement)
    return image
 
 
 
func recolor_texture(texture:Texture2D, source_palette_id:String, target_palette_id:String):
    if texture == null:
        return null
    var image = texture.get_image()
    if image == null or image.is_empty():
        return texture
    return ImageTexture.create_from_image(recolor_image(image, source_palette_id, target_palette_id))
 
 
 
func get_recolored_sprite_texture(sprite_manager, sprite_id:String, source_palette_id:String, target_palette_id:String, size:int = 0):
    var cache_key = "%s|%s|%s|%d" % [sprite_id, source_palette_id, target_palette_id, size]
    if texture_cache.has(cache_key):
        return texture_cache[cache_key]
    var texture = sprite_manager.get_scaled_texture(sprite_id, size) if size > 0 else sprite_manager.get_texture(sprite_id)
    var recolored = recolor_texture(texture, source_palette_id, target_palette_id)
    if recolored != null:
        texture_cache[cache_key] = recolored
    return recolored
 
 
 
func get_cache_stats() -> Dictionary:
    return {
        "palettes": palettes.size(),
        "recolored_textures": texture_cache.size(),
        "data_cache_entries": int(data_cache_manager.get_cache_stats().get("entries", 0)),
        "data_cache_hits": int(data_cache_manager.get_cache_stats().get("cache_hits", 0)),
        "data_cache_misses": int(data_cache_manager.get_cache_stats().get("cache_misses", 0))
    }
 
 
 
func clear_cache() -> void:
    texture_cache.clear()
 
 
func _parse_palette(raw_palette) -> Array:
    var parsed := []
    if not raw_palette is Array:
        return parsed
    for value in raw_palette:
        parsed.append(Color(str(value)))
    return parsed
 
 
func _nearest_palette_index(pixel:Color, palette:Array, limit:int) -> int:
    var best_index := 0
    var best_distance := INF
    for i in range(limit):
        var color:Color = palette[i]
        var dr = pixel.r - color.r
        var dg = pixel.g - color.g
        var db = pixel.b - color.b
        var distance = dr * dr + dg * dg + db * db
        if distance < best_distance:
            best_distance = distance
            best_index = i
    return best_index