Paleta UI compartida (sega-cube.pal) i constants semàntiques UiColor (v0.7.1)

source/core/resources/palette_loader.cpp

@@ -0,0 +1,65 @@
+#include "core/resources/palette_loader.hpp"
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <filesystem>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+
+#include "core/rendering/surface.hpp"
+#include "core/resources/resource_helper.hpp"
+
+namespace Resource::PaletteLoader {
+
+    auto parseJasc(const std::vector<std::uint8_t>& bytes) -> Palette {
+        std::string content(bytes.begin(), bytes.end());
+        std::istringstream stream(content);
+        std::string line;
+
+        // Capçalera: "JASC-PAL" / "0100" / count.
+        std::getline(stream, line);
+        if (!line.starts_with("JASC-PAL")) {
+            throw std::runtime_error("PaletteLoader: fitxer no és JASC-PAL");
+        }
+        std::getline(stream, line);  // versió, ignorada per ara
+        std::getline(stream, line);
+        int declared_count = 0;
+        try {
+            declared_count = std::stoi(line);
+        } catch (...) {
+            throw std::runtime_error("PaletteLoader: count JASC-PAL invàlid");
+        }
+
+        Palette palette{};
+        const std::size_t MAX = std::min(static_cast<std::size_t>(declared_count), palette.size());
+        std::size_t i = 0;
+        while (i < MAX && std::getline(stream, line)) {
+            if (line.empty()) { continue; }
+            std::istringstream ls(line);
+            int r = 0;
+            int g = 0;
+            int b = 0;
+            ls >> r >> g >> b;
+            palette[i] = 0xFF000000U | (static_cast<std::uint32_t>(r & 0xFF) << 16) | (static_cast<std::uint32_t>(g & 0xFF) << 8) | static_cast<std::uint32_t>(b & 0xFF);
+            ++i;
+        }
+        return palette;
+    }
+
+    auto loadFromFile(const std::string& file_path) -> Palette {
+        auto ext = std::filesystem::path(file_path).extension().string();
+        std::ranges::transform(ext, ext.begin(), [](unsigned char c) { return std::tolower(c); });
+
+        auto bytes = Resource::Helper::loadFile(file_path);
+        if (bytes.empty()) {
+            throw std::runtime_error("PaletteLoader: no s'ha pogut llegir " + file_path);
+        }
+
+        if (ext == ".pal") { return parseJasc(bytes); }
+        if (ext == ".gif") { return loadPaletteFromGif(file_path); }
+        throw std::runtime_error("PaletteLoader: format de paleta no suportat: " + ext);
+    }
+
+}  // namespace Resource::PaletteLoader

source/core/resources/palette_loader.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "core/rendering/surface.hpp"
+
+namespace Resource::PaletteLoader {
+
+    // Detecta el format pel sufix i retorna una Palette (256 entrades ARGB).
+    // Actualment suporta:
+    //   - ".pal"  → JASC-PAL versió 0100 (plaintext "R G B" per línia).
+    //   - ".gif"  → paleta global del GIF (reutilitza el decoder existent).
+    // Cridar-lo amb un altre sufix llança std::runtime_error.
+    auto loadFromFile(const std::string& file_path) -> Palette;
+
+    // Parser pur del format JASC-PAL, útil si ja es té el contingut en memòria
+    // (p.ex. des d'un resources.pack). No fa I/O.
+    auto parseJasc(const std::vector<std::uint8_t>& bytes) -> Palette;
+
+}  // namespace Resource::PaletteLoader

source/core/resources/resource_cache.cpp

@@ -4,6 +4,7 @@
 #include <iostream>
 #include <stdexcept>
 
+#include "core/resources/palette_loader.hpp"
 #include "core/resources/resource_helper.hpp"
 #include "utils/utils.hpp"
 
@@ -28,6 +29,12 @@ namespace Resource {
         printWithDots("Animation : ", getFileName(file_path), "[ LOADED ]");
     }
 
+    void Cache::loadPalette(const std::string& name, const std::string& file_path) {
+        auto palette = PaletteLoader::loadFromFile(file_path);
+        palettes_.emplace_back(PaletteResource{.name = name, .palette = palette});
+        printWithDots("Palette : ", getFileName(file_path), "[ LOADED ]");
+    }
+
     auto Cache::getSurface(const std::string& name) -> std::shared_ptr<Surface> {
         auto it = std::ranges::find_if(surfaces_, [&name](const auto& s) { return s.name == name; });
         if (it == surfaces_.end()) {
@@ -46,4 +53,13 @@ namespace Resource {
         return *it;
     }
 
+    auto Cache::getPalette(const std::string& name) -> const Palette& {
+        auto it = std::ranges::find_if(palettes_, [&name](const auto& p) { return p.name == name; });
+        if (it == palettes_.end()) {
+            std::cerr << "Cache: palette not found: " << name << '\n';
+            throw std::runtime_error("Palette not found: " + name);
+        }
+        return it->palette;
+    }
+
 }  // namespace Resource

source/core/resources/resource_cache.hpp

@@ -25,9 +25,13 @@ namespace Resource {
         void loadSurface(const std::string& name, const std::string& file_path);
         // Llig el YAML d'animació en cru i el registra amb el nom donat.
         void loadAnimation(const std::string& name, const std::string& file_path);
+        // Carrega una paleta (.pal JASC o .gif) i la registra amb el nom donat.
+        // Pensat per a paletes compartides (UI, fonts, tilesets reciclats).
+        void loadPalette(const std::string& name, const std::string& file_path);
 
         auto getSurface(const std::string& name) -> std::shared_ptr<Surface>;
         auto getAnimationData(const std::string& name) -> const AnimationResource&;
+        auto getPalette(const std::string& name) -> const Palette&;
 
        private:
         Cache() = default;
@@ -35,6 +39,7 @@ namespace Resource {
 
         std::vector<SurfaceResource> surfaces_;
         std::vector<AnimationResource> animations_;
+        std::vector<PaletteResource> palettes_;
     };
 
 }  // namespace Resource

source/core/resources/resource_types.hpp

@@ -16,3 +16,8 @@ struct AnimationResource {
     std::string name;
     std::vector<std::uint8_t> yaml_data;
 };
+
+struct PaletteResource {
+    std::string name;
+    Palette palette;
+};