rngine 0.8.3 → 0.9.0

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.3",
+  "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

@@ -106,73 +106,71 @@ 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();
 

package/shared/GameMethods.hpp

@@ -24,7 +24,9 @@ public:
 
   void despawn(const std::string &id) override;
 
-  void update(const std::vector<EntityUpdate> &updates) override;
+  void updateEntities(const std::vector<EntityUpdate> &entityUpdates) override;
+
+  void updateScreen(const ScreenUpdate &screenUpdate) override;
 
   bool isAssetLoaded(double id) override;
 

package/shared/GameRenderer.cpp

@@ -1,4 +1,5 @@
 #include "GameRenderer.hpp"
+#include "AssetUtils.hpp"
 #include "ColorUtils.hpp"
 #include "Rect.hpp"
 
@@ -20,7 +21,6 @@
 
 #include "include/gpu/ganesh/gl/GrGLDirectContext.h"
 #include "include/gpu/ganesh/gl/GrGLInterface.h"
-#include "modules/svg/include/SkSVGDOM.h"
 
 #include <EGL/egl.h>
 #include <GLES3/gl3.h>
@@ -135,15 +135,20 @@ void GameRenderer::render(const Screen &screen,
 
   float scale = std::min(scaleX, scaleY);
 
-  float offsetX = (static_cast<float>(_width) - (virtualWidth * scale)) * 0.5f;
-  float offsetY =
-      (static_cast<float>(_height) - (virtualHeight * scale)) * 0.5f;
+  float offsetX =
+      static_cast<float>(_width) * 0.5f - static_cast<float>(screen.px) * scale;
+  float offsetY = static_cast<float>(_height) * 0.5f -
+                  static_cast<float>(screen.py) * scale;
 
   canvas->save();
   canvas->translate(offsetX, offsetY);
   canvas->scale(scale, scale);
 
-  SkRect gameBounds = SkRect::MakeWH(virtualWidth, virtualHeight);
+  SkRect gameBounds =
+      SkRect::MakeXYWH(static_cast<float>(screen.px) - virtualWidth * 0.5f,
+                       static_cast<float>(screen.py) - virtualHeight * 0.5f,
+                       virtualWidth, virtualHeight);
+
   canvas->clipRect(gameBounds);
 
   if (screen.color.has_value()) {
@@ -151,73 +156,16 @@ void GameRenderer::render(const Screen &screen,
   }
 
   if (screen.asset.has_value() && screen.asset.value() != 0) {
-    double assetId = screen.asset.value();
-
-    auto imageIt = _imageCache.find(assetId);
-    if (imageIt != _imageCache.end()) {
-      std::visit(
-          [&](const auto image) {
-            using T = std::decay_t<decltype(image)>;
-            if constexpr (std::is_same_v<T, sk_sp<SkSVGDOM>>) {
-              SkSize intrinsicSize = image->containerSize();
-
-              if (intrinsicSize.isEmpty()) {
-                image->setContainerSize(
-                    SkSize::Make(virtualWidth, virtualHeight));
-                intrinsicSize = SkSize::Make(virtualWidth, virtualHeight);
-              }
-
-              float scaleX = virtualWidth / intrinsicSize.width();
-              float scaleY = virtualHeight / intrinsicSize.height();
-
-              canvas->save();
-              if (screen.flipH.has_value() || screen.flipV.has_value()) {
-                canvas->translate(virtualWidth / 2.f, virtualHeight / 2.f);
-                canvas->scale(screen.flipH.value_or(false) ? -1.f : 1.f,
-                              screen.flipV.value_or(false) ? -1.f : 1.f);
-                canvas->translate(-virtualWidth / 2.f, -virtualHeight / 2.f);
-              }
-              canvas->scale(scaleX, scaleY);
-              image->render(canvas);
-              canvas->restore();
-            } else {
-              float intrinsicW = static_cast<float>(image->width());
-              float intrinsicH = static_cast<float>(image->height());
-              if (intrinsicW <= 0.f || intrinsicH <= 0.f)
-                return;
-
-              float scaleX = virtualWidth / intrinsicW;
-              float scaleY = virtualHeight / intrinsicH;
-
-              canvas->save();
-              if (screen.flipH.has_value() || screen.flipV.has_value()) {
-                canvas->translate(virtualWidth / 2.f, virtualHeight / 2.f);
-                canvas->scale(screen.flipH.value_or(false) ? -1.f : 1.f,
-                              screen.flipV.value_or(false) ? -1.f : 1.f);
-                canvas->translate(-virtualWidth / 2.f, -virtualHeight / 2.f);
-              }
-              canvas->scale(scaleX, scaleY);
-
-              SkSamplingOptions sampling(SkFilterMode::kLinear,
-                                         SkMipmapMode::kLinear);
-              canvas->drawImage(image, 0.f, 0.f, sampling);
-              canvas->restore();
-            }
-          },
-          imageIt->second);
-    } else {
-      auto lottieIt = _lottieCache.find(assetId);
-      if (lottieIt != _lottieCache.end() && lottieIt->second) {
-        auto &lottie = lottieIt->second;
-        lottie->seek(screen.progress.value_or(0.0));
-        SkRect dstBounds = SkRect::MakeWH(virtualWidth, virtualHeight);
-        lottie->render(canvas, &dstBounds);
-      }
-    }
+    SkAutoCanvasRestore restore(canvas, true);
+    canvas->translate(gameBounds.left(), gameBounds.top());
+    AssetUtils::drawAsset(canvas, screen.asset.value(), virtualWidth,
+                          virtualHeight, screen.flipH.value_or(false),
+                          screen.flipV.value_or(false),
+                          screen.progress.value_or(0.0));
   }
 
   for (const auto &[id, entity] : entities) {
-    if (!isEntityVisible(entity, virtualWidth, virtualHeight)) {
+    if (!isEntityVisible(entity, gameBounds)) {
       continue;
     }
 
@@ -250,8 +198,6 @@ void GameRenderer::render(const Screen &screen,
       }
 
       if ((entity.asset.has_value() && entity.asset.value() != 0)) {
-        double assetId = entity.asset.value();
-
         float width = 0.f, height = 0.f;
         std::visit(
             [&](const auto &shape) {
@@ -270,59 +216,10 @@ void GameRenderer::render(const Screen &screen,
         SkAutoCanvasRestore autoRestore(canvas, true);
         canvas->translate(px - width / 2, py - height / 2);
 
-        if (entity.flipH.has_value() || entity.flipV.has_value()) {
-          canvas->translate(width / 2.f, height / 2.f);
-          canvas->scale(entity.flipH.value_or(false) ? -1.f : 1.f,
-                        entity.flipV.value_or(false) ? -1.f : 1.f);
-          canvas->translate(-width / 2.f, -height / 2.f);
-        }
-
-        auto imageIt = _imageCache.find(assetId);
-        if (imageIt != _imageCache.end()) {
-          std::visit(
-              [&](const auto image) {
-                using T = std::decay_t<decltype(image)>;
-                if constexpr (std::is_same_v<T, sk_sp<SkSVGDOM>>) {
-                  SkSize intrinsicSize = image->containerSize();
-                  if (intrinsicSize.isEmpty()) {
-                    image->setContainerSize(SkSize::Make(width, height));
-                    intrinsicSize = SkSize::Make(width, height);
-                  }
-
-                  float scaleX = width / intrinsicSize.width();
-                  float scaleY = height / intrinsicSize.height();
-
-                  canvas->save();
-                  canvas->scale(scaleX, scaleY);
-                  image->render(canvas);
-                  canvas->restore();
-                } else {
-                  float intrinsicW = static_cast<float>(image->width());
-                  float intrinsicH = static_cast<float>(image->height());
-                  if (intrinsicW <= 0.f || intrinsicH <= 0.f)
-                    return;
-
-                  float scaleX = width / intrinsicW;
-                  float scaleY = height / intrinsicH;
-
-                  canvas->save();
-                  canvas->scale(scaleX, scaleY);
-                  SkSamplingOptions sampling(SkFilterMode::kLinear,
-                                             SkMipmapMode::kLinear);
-                  canvas->drawImage(image, 0.f, 0.f, sampling);
-                  canvas->restore();
-                }
-              },
-              imageIt->second);
-        } else {
-          auto lottieIt = _lottieCache.find(assetId);
-          if (lottieIt != _lottieCache.end() && lottieIt->second) {
-            auto &lottie = lottieIt->second;
-            lottie->seek(entity.progress.value_or(0.0));
-            SkRect dstBounds = SkRect::MakeWH(width, height);
-            lottie->render(canvas, &dstBounds);
-          }
-        }
+        AssetUtils::drawAsset(canvas, entity.asset.value(), width, height,
+                              entity.flipH.value_or(false),
+                              entity.flipV.value_or(false),
+                              entity.progress.value_or(0.0));
       }
     }
   }
@@ -335,15 +232,13 @@ void GameRenderer::render(const Screen &screen,
   __android_log_print(ANDROID_LOG_DEBUG, "GameRenderer", "render: complete");
 }
 
-bool GameRenderer::isEntityVisible(const Entity &entity, float screenWidth,
-                                   float screenHeight) {
-  float width = 0.f;
-  float height = 0.f;
+bool GameRenderer::isEntityVisible(const Entity &entity,
+                                   const SkRect &viewBounds) {
+  float width = 0.f, height = 0.f;
 
   std::visit(
       [&](const auto &shape) {
         using T = std::decay_t<decltype(shape)>;
-
         if constexpr (std::is_same_v<T, Rect>) {
           width = static_cast<float>(shape.width);
           height = static_cast<float>(shape.height);
@@ -358,8 +253,8 @@ bool GameRenderer::isEntityVisible(const Entity &entity, float screenWidth,
   float top = static_cast<float>(entity.py) - height / 2.f;
   float bottom = static_cast<float>(entity.py) + height / 2.f;
 
-  return right > 0.f && left < screenWidth && bottom > 0.f &&
-         top < screenHeight;
+  return right > viewBounds.left() && left < viewBounds.right() &&
+         bottom > viewBounds.top() && top < viewBounds.bottom();
 }
 
 bool GameRenderer::initializeEGL() {

package/shared/GameRenderer.hpp

@@ -2,6 +2,7 @@
 #include "Entity.hpp"
 #include "Screen.hpp"
 #include "include/core/SkImage.h"
+#include "include/core/SkRect.h"
 #include "include/core/SkSurface.h"
 #include "include/gpu/ganesh/GrDirectContext.h"
 #include "modules/skottie/include/Skottie.h"
@@ -58,8 +59,7 @@ private:
   std::map<double, sk_sp<skottie::Animation>> _lottieCache;
   std::map<double, std::variant<sk_sp<SkSVGDOM>, sk_sp<SkImage>>> _imageCache;
 
-  bool isEntityVisible(const Entity &entity, float screenWidth,
-                       float screenHeight);
+  bool isEntityVisible(const Entity &entity, const SkRect &viewBounds);
 
   bool initializeEGL();
   bool createEGLSurface();