rngine 0.7.2 → 0.8.1

package/nitrogen/generated/shared/c++/World.hpp

@@ -0,0 +1,91 @@
+///
+/// World.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <optional>
+
+namespace margelo::nitro::rngine {
+
+  /**
+   * A struct which can be represented as a JavaScript object (World).
+   */
+  struct World final {
+  public:
+    double tickRate     SWIFT_PRIVATE;
+    std::optional<double> gx     SWIFT_PRIVATE;
+    std::optional<double> gy     SWIFT_PRIVATE;
+
+  public:
+    World() = default;
+    explicit World(double tickRate, std::optional<double> gx, std::optional<double> gy): tickRate(tickRate), gx(gx), gy(gy) {}
+
+  public:
+    friend bool operator==(const World& lhs, const World& rhs) = default;
+  };
+
+} // namespace margelo::nitro::rngine
+
+namespace margelo::nitro {
+
+  // C++ World <> JS World (object)
+  template <>
+  struct JSIConverter<margelo::nitro::rngine::World> final {
+    static inline margelo::nitro::rngine::World fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::rngine::World(
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "tickRate"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "gx"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "gy")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::rngine::World& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "tickRate"), JSIConverter<double>::toJSI(runtime, arg.tickRate));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "gx"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.gx));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "gy"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.gy));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "tickRate")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "gx")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "gy")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rngine",
-  "version": "0.7.2",
+  "version": "0.8.1",
   "description": "React Native 2D game engine powered by Nitro Modules",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -176,5 +176,8 @@
       "vite"
     ],
     "version": "0.61.0"
+  },
+  "dependencies": {
+    "react-native-skia-android": "^152.0.0"
   }
 }

package/shared/CollisionUtils.hpp

@@ -3,16 +3,11 @@
 #include "Circle.hpp"
 #include "Collision.hpp"
 #include "Entity.hpp"
+#include "Overlap.hpp"
 #include "Rect.hpp"
 #include <optional>
 
 namespace margelo::nitro::rngine::CollisionUtils {
-struct Overlap {
-  double depth;
-  double nx;
-  double ny;
-};
-
 std::optional<Overlap> overlap(const Rect &a, double ax, double ay,
                                const Rect &b, double bx, double by);
 std::optional<Overlap> overlap(const Circle &a, double ax, double ay,

package/{android/src/main/cpp/ColorUtils.hpp → shared/ColorUtils.cpp}

@@ -1,21 +1,17 @@
-#pragma once
-#include <string>
+#include "ColorUtils.hpp"
 
-namespace margelo::nitro::rngine {
-
-inline uint32_t parseHexColor(const std::optional<std::string> &color) {
-  if (!color.has_value())
-    return 0x00000000;
-  const std::string &c = color.value();
+namespace margelo::nitro::rngine::ColorUtils {
+uint32_t parseHexColor(const std::string &color) {
+  const std::string &c = color;
   if (!c.empty() && c[0] == '#') {
     std::string hex = c.substr(1);
 
     if (hex.size() == 3 || hex.size() == 4) {
       std::string expanded;
       expanded.reserve(hex.size() * 2);
-      for (char c : hex) {
-        expanded += c;
-        expanded += c;
+      for (char ch : hex) {
+        expanded += ch;
+        expanded += ch;
       }
       hex = std::move(expanded);
     }
@@ -34,4 +30,4 @@ inline uint32_t parseHexColor(const std::optional<std::string> &color) {
 
   return 0x00000000;
 }
-} // namespace margelo::nitro::rngine
+} // namespace margelo::nitro::rngine::ColorUtils

package/shared/ColorUtils.hpp

@@ -0,0 +1,7 @@
+#pragma once
+#include <cstdint>
+#include <string>
+
+namespace margelo::nitro::rngine::ColorUtils {
+uint32_t parseHexColor(const std::string &color);
+} // namespace margelo::nitro::rngine::ColorUtils

package/shared/GameLoop.cpp

@@ -2,10 +2,11 @@
 #include "Collision.hpp"
 #include "CollisionUtils.hpp"
 #include "Entity.hpp"
+#include "GameRenderer.hpp"
 #include <android/log.h>
 #include <chrono>
 #include <cinttypes>
-#include <set>
+#include <mutex>
 
 namespace margelo::nitro::rngine {
 
@@ -32,6 +33,11 @@ GameLoop::~GameLoop() {
   __android_log_print(ANDROID_LOG_INFO, "GameLoop", "Destructor - Complete");
 }
 
+bool GameLoop::entityIdMatches(const std::string &entityId,
+                               const std::string &prefix) {
+  return entityId == prefix || entityId.starts_with(prefix + "_");
+}
+
 std::vector<Entity *>
 GameLoop::resolveEntitiesInternal(const std::string &prefix) {
   std::vector<Entity *> results;
@@ -52,14 +58,6 @@ GameLoop::resolveEntitiesInternal(const std::string &prefix) {
   return results;
 }
 
-void GameLoop::registerLottieDuration(double id, double duration) {
-  std::lock_guard<std::mutex> lock(_mutex);
-  _lottieDurations[id] = duration;
-  __android_log_print(ANDROID_LOG_DEBUG, "GameLoop",
-                      "Registered lottie duration: id: %.0f, duration: %.4f",
-                      id, duration);
-}
-
 void GameLoop::runGameLoop() {
   using namespace std::chrono;
 
@@ -68,8 +66,14 @@ void GameLoop::runGameLoop() {
   auto previousTime = steady_clock::now();
   double accumulator = 0.0;
 
+  auto &gameRenderer = GameRenderer::getInstance();
+
   while (_isRunning) {
-    double targetDeltaTime = 1.0 / _tickRate.load();
+    double targetDeltaTime;
+    {
+      std::lock_guard<std::mutex> lock(_worldMutex);
+      targetDeltaTime = 1.0 / _world.tickRate;
+    }
     auto currentTime = steady_clock::now();
     double frameTime = duration<double>(currentTime - previousTime).count();
     previousTime = currentTime;
@@ -87,6 +91,11 @@ void GameLoop::runGameLoop() {
       }
     }
 
+    {
+      std::lock_guard<std::mutex> lock(_mutex);
+      gameRenderer.render(_screen, _entities);
+    }
+
     std::this_thread::sleep_for(milliseconds(1));
   }
 
@@ -108,28 +117,14 @@ void GameLoop::runSystems() {
     }
 
     if (system.collisions.has_value()) {
-      std::set<std::pair<std::string, std::string>> uniqueEntityIdPairs;
-
-      for (const auto &[a, b] : system.collisions.value()) {
-        auto resolvedEntitiesInternalA = resolveEntitiesInternal(a);
-        auto resolvedEntitiesInternalB = resolveEntitiesInternal(b);
-
-        for (const auto &entityA : resolvedEntitiesInternalA) {
-          for (const auto &entityB : resolvedEntitiesInternalB) {
-            if (entityA == entityB)
-              continue;
-
-            auto uniqueEntityIdPairKey = std::minmax(entityA->id, entityB->id);
-
-            if (uniqueEntityIdPairs.count(uniqueEntityIdPairKey))
-              continue;
-
-            uniqueEntityIdPairs.insert(uniqueEntityIdPairKey);
-
-            if (auto collision =
-                    CollisionUtils::shapeOverlap(*entityA, *entityB)) {
-              collisions.push_back(collision.value());
-            }
+      for (const auto &pair : system.collisions.value()) {
+        for (const auto &c : _collisions) {
+          bool matchesForward =
+              entityIdMatches(c.a, pair.a) && entityIdMatches(c.b, pair.b);
+          bool matchesReverse =
+              entityIdMatches(c.a, pair.b) && entityIdMatches(c.b, pair.a);
+          if (matchesForward || matchesReverse) {
+            collisions.push_back(c);
           }
         }
       }
@@ -151,18 +146,12 @@ void GameLoop::runSystems() {
   }
 }
 
-void GameLoop::captureSnapshot() {
-  std::lock_guard<std::mutex> snapshotLock(_snapshotMutex);
-  std::lock_guard<std::mutex> lock(_mutex);
-  _entitiesSnapshot = _entities;
-  _screenSnapshot = _screen;
-}
-
 void GameLoop::update(double deltaTime) {
   updateStats(deltaTime);
   updateEntities(deltaTime);
+  computeCollisions();
+  resolveCollisions();
   runSystems();
-  captureSnapshot();
 }
 
 void GameLoop::updateStats(double deltaTime) {
@@ -173,26 +162,51 @@ void GameLoop::updateStats(double deltaTime) {
   frameCount++;
 
   if (timeAccumulator >= 1.0) {
-    _gameStats.tickRate = static_cast<double>(frameCount);
-    _gameStats.deltaTime = deltaTime;
+    _gameStats.tickRate = static_cast<double>(frameCount) / timeAccumulator;
+    _gameStats.deltaTime = timeAccumulator / static_cast<double>(frameCount);
 
-    __android_log_print(ANDROID_LOG_DEBUG, "GameLoop",
-                        "TickRate: %.2f, Delta: %.4f, Total Ticks: %" PRIu64,
-                        _gameStats.tickRate, _gameStats.deltaTime,
-                        _gameStats.totalTicks);
+    __android_log_print(
+        ANDROID_LOG_DEBUG, "GameLoop",
+        "updateStats: TickRate: %.2f, Delta: %.4f, Total Ticks: %" PRIu64,
+        _gameStats.tickRate, _gameStats.deltaTime, _gameStats.totalTicks);
 
-    timeAccumulator = 0.0;
+    timeAccumulator -= 1.0;
     frameCount = 0;
   }
 
   _gameStats.totalTicks++;
 }
 
+void GameLoop::updateScreen(double deltaTime) {
+  std::lock_guard<std::mutex> lock(_mutex);
+  if (_screen.asset.has_value() && _screen.asset.value() < 0) {
+    auto &lottieCache = GameRenderer::getInstance().getLottieCacheInternal();
+    auto it = lottieCache.find(_screen.asset.value());
+    if (it != lottieCache.end() && it->second) {
+      _screen.progress = fmod(_screen.progress.value_or(0.0) +
+                                  deltaTime / it->second->duration(),
+                              1.0);
+    }
+  } else if (_screen.progress.has_value()) {
+    _screen.progress.reset();
+  }
+}
+
 void GameLoop::updateEntities(double deltaTime) {
+  std::lock_guard<std::mutex> worldLock(_worldMutex);
   std::lock_guard<std::mutex> lock(_mutex);
 
   for (auto &[id, entity] : _entities) {
 
+    if (entity.mass.has_value() && entity.mass.value() > 0.0) {
+      if (_world.gx.has_value()) {
+        entity.vx = entity.vx.value_or(0.0) + _world.gx.value() * deltaTime;
+      }
+      if (_world.gy.has_value()) {
+        entity.vy = entity.vy.value_or(0.0) + _world.gy.value() * deltaTime;
+      }
+    }
+
     if (entity.ax.has_value()) {
       entity.vx = entity.vx.value_or(0.0) + entity.ax.value() * deltaTime;
     }
@@ -208,12 +222,89 @@ void GameLoop::updateEntities(double deltaTime) {
     }
 
     if (entity.asset.has_value() && entity.asset.value() < 0) {
-      auto it = _lottieDurations.find(entity.asset.value());
-      if (it != _lottieDurations.end() && it->second > 0.0) {
-        entity.progress =
-            fmod(entity.progress.value_or(0.0) + deltaTime / it->second, 1.0);
+      auto &lottieCache = GameRenderer::getInstance().getLottieCacheInternal();
+      auto it = lottieCache.find(entity.asset.value());
+      if (it != lottieCache.end() && it->second) {
+        entity.progress = fmod(entity.progress.value_or(0.0) +
+                                   deltaTime / it->second->duration(),
+                               1.0);
+      }
+    } else if (entity.progress.has_value()) {
+      entity.progress.reset();
+    }
+  }
+}
+
+void GameLoop::computeCollisions() {
+  std::lock_guard<std::mutex> lock(_mutex);
+  _collisions.clear();
+
+  std::vector<Entity *> entities;
+  entities.reserve(_entities.size());
+  for (auto &[id, entity] : _entities) {
+    entities.push_back(&entity);
+  }
+
+  for (size_t i = 0; i < entities.size(); ++i) {
+    for (size_t j = i + 1; j < entities.size(); ++j) {
+      auto result = CollisionUtils::shapeOverlap(*entities[i], *entities[j]);
+      if (result.has_value()) {
+        _collisions.push_back(result.value());
       }
     }
   }
 }
+
+void GameLoop::resolveCollisions() {
+  std::lock_guard<std::mutex> lock(_mutex);
+
+  const double percent = 0.8;
+  const double slop = 0.01;
+
+  for (const auto &c : _collisions) {
+    auto itA = _entities.find(c.a);
+    auto itB = _entities.find(c.b);
+    if (itA == _entities.end() || itB == _entities.end())
+      continue;
+
+    Entity &a = itA->second;
+    Entity &b = itB->second;
+
+    if (a.isSensor.value_or(false) || b.isSensor.value_or(false))
+      continue;
+
+    double inverseMassA = (a.mass.has_value() && a.mass.value() > 0.0)
+                              ? 1.0 / a.mass.value()
+                              : 0.0;
+    double inverseMassB = (b.mass.has_value() && b.mass.value() > 0.0)
+                              ? 1.0 / b.mass.value()
+                              : 0.0;
+    double totalInverseMass = inverseMassA + inverseMassB;
+    if (totalInverseMass == 0.0)
+      continue;
+
+    double correctionDepth = std::max(c.depth - slop, 0.0);
+    double correction = (correctionDepth / totalInverseMass) * percent;
+    a.px -= c.nx * correction * inverseMassA;
+    a.py -= c.ny * correction * inverseMassA;
+    b.px += c.nx * correction * inverseMassB;
+    b.py += c.ny * correction * inverseMassB;
+
+    double avx = a.vx.value_or(0.0), avy = a.vy.value_or(0.0);
+    double bvx = b.vx.value_or(0.0), bvy = b.vy.value_or(0.0);
+    double relativeVx = bvx - avx, relativeVy = bvy - avy;
+    double velocityAlongNormal = relativeVx * c.nx + relativeVy * c.ny;
+    if (velocityAlongNormal > 0)
+      continue;
+
+    double restitution = 0.0;
+    double impulse =
+        -(1 + restitution) * velocityAlongNormal / totalInverseMass;
+
+    a.vx = avx - impulse * c.nx * inverseMassA;
+    a.vy = avy - impulse * c.ny * inverseMassA;
+    b.vx = bvx + impulse * c.nx * inverseMassB;
+    b.vy = bvy + impulse * c.ny * inverseMassB;
+  }
+}
 } // namespace margelo::nitro::rngine

package/shared/GameLoop.hpp

@@ -4,6 +4,7 @@
 #include "GameStats.hpp"
 #include "Screen.hpp"
 #include "System.hpp"
+#include "World.hpp"
 #include <atomic>
 #include <memory>
 #include <thread>
@@ -20,43 +21,38 @@ public:
 
   ~GameLoop();
 
+  std::mutex &getWorldMutexInternal() { return _worldMutex; };
   std::mutex &getMutexInternal() { return _mutex; };
-  std::mutex &getSnapshotMutexInternal() { return _snapshotMutex; };
   std::map<string, Entity> &getEntitiesInternal() { return _entities; };
-  std::map<string, Entity> &getEntitiesSnapshotInternal() {
-    return _entitiesSnapshot;
-  };
   std::vector<System> &getSystemsInternal() { return _systems; };
   std::atomic<bool> &getIsPausedInternal() { return _isPaused; };
+  World &getWorldInternal() { return _world; };
   Screen &getScreenInternal() { return _screen; };
-  Screen &getScreenSnapshotInternal() { return _screenSnapshot; };
 
+  bool entityIdMatches(const std::string &entityId, const std::string &prefix);
   std::vector<Entity *> resolveEntitiesInternal(const std::string &prefix);
-  void registerLottieDuration(double, double);
-
-  void setTickRate(double tickRate) { _tickRate.store(tickRate); };
 
 private:
   explicit GameLoop();
+  std::mutex _worldMutex;
   std::mutex _mutex;
-  std::mutex _snapshotMutex;
   std::map<std::string, Entity> _entities;
-  std::map<std::string, Entity> _entitiesSnapshot;
-  std::map<double, double> _lottieDurations;
+  std::vector<Collision> _collisions{};
   std::vector<System> _systems{};
   std::atomic<bool> _isRunning{true};
   std::atomic<bool> _isPaused{true};
-  std::atomic<double> _tickRate{60.0};
+  World _world;
   Screen _screen;
-  Screen _screenSnapshot;
   GameStats _gameStats;
   std::unique_ptr<std::thread> _gameThread;
 
   void runGameLoop();
   void runSystems();
-  void captureSnapshot();
+  void computeCollisions();
+  void resolveCollisions();
   void update(double deltaTime);
   void updateStats(double deltaTime);
+  void updateScreen(double deltaTime);
   void updateEntities(double deltaTime);
 };
 } // namespace margelo::nitro::rngine

package/shared/GameMethods.cpp

@@ -1,39 +1,37 @@
 #include "GameMethods.hpp"
 #include "EntityUpdate.hpp"
 #include "GameLoop.hpp"
+#include "GameRenderer.hpp"
+#include "include/core/SkStream.h"
 #include <android/log.h>
+#include <fbjni/fbjni.h>
 
 namespace margelo::nitro::rngine {
-void GameMethods::setTickRate(double tickRate) {
+void GameMethods::setWorld(const World &world) {
   auto &instance = GameLoop::getInstance();
-  instance.setTickRate(tickRate);
+  std::lock_guard<std::mutex> lock(instance.getWorldMutexInternal());
+  instance.getWorldInternal() = world;
   __android_log_print(ANDROID_LOG_INFO, "GameMethods",
-                      "setTickRate: tickRate=%.1f", tickRate);
+                      "setWorld: tickRate=%.1f", world.tickRate);
 }
 
 void GameMethods::setScreen(const Screen &screen) {
   auto &instance = GameLoop::getInstance();
   std::lock_guard<std::mutex> lock(instance.getMutexInternal());
-  std::lock_guard<std::mutex> snapshotLock(instance.getSnapshotMutexInternal());
   instance.getScreenInternal() = screen;
-  instance.getScreenSnapshotInternal() = screen;
 
   __android_log_print(ANDROID_LOG_INFO, "GameMethods",
-                      "setWorld: width=%.0f height=%.0f", screen.width,
+                      "setScreen: width=%.0f height=%.0f", screen.width,
                       screen.height);
 }
 
 void GameMethods::setEntities(const std::vector<Entity> &entities) {
   auto &instance = GameLoop::getInstance();
   std::lock_guard<std::mutex> lock(instance.getMutexInternal());
-  std::lock_guard<std::mutex> snapshotLock(instance.getSnapshotMutexInternal());
   auto &entitiesInternal = instance.getEntitiesInternal();
-  auto &entitiesSnapshotInternal = instance.getEntitiesSnapshotInternal();
   entitiesInternal.clear();
-  entitiesSnapshotInternal.clear();
   for (auto &entity : entities) {
     entitiesInternal[entity.id] = entity;
-    entitiesSnapshotInternal[entity.id] = entity;
   }
   __android_log_print(ANDROID_LOG_INFO, "GameMethods",
                       "setEntities: loaded %zu entities", entities.size());
@@ -130,6 +128,9 @@ void GameMethods::update(const std::vector<EntityUpdate> &updates) {
       if (update.shape.has_value()) {
         entity->shape = update.shape.value();
       }
+      if (update.isSensor.has_value()) {
+        entity->isSensor = update.isSensor.value();
+      }
       if (update.asset.has_value()) {
         entity->asset = update.asset.value();
       }
@@ -151,6 +152,9 @@ void GameMethods::update(const std::vector<EntityUpdate> &updates) {
       if (update.ay.has_value()) {
         entity->ay = update.ay.value();
       }
+      if (update.mass.has_value()) {
+        entity->mass = update.mass.value();
+      }
     }
 
     __android_log_print(ANDROID_LOG_INFO, "GameMethods",
@@ -158,4 +162,91 @@ void GameMethods::update(const std::vector<EntityUpdate> &updates) {
                         resolvedEntitiesInternals.size(), update.id.c_str());
   }
 }
+
+bool GameMethods::isAssetLoaded(double id) {
+  auto &gameRenderer = GameRenderer::getInstance();
+
+  if (id > 0) {
+    auto &svgCache = gameRenderer.getSvgCacheInternal();
+    auto it = svgCache.find(id);
+    return it != svgCache.end();
+  }
+
+  if (id < 0) {
+    auto &lottieCache = gameRenderer.getLottieCacheInternal();
+    auto it = lottieCache.find(id);
+    return it != lottieCache.end();
+  }
+
+  return false;
+};
+
+std::shared_ptr<Promise<bool>>
+GameMethods::loadLottie(double id, const std::string &jsonStr) {
+  return Promise<bool>::async([=]() -> bool {
+    auto stream = SkMemoryStream::MakeDirect(jsonStr.data(), jsonStr.size());
+    auto animation = skottie::Animation::Make(stream.get());
+
+    if (!animation) {
+      return false;
+    }
+
+    auto &gameRenderer = GameRenderer::getInstance();
+    auto &lottieCache = gameRenderer.getLottieCacheInternal();
+
+    lottieCache[id] = std::move(animation);
+
+    return true;
+  });
+};
+
+std::shared_ptr<Promise<bool>> GameMethods::loadSvg(double id,
+                                                    const std::string &svgUri) {
+  return Promise<bool>::async([=]() -> bool {
+    std::string svgStr;
+
+    using namespace facebook::jni;
+
+    ThreadScope::WithClassLoader([&] {
+      static const auto helperClass =
+          findClassStatic("com/margelo/nitro/rngine/SvgLoaderHelper");
+
+      local_ref<JArrayByte> byteArray;
+
+      if (svgUri.rfind("http://", 0) == 0 || svgUri.rfind("https://", 0) == 0) {
+        static const auto method =
+            helperClass->getStaticMethod<JArrayByte(local_ref<JString>)>(
+                "loadFromUrl");
+        byteArray = method(helperClass, make_jstring(svgUri));
+      } else {
+        static const auto method =
+            helperClass->getStaticMethod<JArrayByte(local_ref<JString>)>(
+                "loadFromResource");
+        byteArray = method(helperClass, make_jstring(svgUri));
+      }
+
+      if (!byteArray) {
+        throw std::runtime_error("Failed to load SVG bytes for: " + svgUri);
+      }
+
+      size_t len = byteArray->size();
+      svgStr.resize(len);
+      byteArray->getRegion(0, len, reinterpret_cast<int8_t *>(svgStr.data()));
+    });
+
+    auto stream = SkMemoryStream::MakeDirect(svgStr.data(), svgStr.size());
+    auto svgDom = SkSVGDOM::MakeFromStream(*stream);
+
+    if (!svgDom) {
+      return false;
+    }
+
+    auto &gameRenderer = GameRenderer::getInstance();
+    auto &svgCache = gameRenderer.getSvgCacheInternal();
+
+    svgCache[id] = std::move(svgDom);
+
+    return true;
+  });
+};
 } // namespace margelo::nitro::rngine