Refactor ObjectJsonHelpers

Move functions in ObjectJsonHelpers to their relevant namespaces and classes
- Move ParseColour to Colour::FromString
- Move ParseCursor to Cursor::FromString
- Move LoadStrings to StringTable::ReadJson
- Move LoadImages to ImageTable::ReadJson
- Move ParseObjectEntry to Object::ParseObjectEntry
- Move GetString, etc. to Json::GetString, etc.
- Delete ObjectJsonHelpers .cpp and .h files

src/openrct2/object/ImageTable.cpp

@@ -9,14 +9,285 @@
 
 #include "ImageTable.h"
 
+#include "../Context.h"
 #include "../OpenRCT2.h"
+#include "../PlatformEnvironment.h"
+#include "../core/File.h"
+#include "../core/FileScanner.h"
 #include "../core/IStream.hpp"
+#include "../core/Path.hpp"
+#include "../core/String.hpp"
+#include "../drawing/ImageImporter.h"
+#include "../sprites.h"
 #include "Object.h"
+#include "ObjectFactory.h"
 
 #include <algorithm>
 #include <memory>
 #include <stdexcept>
 
+using namespace OpenRCT2;
+using namespace OpenRCT2::Drawing;
+
+struct ImageTable::RequiredImage
+{
+    rct_g1_element g1{};
+    std::unique_ptr<RequiredImage> next_zoom;
+
+    bool HasData() const
+    {
+        return g1.offset != nullptr;
+    }
+
+    RequiredImage() = default;
+    RequiredImage(const RequiredImage&) = delete;
+
+    RequiredImage(const rct_g1_element& orig)
+    {
+        auto length = g1_calculate_data_size(&orig);
+        g1 = orig;
+        g1.offset = new uint8_t[length];
+        std::memcpy(g1.offset, orig.offset, length);
+        g1.flags &= ~G1_FLAG_HAS_ZOOM_SPRITE;
+    }
+
+    RequiredImage(uint32_t idx, std::function<const rct_g1_element*(uint32_t)> getter)
+    {
+        auto orig = getter(idx);
+        if (orig != nullptr)
+        {
+            auto length = g1_calculate_data_size(orig);
+            g1 = *orig;
+            g1.offset = new uint8_t[length];
+            std::memcpy(g1.offset, orig->offset, length);
+            if ((g1.flags & G1_FLAG_HAS_ZOOM_SPRITE) && g1.zoomed_offset != 0)
+            {
+                // Fetch image for next zoom level
+                next_zoom = std::make_unique<RequiredImage>(static_cast<uint32_t>(idx - g1.zoomed_offset), getter);
+                if (!next_zoom->HasData())
+                {
+                    next_zoom = nullptr;
+                    g1.flags &= ~G1_FLAG_HAS_ZOOM_SPRITE;
+                }
+            }
+        }
+    }
+
+    ~RequiredImage()
+    {
+        delete[] g1.offset;
+    }
+};
+
+std::vector<std::unique_ptr<ImageTable::RequiredImage>> ImageTable::ParseImages(IReadObjectContext* context, std::string s)
+{
+    std::vector<std::unique_ptr<RequiredImage>> result;
+    if (s.empty())
+    {
+        result.push_back(std::make_unique<RequiredImage>());
+    }
+    else if (String::StartsWith(s, "$CSG"))
+    {
+        if (is_csg_loaded())
+        {
+            auto range = ParseRange(s.substr(4));
+            if (!range.empty())
+            {
+                for (auto i : range)
+                {
+                    result.push_back(std::make_unique<RequiredImage>(
+                        static_cast<uint32_t>(SPR_CSG_BEGIN + i),
+                        [](uint32_t idx) -> const rct_g1_element* { return gfx_get_g1_element(idx); }));
+                }
+            }
+        }
+    }
+    else if (String::StartsWith(s, "$G1"))
+    {
+        auto range = ParseRange(s.substr(3));
+        if (!range.empty())
+        {
+            for (auto i : range)
+            {
+                result.push_back(std::make_unique<RequiredImage>(
+                    static_cast<uint32_t>(i), [](uint32_t idx) -> const rct_g1_element* { return gfx_get_g1_element(idx); }));
+            }
+        }
+    }
+    else if (String::StartsWith(s, "$RCT2:OBJDATA/"))
+    {
+        auto name = s.substr(14);
+        auto rangeStart = name.find('[');
+        if (rangeStart != std::string::npos)
+        {
+            auto rangeString = name.substr(rangeStart);
+            auto range = ParseRange(name.substr(rangeStart));
+            name = name.substr(0, rangeStart);
+            result = LoadObjectImages(context, name, range);
+        }
+    }
+    else
+    {
+        try
+        {
+            auto imageData = context->GetData(s);
+            auto image = Imaging::ReadFromBuffer(imageData, IMAGE_FORMAT::PNG_32);
+
+            ImageImporter importer;
+            auto importResult = importer.Import(image, 0, 0, ImageImporter::IMPORT_FLAGS::RLE);
+
+            result.push_back(std::make_unique<RequiredImage>(importResult.Element));
+        }
+        catch (const std::exception& e)
+        {
+            auto msg = String::StdFormat("Unable to load image '%s': %s", s.c_str(), e.what());
+            context->LogWarning(OBJECT_ERROR_BAD_IMAGE_TABLE, msg.c_str());
+            result.push_back(std::make_unique<RequiredImage>());
+        }
+    }
+    return result;
+}
+
+std::vector<std::unique_ptr<ImageTable::RequiredImage>> ImageTable::ParseImages(IReadObjectContext* context, json_t& el)
+{
+    Guard::Assert(el.is_object(), "ImageTable::ParseImages expects parameter el to be object");
+
+    auto path = Json::GetString(el["path"]);
+    auto x = Json::GetNumber<int16_t>(el["x"]);
+    auto y = Json::GetNumber<int16_t>(el["y"]);
+    auto raw = Json::GetString(el["format"]) == "raw";
+
+    std::vector<std::unique_ptr<RequiredImage>> result;
+    try
+    {
+        auto flags = ImageImporter::IMPORT_FLAGS::NONE;
+        if (!raw)
+        {
+            flags = static_cast<ImageImporter::IMPORT_FLAGS>(flags | ImageImporter::IMPORT_FLAGS::RLE);
+        }
+        auto imageData = context->GetData(path);
+        auto image = Imaging::ReadFromBuffer(imageData, IMAGE_FORMAT::PNG_32);
+
+        ImageImporter importer;
+        auto importResult = importer.Import(image, 0, 0, flags);
+        auto g1Element = importResult.Element;
+        g1Element.x_offset = x;
+        g1Element.y_offset = y;
+        result.push_back(std::make_unique<RequiredImage>(g1Element));
+    }
+    catch (const std::exception& e)
+    {
+        auto msg = String::StdFormat("Unable to load image '%s': %s", path.c_str(), e.what());
+        context->LogWarning(OBJECT_ERROR_BAD_IMAGE_TABLE, msg.c_str());
+        result.push_back(std::make_unique<RequiredImage>());
+    }
+    return result;
+}
+
+std::vector<std::unique_ptr<ImageTable::RequiredImage>> ImageTable::LoadObjectImages(
+    IReadObjectContext* context, const std::string& name, const std::vector<int32_t>& range)
+{
+    std::vector<std::unique_ptr<RequiredImage>> result;
+    auto objectPath = FindLegacyObject(name);
+    auto obj = ObjectFactory::CreateObjectFromLegacyFile(context->GetObjectRepository(), objectPath.c_str());
+    if (obj != nullptr)
+    {
+        auto& imgTable = static_cast<const Object*>(obj)->GetImageTable();
+        auto numImages = static_cast<int32_t>(imgTable.GetCount());
+        auto images = imgTable.GetImages();
+        size_t placeHoldersAdded = 0;
+        for (auto i : range)
+        {
+            if (i >= 0 && i < numImages)
+            {
+                result.push_back(std::make_unique<RequiredImage>(
+                    static_cast<uint32_t>(i), [images](uint32_t idx) -> const rct_g1_element* { return &images[idx]; }));
+            }
+            else
+            {
+                result.push_back(std::make_unique<RequiredImage>());
+                placeHoldersAdded++;
+            }
+        }
+        delete obj;
+
+        // Log place holder information
+        if (placeHoldersAdded > 0)
+        {
+            std::string msg = "Adding " + std::to_string(placeHoldersAdded) + " placeholders";
+            context->LogWarning(OBJECT_ERROR_INVALID_PROPERTY, msg.c_str());
+        }
+    }
+    else
+    {
+        std::string msg = "Unable to open '" + objectPath + "'";
+        context->LogWarning(OBJECT_ERROR_INVALID_PROPERTY, msg.c_str());
+        for (size_t i = 0; i < range.size(); i++)
+        {
+            result.push_back(std::make_unique<RequiredImage>());
+        }
+    }
+    return result;
+}
+
+std::vector<int32_t> ImageTable::ParseRange(std::string s)
+{
+    // Currently only supports [###] or [###..###]
+    std::vector<int32_t> result = {};
+    if (s.length() >= 3 && s[0] == '[' && s[s.length() - 1] == ']')
+    {
+        s = s.substr(1, s.length() - 2);
+        auto parts = String::Split(s, "..");
+        if (parts.size() == 1)
+        {
+            result.push_back(std::stoi(parts[0]));
+        }
+        else
+        {
+            auto left = std::stoi(parts[0]);
+            auto right = std::stoi(parts[1]);
+            if (left <= right)
+            {
+                for (auto i = left; i <= right; i++)
+                {
+                    result.push_back(i);
+                }
+            }
+            else
+            {
+                for (auto i = right; i >= left; i--)
+                {
+                    result.push_back(i);
+                }
+            }
+        }
+    }
+    return result;
+}
+
+std::string ImageTable::FindLegacyObject(const std::string& name)
+{
+    const auto env = GetContext()->GetPlatformEnvironment();
+    auto objectsPath = env->GetDirectoryPath(DIRBASE::RCT2, DIRID::OBJECT);
+    auto objectPath = Path::Combine(objectsPath, name);
+    if (!File::Exists(objectPath))
+    {
+        // Search recursively for any file with the target name (case insensitive)
+        auto filter = Path::Combine(objectsPath, "*.dat");
+        auto scanner = std::unique_ptr<IFileScanner>(Path::ScanDirectory(filter, true));
+        while (scanner->Next())
+        {
+            auto currentName = Path::GetFileName(scanner->GetPathRelative());
+            if (String::Equals(currentName, name, true))
+            {
+                objectPath = scanner->GetPath();
+                break;
+            }
+        }
+    }
+    return objectPath;
+}
+
 ImageTable::~ImageTable()
 {
     if (_data == nullptr)
@@ -97,6 +368,70 @@ void ImageTable::Read(IReadObjectContext* context, OpenRCT2::IStream* stream)
     }
 }
 
+void ImageTable::ReadJson(IReadObjectContext* context, json_t& root)
+{
+    Guard::Assert(root.is_object(), "ImageTable::ReadJson expects parameter root to be object");
+
+    if (context->ShouldLoadImages())
+    {
+        // First gather all the required images from inspecting the JSON
+        std::vector<std::unique_ptr<RequiredImage>> allImages;
+        auto jsonImages = root["images"];
+
+        for (auto& jsonImage : jsonImages)
+        {
+            if (jsonImage.is_string())
+            {
+                auto strImage = jsonImage.get<std::string>();
+                auto images = ParseImages(context, strImage);
+                allImages.insert(
+                    allImages.end(), std::make_move_iterator(images.begin()), std::make_move_iterator(images.end()));
+            }
+            else if (jsonImage.is_object())
+            {
+                auto images = ParseImages(context, jsonImage);
+                allImages.insert(
+                    allImages.end(), std::make_move_iterator(images.begin()), std::make_move_iterator(images.end()));
+            }
+        }
+
+        // Now add all the images to the image table
+        auto imagesStartIndex = GetCount();
+        for (const auto& img : allImages)
+        {
+            const auto& g1 = img->g1;
+            AddImage(&g1);
+        }
+
+        // Add all the zoom images at the very end of the image table.
+        // This way it should not affect the offsets used within the object logic.
+        for (size_t j = 0; j < allImages.size(); j++)
+        {
+            const auto tableIndex = imagesStartIndex + j;
+            const auto* img = allImages[j].get();
+            if (img->next_zoom != nullptr)
+            {
+                img = img->next_zoom.get();
+
+                // Set old image zoom offset to zoom image which we are about to add
+                auto g1a = const_cast<rct_g1_element*>(&GetImages()[tableIndex]);
+                g1a->zoomed_offset = static_cast<int32_t>(tableIndex) - static_cast<int32_t>(GetCount());
+
+                while (img != nullptr)
+                {
+                    auto g1b = img->g1;
+                    if (img->next_zoom != nullptr)
+                    {
+                        g1b.zoomed_offset = -1;
+                    }
+                    AddImage(&g1b);
+                    img = img->next_zoom.get();
+                }
+            }
+        }
+    }
+}
+
 void ImageTable::AddImage(const rct_g1_element* g1)
 {
     rct_g1_element newg1 = *g1;