rngine 0.8.0 → 0.8.2

package/shared/GameLoop.cpp

@@ -2,9 +2,11 @@
 #include "Collision.hpp"
 #include "CollisionUtils.hpp"
 #include "Entity.hpp"
+#include "GameRenderer.hpp"
 #include <android/log.h>
 #include <chrono>
 #include <cinttypes>
+#include <mutex>
 
 namespace margelo::nitro::rngine {
 
@@ -56,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;
 
@@ -72,6 +66,8 @@ void GameLoop::runGameLoop() {
   auto previousTime = steady_clock::now();
   double accumulator = 0.0;
 
+  auto &gameRenderer = GameRenderer::getInstance();
+
   while (_isRunning) {
     double targetDeltaTime;
     {
@@ -95,6 +91,11 @@ void GameLoop::runGameLoop() {
       }
     }
 
+    {
+      std::lock_guard<std::mutex> lock(_mutex);
+      gameRenderer.render(_screen, _entities);
+    }
+
     std::this_thread::sleep_for(milliseconds(1));
   }
 
@@ -145,20 +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) {
@@ -169,21 +162,39 @@ 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) {
+      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();
+  }
+}
+
 void GameLoop::updateEntities(double deltaTime) {
   std::lock_guard<std::mutex> worldLock(_worldMutex);
   std::lock_guard<std::mutex> lock(_mutex);
@@ -214,11 +225,18 @@ 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) {
+        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();
     }
   }
 }

package/shared/GameLoop.hpp

@@ -23,36 +23,26 @@ public:
 
   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);
 
 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};
   World _world;
   Screen _screen;
-  Screen _screenSnapshot;
   GameStats _gameStats;
   std::unique_ptr<std::thread> _gameThread;
 
@@ -60,9 +50,9 @@ private:
   void runSystems();
   void computeCollisions();
   void resolveCollisions();
-  void captureSnapshot();
   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,7 +1,10 @@
 #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::setWorld(const World &world) {
@@ -15,9 +18,7 @@ void GameMethods::setWorld(const World &world) {
 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",
                       "setScreen: width=%.0f height=%.0f", screen.width,
@@ -27,14 +28,10 @@ void GameMethods::setScreen(const Screen &screen) {
 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());
@@ -140,9 +137,18 @@ void GameMethods::update(const std::vector<EntityUpdate> &updates) {
       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();
       }
@@ -165,4 +171,95 @@ 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 resourceProvider = skresources::DataURIResourceProviderProxy::Make(
+        nullptr, skresources::ImageDecodeStrategy::kLazyDecode);
+
+    auto animation = skottie::Animation::Builder()
+                         .setResourceProvider(resourceProvider)
+                         .make(jsonStr.data(), jsonStr.size());
+
+    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

package/shared/GameMethods.hpp

@@ -7,14 +7,31 @@ namespace margelo::nitro::rngine {
 class GameMethods : public HybridGameMethodsSpec {
 public:
   GameMethods() : HybridObject(TAG) {}
+
   void setWorld(const World &world) override;
+
   void setScreen(const Screen &screen) override;
+
   void setEntities(const std::vector<Entity> &entities) override;
+
   void setSystems(const std::vector<System> &systems) override;
+
   void pause() override;
+
   void resume() override;
+
   void spawn(const std::vector<Entity> &entities) override;
+
   void despawn(const std::string &id) override;
+
   void update(const std::vector<EntityUpdate> &updates) override;
+
+  bool isAssetLoaded(double id) override;
+
+  std::shared_ptr<Promise<bool>>
+  loadLottie(double id, const std::string &jsonStr) override;
+
+  std::shared_ptr<Promise<bool>> loadSvg(double id,
+                                         const std::string &svgUri) override;
 };
 } // namespace margelo::nitro::rngine