Read palette arrays from JSON manifest files

Author: AaronVanGeffen

tools/gxc/src/SpriteManifest.cpp

@@ -41,7 +41,7 @@ static SpriteManifest::Format parseFormat(const nlohmann::json& jFormat, const b
     else if (value == "palette" && hasImageFile)
         return SpriteManifest::Format::paletteImage;
     else if (value == "palette")
-        return SpriteManifest::Format::paletteHex;
+        return SpriteManifest::Format::paletteArray;
     else
         throw std::runtime_error("Unknown format");
 }
@@ -117,6 +117,43 @@ static std::optional<Range> parseRange(std::string_view s)
     return std::nullopt;
 }
 
+static BGRColour parseJSONPaletteColour(const std::string& s)
+{
+    uint8_t r = 0;
+    uint8_t g = 0;
+    uint8_t b = 0;
+    if (s[0] == '#' && s.size() == 7)
+    {
+        // Expect #RRGGBB
+        r = std::stoul(s.substr(1, 2), nullptr, 16) & 0xFF;
+        g = std::stoul(s.substr(3, 2), nullptr, 16) & 0xFF;
+        b = std::stoul(s.substr(5, 2), nullptr, 16) & 0xFF;
+    }
+    return { b, g, r };
+}
+
+static std::vector<BGRColour> parseColours(const nlohmann::json& jPalette)
+{
+    if (!jPalette.is_object())
+        throw std::runtime_error("parseColours expects parameter jPalette to be an object");
+
+    auto jColours = jPalette["colours"];
+    std::vector<BGRColour> out;
+
+    auto numColours = jColours.size();
+    out.reserve(numColours * 3);
+
+    for (auto& jColour : jColours)
+    {
+        if (!jColour.is_string())
+            throw std::runtime_error("Encountered a value that is not a string!");
+
+        out.push_back(parseJSONPaletteColour(jColour.get<std::string>()));
+    }
+
+    return out;
+}
+
 static SpriteManifest::Entry parseEntry(const nlohmann::json& jEntry)
 {
     SpriteManifest::Entry result;
@@ -150,14 +187,22 @@ static SpriteManifest::Entry parseEntry(const nlohmann::json& jEntry)
         if (jEntry.contains("path"))
             result.path = jEntry.at("path").get<std::string>();
         if (jEntry.contains("format"))
-            result.format = parseFormat(jEntry["format"], jEntry.contains("path"));
+            result.format = parseFormat(jEntry["format"], result.path.empty());
+
         if (jEntry.contains("palette"))
             result.palette = parsePalette(jEntry["palette"]);
+        if (jEntry.contains("colours"))
+            result.colours = parseColours(jEntry);
+
+        if (result.format == SpriteManifest::Format::automatic && !result.colours.empty())
+            result.format = SpriteManifest::Format::paletteArray;
 
         if (jEntry.contains("x"))
             result.offsetX = jEntry["x"];
         else if (jEntry.contains("x_offset"))
             result.offsetX = jEntry["x_offset"];
+        else if (jEntry.contains("index"))    // palette startIndex
+            result.offsetX = jEntry["index"]; // palette startIndex
 
         if (jEntry.contains("y"))
             result.offsetY = jEntry["y"];

tools/gxc/src/SpriteManifest.h

@@ -7,6 +7,15 @@
 
 namespace gxc
 {
+    struct BGRColour
+    {
+        uint8_t blue{};
+        uint8_t green{};
+        uint8_t red{};
+    };
+
+    using ColourVector = std::vector<BGRColour>;
+
     class SpriteArchive;
 
     class SpriteManifest
@@ -33,6 +42,7 @@ namespace gxc
             fs::path path;
             Format format{};
             PaletteKind palette{};
+            ColourVector colours{};
             int32_t offsetX{};
             int32_t offsetY{};
             int32_t zoomOffset{};

tools/gxc/src/gxc.cpp

@@ -60,6 +60,14 @@ static void encodePaletteFromImage(Stream& stream, const Image& image)
     }
 }
 
+static void encodePaletteFromArray(Stream& stream, const std::vector<BGRColour>& colours)
+{
+    for (auto& colour : colours)
+    {
+        stream.write(&colour, 3);
+    }
+}
+
 static std::string stringifyFlags(uint16_t flags)
 {
     std::string result;
@@ -136,6 +144,21 @@ int runBuild(const CommandLineOptions& options)
         }
         try
         {
+            // Palette arrays don't have an image to load, so start with those
+            if (manifestEntry.format == SpriteManifest::Format::paletteArray)
+            {
+                MemoryStream ms;
+                encodePaletteFromArray(ms, manifestEntry.colours);
+
+                SpriteArchive::Entry entry;
+                entry.width = manifestEntry.colours.size();
+                entry.height = 1;
+                entry.offsetX = manifestEntry.offsetX;
+                entry.flags = GxFlags::isPalette;
+                archive.addEntry(entry, ms.asSpan<const std::byte>());
+                continue;
+            }
+
             auto imageCacheIterator = imageCache.find(manifestEntry.path);
             if (imageCacheIterator == imageCache.end())
             {