Refactor import flags

src/openrct2-ui/scripting/CustomImages.cpp

@@ -322,7 +322,8 @@ namespace OpenRCT2::Scripting
                 auto importMode = getImportModeFromPalette(pixelData.Palette);
                 auto pngData = DukGetDataFromBufferLikeObject(pixelData.Data);
                 auto image = Imaging::ReadFromBuffer(pngData, imageFormat);
-                ImageImportMeta meta = { { 0, 0 }, palette, ImportFlags::RLE, importMode };
+                uint8_t flags = EnumToFlag(ImportFlags::RLE);
+                ImageImportMeta meta = { { 0, 0 }, palette, flags, importMode };
 
                 ImageImporter importer;
                 auto importResult = importer.Import(image, meta);

src/openrct2/CommandLineSprite.cpp

@@ -498,7 +498,8 @@ int32_t CommandLineForSprite(const char** argv, int32_t argc)
             }
         }
 
-        ImageImportMeta meta = { { xOffset, yOffset }, Palette::OpenRCT2, ImportFlags::RLE, gSpriteMode };
+        uint8_t importFlags = EnumToFlag(ImportFlags::RLE);
+        ImageImportMeta meta = { { xOffset, yOffset }, Palette::OpenRCT2, importFlags, gSpriteMode };
         auto importResult = SpriteImageImport(imagePath, meta);
         if (!importResult.has_value())
             return -1;

src/openrct2/drawing/ImageImporter.cpp

@@ -38,7 +38,7 @@ namespace OpenRCT2::Drawing
         {
             throw std::invalid_argument("Image is not paletted, it has bit depth of " + std::to_string(image.Depth));
         }
-        const bool isRLE = meta.importFlags & ImportFlags::RLE;
+        const bool isRLE = HasFlag(meta.importFlags, ImportFlags::RLE);
 
         auto pixels = GetPixels(image, meta);
         auto buffer = isRLE ? EncodeRLE(pixels.data(), meta.srcSize) : EncodeRaw(pixels.data(), meta.srcSize);
@@ -50,7 +50,7 @@ namespace OpenRCT2::Drawing
         outElement.x_offset = meta.offset.x;
         outElement.y_offset = meta.offset.y;
         outElement.zoomed_offset = meta.zoomedOffset;
-        if (meta.importFlags & ImportFlags::NoDrawOnZoom)
+        if (HasFlag(meta.importFlags, ImportFlags::NoDrawOnZoom))
             outElement.flags |= G1_FLAG_NO_ZOOM_DRAW;
 
         ImageImporter::ImportResult result;
@@ -391,25 +391,22 @@ namespace OpenRCT2::Drawing
         auto yOffset = Json::GetNumber<int16_t>(input["y"]);
         auto keepPalette = Json::GetString(input["palette"]) == "keep";
         auto palette = keepPalette ? Palette::KeepIndices : Palette::OpenRCT2;
-        auto flags = EnumValue(ImportFlags::None);
+        uint8_t flags = 0;
 
         auto raw = Json::GetString(input["format"]) == "raw";
         if (!raw)
-            flags |= EnumValue(ImportFlags::RLE);
+            flags |= EnumToFlag(ImportFlags::RLE);
+
+        if (Json::GetBoolean("noDrawOnZoom"))
+            flags |= EnumToFlag(ImportFlags::NoDrawOnZoom);
 
-        flags |= Json::GetFlags<uint8_t>(
-            input,
-            {
-                { "noDrawOnZoom", ImportFlags::NoDrawOnZoom },
-            });
         auto srcX = Json::GetNumber<int16_t>(input["srcX"]);
         auto srcY = Json::GetNumber<int16_t>(input["srcY"]);
         auto srcWidth = Json::GetNumber<int16_t>(input["srcWidth"]);
         auto srcHeight = Json::GetNumber<int16_t>(input["srcHeight"]);
         auto zoomedOffset = Json::GetNumber<int32_t>(input["zoom"]);
 
-        return ImageImportMeta{ { xOffset, yOffset }, palette,        static_cast<ImportFlags>(flags),
-                                ImportMode::Default,  { srcX, srcY }, { srcWidth, srcHeight },
-                                zoomedOffset };
+        return ImageImportMeta{ { xOffset, yOffset },    palette,     flags, ImportMode::Default, { srcX, srcY },
+                                { srcWidth, srcHeight }, zoomedOffset };
     };
 } // namespace OpenRCT2::Drawing

src/openrct2/drawing/ImageImporter.h

@@ -11,6 +11,7 @@
 
 #include "../core/Imaging.h"
 #include "../core/JsonFwd.hpp"
+#include "../util/Util.h"
 #include "Drawing.h"
 
 #include <string_view>
@@ -27,11 +28,10 @@ namespace OpenRCT2::Drawing
         Dithering,
     };
 
-    enum ImportFlags : uint8_t
+    enum class ImportFlags : uint8_t
     {
-        None = 0,
-        RLE = 1 << 1,
-        NoDrawOnZoom = 1 << 2,
+        RLE,
+        NoDrawOnZoom,
     };
 
     enum class Palette : uint8_t
@@ -44,7 +44,7 @@ namespace OpenRCT2::Drawing
     {
         ScreenCoordsXY offset{};
         Palette palette = Palette::OpenRCT2;
-        ImportFlags importFlags = ImportFlags::RLE;
+        uint8_t importFlags = EnumToFlag(ImportFlags::RLE);
         ImportMode importMode = ImportMode::Default;
         ScreenCoordsXY srcOffset{};
         ScreenSize srcSize{};

src/openrct2/util/Util.h

@@ -127,6 +127,12 @@ template<typename TEnum> constexpr auto EnumValue(TEnum enumerator) noexcept
     return static_cast<std::underlying_type_t<TEnum>>(enumerator);
 }
 
+template<typename T> constexpr bool HasFlag(uint64_t holder, T v)
+{
+    static_assert(std::is_enum_v<T>);
+    return (holder & EnumToFlag(v)) != 0;
+}
+
 constexpr uint8_t HiByte(uint16_t value)
 {
     return static_cast<uint8_t>(value >> 8);