rngine 0.8.2 → 0.9.0

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

@@ -0,0 +1,120 @@
+///
+/// ScreenUpdate.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>
+#include <string>
+
+namespace margelo::nitro::rngine {
+
+  /**
+   * A struct which can be represented as a JavaScript object (ScreenUpdate).
+   */
+  struct ScreenUpdate final {
+  public:
+    std::optional<double> px     SWIFT_PRIVATE;
+    std::optional<double> py     SWIFT_PRIVATE;
+    std::optional<double> width     SWIFT_PRIVATE;
+    std::optional<double> height     SWIFT_PRIVATE;
+    std::optional<std::string> color     SWIFT_PRIVATE;
+    std::optional<double> asset     SWIFT_PRIVATE;
+    std::optional<bool> flipH     SWIFT_PRIVATE;
+    std::optional<bool> flipV     SWIFT_PRIVATE;
+    std::optional<double> progress     SWIFT_PRIVATE;
+    std::optional<double> speed     SWIFT_PRIVATE;
+
+  public:
+    ScreenUpdate() = default;
+    explicit ScreenUpdate(std::optional<double> px, std::optional<double> py, std::optional<double> width, std::optional<double> height, std::optional<std::string> color, std::optional<double> asset, std::optional<bool> flipH, std::optional<bool> flipV, std::optional<double> progress, std::optional<double> speed): px(px), py(py), width(width), height(height), color(color), asset(asset), flipH(flipH), flipV(flipV), progress(progress), speed(speed) {}
+
+  public:
+    friend bool operator==(const ScreenUpdate& lhs, const ScreenUpdate& rhs) = default;
+  };
+
+} // namespace margelo::nitro::rngine
+
+namespace margelo::nitro {
+
+  // C++ ScreenUpdate <> JS ScreenUpdate (object)
+  template <>
+  struct JSIConverter<margelo::nitro::rngine::ScreenUpdate> final {
+    static inline margelo::nitro::rngine::ScreenUpdate fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::rngine::ScreenUpdate(
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "px"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "py"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "width"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "height"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "color"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "asset"))),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "flipH"))),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "flipV"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "progress"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "speed")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::rngine::ScreenUpdate& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "px"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.px));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "py"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.py));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "width"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.width));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "height"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.height));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "color"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.color));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "asset"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.asset));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "flipH"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.flipH));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "flipV"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.flipV));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "progress"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.progress));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "speed"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.speed));
+      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<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "px")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "py")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "width")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "height")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "color")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "asset")))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "flipH")))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "flipV")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "progress")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "speed")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -30,18 +30,15 @@
 
 // Forward declaration of `CollisionPair` to properly resolve imports.
 namespace margelo::nitro::rngine { struct CollisionPair; }
-// Forward declaration of `Entity` to properly resolve imports.
-namespace margelo::nitro::rngine { struct Entity; }
-// Forward declaration of `Collision` to properly resolve imports.
-namespace margelo::nitro::rngine { struct Collision; }
+// Forward declaration of `SystemContext` to properly resolve imports.
+namespace margelo::nitro::rngine { struct SystemContext; }
 
 #include <string>
 #include <vector>
 #include <optional>
 #include "CollisionPair.hpp"
 #include <NitroModules/Promise.hpp>
-#include "Entity.hpp"
-#include "Collision.hpp"
+#include "SystemContext.hpp"
 #include <functional>
 
 namespace margelo::nitro::rngine {
@@ -53,11 +50,11 @@ namespace margelo::nitro::rngine {
   public:
     std::optional<std::vector<std::string>> entities     SWIFT_PRIVATE;
     std::optional<std::vector<CollisionPair>> collisions     SWIFT_PRIVATE;
-    std::function<std::shared_ptr<Promise<double>>(const std::vector<Entity>& /* entities */, const std::vector<Collision>& /* collisions */)> onTick     SWIFT_PRIVATE;
+    std::function<std::shared_ptr<Promise<double>>(const SystemContext& /* systemContext */)> onTick     SWIFT_PRIVATE;
 
   public:
     System() = default;
-    explicit System(std::optional<std::vector<std::string>> entities, std::optional<std::vector<CollisionPair>> collisions, std::function<std::shared_ptr<Promise<double>>(const std::vector<Entity>& /* entities */, const std::vector<Collision>& /* collisions */)> onTick): entities(entities), collisions(collisions), onTick(onTick) {}
+    explicit System(std::optional<std::vector<std::string>> entities, std::optional<std::vector<CollisionPair>> collisions, std::function<std::shared_ptr<Promise<double>>(const SystemContext& /* systemContext */)> onTick): entities(entities), collisions(collisions), onTick(onTick) {}
 
   public:
     // System is not equatable because these properties are not equatable: onTick
@@ -75,14 +72,14 @@ namespace margelo::nitro {
       return margelo::nitro::rngine::System(
         JSIConverter<std::optional<std::vector<std::string>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "entities"))),
         JSIConverter<std::optional<std::vector<margelo::nitro::rngine::CollisionPair>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "collisions"))),
-        JSIConverter<std::function<std::shared_ptr<Promise<double>>(const std::vector<margelo::nitro::rngine::Entity>&, const std::vector<margelo::nitro::rngine::Collision>&)>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "onTick")))
+        JSIConverter<std::function<std::shared_ptr<Promise<double>>(const margelo::nitro::rngine::SystemContext&)>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "onTick")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::rngine::System& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "entities"), JSIConverter<std::optional<std::vector<std::string>>>::toJSI(runtime, arg.entities));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "collisions"), JSIConverter<std::optional<std::vector<margelo::nitro::rngine::CollisionPair>>>::toJSI(runtime, arg.collisions));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "onTick"), JSIConverter<std::function<std::shared_ptr<Promise<double>>(const std::vector<margelo::nitro::rngine::Entity>&, const std::vector<margelo::nitro::rngine::Collision>&)>>::toJSI(runtime, arg.onTick));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "onTick"), JSIConverter<std::function<std::shared_ptr<Promise<double>>(const margelo::nitro::rngine::SystemContext&)>>::toJSI(runtime, arg.onTick));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -95,7 +92,7 @@ namespace margelo::nitro {
       }
       if (!JSIConverter<std::optional<std::vector<std::string>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "entities")))) return false;
       if (!JSIConverter<std::optional<std::vector<margelo::nitro::rngine::CollisionPair>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "collisions")))) return false;
-      if (!JSIConverter<std::function<std::shared_ptr<Promise<double>>(const std::vector<margelo::nitro::rngine::Entity>&, const std::vector<margelo::nitro::rngine::Collision>&)>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "onTick")))) return false;
+      if (!JSIConverter<std::function<std::shared_ptr<Promise<double>>(const margelo::nitro::rngine::SystemContext&)>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "onTick")))) return false;
       return true;
     }
   };

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

@@ -0,0 +1,99 @@
+///
+/// SystemContext.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
+
+// Forward declaration of `Screen` to properly resolve imports.
+namespace margelo::nitro::rngine { struct Screen; }
+// Forward declaration of `Entity` to properly resolve imports.
+namespace margelo::nitro::rngine { struct Entity; }
+// Forward declaration of `Collision` to properly resolve imports.
+namespace margelo::nitro::rngine { struct Collision; }
+
+#include "Screen.hpp"
+#include "Entity.hpp"
+#include <vector>
+#include "Collision.hpp"
+
+namespace margelo::nitro::rngine {
+
+  /**
+   * A struct which can be represented as a JavaScript object (SystemContext).
+   */
+  struct SystemContext final {
+  public:
+    Screen screen     SWIFT_PRIVATE;
+    std::vector<Entity> entities     SWIFT_PRIVATE;
+    std::vector<Collision> collisions     SWIFT_PRIVATE;
+
+  public:
+    SystemContext() = default;
+    explicit SystemContext(Screen screen, std::vector<Entity> entities, std::vector<Collision> collisions): screen(screen), entities(entities), collisions(collisions) {}
+
+  public:
+    friend bool operator==(const SystemContext& lhs, const SystemContext& rhs) = default;
+  };
+
+} // namespace margelo::nitro::rngine
+
+namespace margelo::nitro {
+
+  // C++ SystemContext <> JS SystemContext (object)
+  template <>
+  struct JSIConverter<margelo::nitro::rngine::SystemContext> final {
+    static inline margelo::nitro::rngine::SystemContext fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::rngine::SystemContext(
+        JSIConverter<margelo::nitro::rngine::Screen>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "screen"))),
+        JSIConverter<std::vector<margelo::nitro::rngine::Entity>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "entities"))),
+        JSIConverter<std::vector<margelo::nitro::rngine::Collision>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "collisions")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::rngine::SystemContext& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "screen"), JSIConverter<margelo::nitro::rngine::Screen>::toJSI(runtime, arg.screen));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "entities"), JSIConverter<std::vector<margelo::nitro::rngine::Entity>>::toJSI(runtime, arg.entities));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "collisions"), JSIConverter<std::vector<margelo::nitro::rngine::Collision>>::toJSI(runtime, arg.collisions));
+      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<margelo::nitro::rngine::Screen>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "screen")))) return false;
+      if (!JSIConverter<std::vector<margelo::nitro::rngine::Entity>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "entities")))) return false;
+      if (!JSIConverter<std::vector<margelo::nitro::rngine::Collision>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "collisions")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rngine",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "description": "React Native 2D game engine powered by Nitro Modules",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/shared/GameLoop.cpp

@@ -1,8 +1,10 @@
 #include "GameLoop.hpp"
+#include "AssetUtils.hpp"
 #include "Collision.hpp"
 #include "CollisionUtils.hpp"
 #include "Entity.hpp"
 #include "GameRenderer.hpp"
+#include "SystemContext.hpp"
 #include <android/log.h>
 #include <chrono>
 #include <cinttypes>
@@ -105,14 +107,15 @@ void GameLoop::runGameLoop() {
 void GameLoop::runSystems() {
   for (size_t systemIndex = 0; systemIndex < _systems.size(); ++systemIndex) {
     auto &system = _systems[systemIndex];
-    std::vector<Entity> entities;
-    std::vector<Collision> collisions;
+    SystemContext systemContext;
+
+    systemContext.screen = _screen;
 
     if (system.entities.has_value()) {
       for (const auto &id : system.entities.value()) {
         auto resolvedEntitiesInternal = resolveEntitiesInternal(id);
         for (auto *entity : resolvedEntitiesInternal)
-          entities.push_back(*entity);
+          systemContext.entities.push_back(*entity);
       }
     }
 
@@ -124,7 +127,7 @@ void GameLoop::runSystems() {
           bool matchesReverse =
               entityIdMatches(c.a, pair.b) && entityIdMatches(c.b, pair.a);
           if (matchesForward || matchesReverse) {
-            collisions.push_back(c);
+            systemContext.collisions.push_back(c);
           }
         }
       }
@@ -133,10 +136,10 @@ void GameLoop::runSystems() {
     __android_log_print(
         ANDROID_LOG_DEBUG, "GameLoop",
         "System Index: %zu, Entities: %zu, Collisions: %zu, Calling onTick",
-        systemIndex, entities.size(), collisions.size());
+        systemIndex, systemContext.entities.size(),
+        systemContext.collisions.size());
 
-    std::shared_ptr<Promise<double>> promise =
-        system.onTick(entities, collisions);
+    std::shared_ptr<Promise<double>> promise = system.onTick(systemContext);
     std::future<double> future = promise->await();
     double duration = future.get();
 
@@ -179,19 +182,9 @@ void GameLoop::updateStats(double deltaTime) {
 
 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) {
-      if (_screen.speed.has_value() && _screen.speed.value() > 0) {
-        _screen.progress = fmod(_screen.progress.value_or(0.0) +
-                                    (deltaTime * _screen.speed.value()) /
-                                        it->second->duration(),
-                                1.0);
-      }
-    }
-  } else if (_screen.progress.has_value()) {
-    _screen.progress.reset();
+  if (_screen.asset.has_value()) {
+    AssetUtils::updateProgress(_screen.progress, _screen.speed,
+                               _screen.asset.value(), deltaTime);
   }
 }
 
@@ -224,19 +217,9 @@ void GameLoop::updateEntities(double deltaTime) {
       entity.py += entity.vy.value() * deltaTime;
     }
 
-    if (entity.asset.has_value() && entity.asset.value() < 0) {
-      auto &lottieCache = GameRenderer::getInstance().getLottieCacheInternal();
-      auto it = lottieCache.find(entity.asset.value());
-      if (it != lottieCache.end() && it->second) {
-        if (entity.speed.has_value() && entity.speed.value() > 0) {
-          entity.progress = fmod(entity.progress.value_or(0.0) +
-                                     (deltaTime * entity.speed.value()) /
-                                         it->second->duration(),
-                                 1.0);
-        }
-      }
-    } else if (entity.progress.has_value()) {
-      entity.progress.reset();
+    if (entity.asset.has_value()) {
+      AssetUtils::updateProgress(entity.progress, entity.speed,
+                                 entity.asset.value(), deltaTime);
     }
   }
 }

package/shared/GameMethods.cpp

@@ -2,6 +2,7 @@
 #include "EntityUpdate.hpp"
 #include "GameLoop.hpp"
 #include "GameRenderer.hpp"
+#include "include/core/SkImage.h"
 #include "include/core/SkStream.h"
 #include <android/log.h>
 #include <fbjni/fbjni.h>
@@ -105,80 +106,78 @@ void GameMethods::despawn(const std::string &id) {
   }
 }
 
-void GameMethods::update(const std::vector<EntityUpdate> &updates) {
+static void patch(const auto &field, auto &target) {
+  if (field.has_value()) {
+    target = field.value();
+  }
+}
+
+void GameMethods::updateEntities(
+    const std::vector<EntityUpdate> &entityUpdates) {
   auto &instance = GameLoop::getInstance();
   std::lock_guard<std::mutex> lock(instance.getMutexInternal());
-  for (const auto &update : updates) {
+  for (const auto &entityUpdate : entityUpdates) {
     auto resolvedEntitiesInternals =
-        instance.resolveEntitiesInternal(update.id);
+        instance.resolveEntitiesInternal(entityUpdate.id);
     if (resolvedEntitiesInternals.empty()) {
       __android_log_print(ANDROID_LOG_WARN, "GameMethods",
-                          "update: no entity found for id=%s",
-                          update.id.c_str());
+                          "entityUpdate: no entity found for id=%s",
+                          entityUpdate.id.c_str());
       continue;
     }
 
     for (auto *entity : resolvedEntitiesInternals) {
-      if (update.px.has_value()) {
-        entity->px = update.px.value();
-      }
-      if (update.py.has_value()) {
-        entity->py = update.py.value();
-      }
-      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();
-      }
-      if (update.progress.has_value()) {
-        entity->progress = update.progress.value();
-      }
-      if (update.speed.has_value()) {
-        entity->speed = update.speed.value();
-      }
-      if (update.color.has_value()) {
-        entity->color = update.color.value();
-      }
-      if (update.flipH.has_value()) {
-        entity->flipH = update.flipH.value();
-      }
-      if (update.flipV.has_value()) {
-        entity->flipV = update.flipV.value();
-      }
-      if (update.vx.has_value()) {
-        entity->vx = update.vx.value();
-      }
-      if (update.vy.has_value()) {
-        entity->vy = update.vy.value();
-      }
-      if (update.ax.has_value()) {
-        entity->ax = update.ax.value();
-      }
-      if (update.ay.has_value()) {
-        entity->ay = update.ay.value();
-      }
-      if (update.mass.has_value()) {
-        entity->mass = update.mass.value();
-      }
+      patch(entityUpdate.px, entity->px);
+      patch(entityUpdate.py, entity->py);
+      patch(entityUpdate.shape, entity->shape);
+      patch(entityUpdate.isSensor, entity->isSensor);
+      patch(entityUpdate.asset, entity->asset);
+      patch(entityUpdate.progress, entity->progress);
+      patch(entityUpdate.speed, entity->speed);
+      patch(entityUpdate.color, entity->color);
+      patch(entityUpdate.flipH, entity->flipH);
+      patch(entityUpdate.flipV, entity->flipV);
+      patch(entityUpdate.vx, entity->vx);
+      patch(entityUpdate.vy, entity->vy);
+      patch(entityUpdate.ax, entity->ax);
+      patch(entityUpdate.ay, entity->ay);
+      patch(entityUpdate.mass, entity->mass);
     }
 
     __android_log_print(ANDROID_LOG_INFO, "GameMethods",
-                        "update: patched %zu entities for id=%s",
-                        resolvedEntitiesInternals.size(), update.id.c_str());
+                        "entityUpdateEntities: patched %zu entities for id=%s",
+                        resolvedEntitiesInternals.size(),
+                        entityUpdate.id.c_str());
   }
 }
 
+void GameMethods::updateScreen(const ScreenUpdate &screenUpdate) {
+  auto &instance = GameLoop::getInstance();
+  std::lock_guard<std::mutex> lock(instance.getMutexInternal());
+  auto &screen = instance.getScreenInternal();
+
+  patch(screenUpdate.px, screen.px);
+  patch(screenUpdate.py, screen.py);
+  patch(screenUpdate.width, screen.width);
+  patch(screenUpdate.height, screen.height);
+  patch(screenUpdate.asset, screen.asset);
+  patch(screenUpdate.progress, screen.progress);
+  patch(screenUpdate.speed, screen.speed);
+  patch(screenUpdate.color, screen.color);
+  patch(screenUpdate.flipH, screen.flipH);
+  patch(screenUpdate.flipV, screen.flipV);
+
+  __android_log_print(ANDROID_LOG_INFO, "GameMethods",
+                      "updateScreen: patched screen");
+}
+
 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();
+    auto &imageCache = gameRenderer.getImageCacheInternal();
+    auto it = imageCache.find(id);
+    return it != imageCache.end();
   }
 
   if (id < 0) {
@@ -213,53 +212,86 @@ GameMethods::loadLottie(double id, const std::string &jsonStr) {
   });
 };
 
-std::shared_ptr<Promise<bool>> GameMethods::loadSvg(double id,
-                                                    const std::string &svgUri) {
+std::shared_ptr<Promise<bool>>
+GameMethods::loadImage(double id, const std::string &imageUri) {
   return Promise<bool>::async([=]() -> bool {
-    std::string svgStr;
+    __android_log_print(ANDROID_LOG_DEBUG, "GameMethods",
+                        "loadImage: start id=%.0f uri=%s", id,
+                        imageUri.c_str());
+    std::string imageStr;
 
     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) {
+    try {
+      ThreadScope::WithClassLoader([&] {
+        static const auto helperClass =
+            findClassStatic("com/margelo/nitro/rngine/ImageLoaderHelper");
+
+        local_ref<JArrayByte> byteArray;
+
+        if (imageUri.rfind("http://", 0) == 0 ||
+            imageUri.rfind("https://", 0) == 0) {
+          static const auto method =
+              helperClass->getStaticMethod<JArrayByte(local_ref<JString>)>(
+                  "loadFromUrl");
+          byteArray = method(helperClass, make_jstring(imageUri));
+        } else {
+          static const auto method =
+              helperClass->getStaticMethod<JArrayByte(local_ref<JString>)>(
+                  "loadFromResource");
+          byteArray = method(helperClass, make_jstring(imageUri));
+        }
+
+        if (!byteArray) {
+          throw std::runtime_error("Failed to load image bytes for: " +
+                                   imageUri);
+        }
+
+        size_t len = byteArray->size();
+        imageStr.resize(len);
+        byteArray->getRegion(0, len,
+                             reinterpret_cast<int8_t *>(imageStr.data()));
+      });
+    } catch (const std::exception &e) {
+      __android_log_print(ANDROID_LOG_ERROR, "GameMethods",
+                          "loadImage: JNI fetch failed id=%.0f: %s", id,
+                          e.what());
       return false;
     }
 
+    __android_log_print(ANDROID_LOG_DEBUG, "GameMethods",
+                        "loadImage: fetched %zu bytes id=%.0f", imageStr.size(),
+                        id);
+
     auto &gameRenderer = GameRenderer::getInstance();
-    auto &svgCache = gameRenderer.getSvgCacheInternal();
+    auto &imageCache = gameRenderer.getImageCacheInternal();
 
-    svgCache[id] = std::move(svgDom);
+    auto stream = SkMemoryStream::MakeDirect(imageStr.data(), imageStr.size());
+    auto svgDom = SkSVGDOM::MakeFromStream(*stream);
 
-    return true;
+    if (svgDom) {
+      __android_log_print(ANDROID_LOG_DEBUG, "GameMethods",
+                          "loadImage: parsed as SVG id=%.0f", id);
+      imageCache[id] = std::move(svgDom);
+      return true;
+    }
+
+    auto data = SkData::MakeWithCopy(imageStr.data(), imageStr.size());
+    auto raster = SkImages::DeferredFromEncodedData(std::move(data));
+
+    if (raster) {
+      __android_log_print(ANDROID_LOG_DEBUG, "GameMethods",
+                          "loadImage: parsed as raster id=%.0f", id);
+      imageCache[id] = std::move(raster);
+      return true;
+    }
+
+    __android_log_print(ANDROID_LOG_ERROR, "GameMethods",
+                        "loadImage: both SVG parse and raster decode failed "
+                        "id=%.0f",
+                        id);
+
+    return false;
   });
 };
 } // namespace margelo::nitro::rngine