rngine 0.11.2 → 0.11.4

package/shared/custom/System.hpp

@@ -0,0 +1,166 @@
+#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 "CollisionPair.hpp"
+#include "SystemContext.hpp"
+#include <NitroModules/Promise.hpp>
+#include <functional>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::rngine {
+
+struct System final {
+public:
+  std::optional<bool> world SWIFT_PRIVATE;
+  std::optional<bool> screen SWIFT_PRIVATE;
+  std::optional<std::vector<std::string>> entities SWIFT_PRIVATE;
+  std::optional<std::vector<CollisionPair>> collisions SWIFT_PRIVATE;
+  std::function<std::shared_ptr<Promise<void>>(const SystemContext &)> onTick
+      SWIFT_PRIVATE;
+
+public:
+  System() = default;
+  explicit System(
+      std::optional<bool> world, std::optional<bool> screen,
+      std::optional<std::vector<std::string>> entities,
+      std::optional<std::vector<CollisionPair>> collisions,
+      std::function<std::shared_ptr<Promise<void>>(const SystemContext &)>
+          onTick)
+      : world(world), screen(screen), entities(entities),
+        collisions(collisions), onTick(onTick) {}
+};
+
+} // namespace margelo::nitro::rngine
+
+namespace margelo::nitro {
+
+template <> struct JSIConverter<rngine::System> final {
+  using OnTick = std::function<std::shared_ptr<Promise<void>>(
+      const rngine::SystemContext &)>;
+
+  static inline OnTick makeOnTick(jsi::Runtime &runtime,
+                                  const jsi::Value &value) {
+    jsi::Function fn = value.asObject(runtime).asFunction(runtime);
+
+    BorrowingReference<jsi::Function> shared;
+    {
+      JSICacheReference cache = JSICache::getOrCreateCache(runtime);
+      shared = cache.makeShared(std::move(fn));
+    }
+
+    SyncJSCallback<void(const rngine::SystemContext &)> sync(runtime,
+                                                             std::move(shared));
+    auto dispatcher = Dispatcher::getRuntimeGlobalDispatcher(runtime);
+    AsyncJSCallback<void(const rngine::SystemContext &)> async(std::move(sync),
+                                                               dispatcher);
+
+    return [async = std::move(async)](const rngine::SystemContext &ctx) {
+      return async.call(ctx);
+    };
+  }
+
+  static inline rngine::System fromJSI(jsi::Runtime &runtime,
+                                       const jsi::Value &arg) {
+    jsi::Object obj = arg.asObject(runtime);
+    return rngine::System(
+        JSIConverter<std::optional<bool>>::fromJSI(
+            runtime,
+            obj.getProperty(runtime, PropNameIDCache::get(runtime, "world"))),
+        JSIConverter<std::optional<bool>>::fromJSI(
+            runtime,
+            obj.getProperty(runtime, PropNameIDCache::get(runtime, "screen"))),
+        JSIConverter<std::optional<std::vector<std::string>>>::fromJSI(
+            runtime, obj.getProperty(
+                         runtime, PropNameIDCache::get(runtime, "entities"))),
+        JSIConverter<std::optional<std::vector<rngine::CollisionPair>>>::
+            fromJSI(runtime,
+                    obj.getProperty(
+                        runtime, PropNameIDCache::get(runtime, "collisions"))),
+        makeOnTick(runtime, obj.getProperty(runtime, PropNameIDCache::get(
+                                                         runtime, "onTick"))));
+  }
+
+  static inline jsi::Value toJSI(jsi::Runtime &runtime,
+                                 const rngine::System &arg) {
+    jsi::Object obj(runtime);
+    obj.setProperty(
+        runtime, PropNameIDCache::get(runtime, "world"),
+        JSIConverter<std::optional<bool>>::toJSI(runtime, arg.world));
+    obj.setProperty(
+        runtime, PropNameIDCache::get(runtime, "screen"),
+        JSIConverter<std::optional<bool>>::toJSI(runtime, arg.screen));
+    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<rngine::CollisionPair>>>::toJSI(
+            runtime, arg.collisions));
+    obj.setProperty(
+        runtime, PropNameIDCache::get(runtime, "onTick"),
+        JSIConverter<std::function<std::shared_ptr<Promise<void>>(
+            const rngine::SystemContext &)>>::toJSI(runtime, arg.onTick));
+    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<bool>>::canConvert(
+            runtime,
+            obj.getProperty(runtime, PropNameIDCache::get(runtime, "world"))))
+      return false;
+    if (!JSIConverter<std::optional<bool>>::canConvert(
+            runtime,
+            obj.getProperty(runtime, PropNameIDCache::get(runtime, "screen"))))
+      return false;
+    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<rngine::CollisionPair>>>::
+            canConvert(runtime,
+                       obj.getProperty(runtime, PropNameIDCache::get(
+                                                    runtime, "collisions"))))
+      return false;
+    if (!JSIConverter<std::function<std::shared_ptr<Promise<void>>(
+            const rngine::SystemContext &)>>::
+            canConvert(runtime,
+                       obj.getProperty(
+                           runtime, PropNameIDCache::get(runtime, "onTick"))))
+      return false;
+
+    return true;
+  }
+};
+
+} // namespace margelo::nitro

package/shared/custom/SystemContext.hpp

@@ -0,0 +1,139 @@
+#pragma once
+
+#include <optional>
+#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 "Collision.hpp"
+#include "Entity.hpp"
+#include "Screen.hpp"
+#include "World.hpp"
+#include <vector>
+
+namespace margelo::nitro::rngine {
+
+struct SystemContext final {
+public:
+  std::optional<World> world SWIFT_PRIVATE;
+  std::optional<Screen> screen SWIFT_PRIVATE;
+  std::optional<std::vector<Entity>> entities SWIFT_PRIVATE;
+  std::optional<std::vector<Collision>> collisions SWIFT_PRIVATE;
+
+public:
+  SystemContext() = default;
+  explicit SystemContext(std::optional<World> world,
+                         std::optional<Screen> screen,
+                         std::optional<std::vector<Entity>> entities,
+                         std::optional<std::vector<Collision>> collisions)
+      : world(world), screen(screen), entities(entities),
+        collisions(collisions) {}
+
+public:
+  friend bool operator==(const SystemContext &lhs,
+                         const SystemContext &rhs) = default;
+};
+
+} // namespace margelo::nitro::rngine
+
+namespace margelo::nitro {
+
+template <> struct JSIConverter<rngine::SystemContext> final {
+  static inline rngine::SystemContext fromJSI(jsi::Runtime &runtime,
+                                              const jsi::Value &arg) {
+    jsi::Object obj = arg.asObject(runtime);
+
+    return rngine::SystemContext(
+        JSIConverter<std::optional<rngine::World>>::fromJSI(
+            runtime,
+            obj.getProperty(runtime, PropNameIDCache::get(runtime, "world"))),
+        JSIConverter<std::optional<rngine::Screen>>::fromJSI(
+            runtime,
+            obj.getProperty(runtime, PropNameIDCache::get(runtime, "screen"))),
+        JSIConverter<std::optional<std::vector<rngine::Entity>>>::fromJSI(
+            runtime, obj.getProperty(
+                         runtime, PropNameIDCache::get(runtime, "entities"))),
+        JSIConverter<std::optional<std::vector<rngine::Collision>>>::fromJSI(
+            runtime, obj.getProperty(runtime, PropNameIDCache::get(
+                                                  runtime, "collisions"))));
+  }
+
+  static inline jsi::Value toJSI(jsi::Runtime &runtime,
+                                 const rngine::SystemContext &arg) {
+    jsi::Object obj(runtime);
+
+    obj.setProperty(
+        runtime, PropNameIDCache::get(runtime, "world"),
+        JSIConverter<std::optional<rngine::World>>::toJSI(runtime, arg.world));
+
+    obj.setProperty(runtime, PropNameIDCache::get(runtime, "screen"),
+                    JSIConverter<std::optional<rngine::Screen>>::toJSI(
+                        runtime, arg.screen));
+
+    obj.setProperty(
+        runtime, PropNameIDCache::get(runtime, "entities"),
+        JSIConverter<std::optional<std::vector<rngine::Entity>>>::toJSI(
+            runtime, arg.entities));
+
+    obj.setProperty(
+        runtime, PropNameIDCache::get(runtime, "collisions"),
+        JSIConverter<std::optional<std::vector<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<std::optional<rngine::World>>::canConvert(
+            runtime,
+            obj.getProperty(runtime, PropNameIDCache::get(runtime, "world"))))
+      return false;
+
+    if (!JSIConverter<std::optional<rngine::Screen>>::canConvert(
+            runtime,
+            obj.getProperty(runtime, PropNameIDCache::get(runtime, "screen"))))
+      return false;
+
+    if (!JSIConverter<std::optional<std::vector<rngine::Entity>>>::canConvert(
+            runtime, obj.getProperty(
+                         runtime, PropNameIDCache::get(runtime, "entities"))))
+      return false;
+
+    if (!JSIConverter<std::optional<std::vector<rngine::Collision>>>::
+            canConvert(runtime,
+                       obj.getProperty(runtime, PropNameIDCache::get(
+                                                    runtime, "collisions"))))
+      return false;
+
+    return true;
+  }
+};
+
+} // namespace margelo::nitro

package/shared/utils/AssetUtils.cpp

@@ -1,6 +1,7 @@
 #include "AssetUtils.hpp"
 #include "FitTransform.hpp"
 #include "GameRenderer.hpp"
+#include "include/core/SkPictureRecorder.h"
 #include <variant>
 
 namespace margelo::nitro::rngine::AssetUtils {
@@ -84,7 +85,10 @@ static void drawSVG(SkCanvas *canvas, const sk_sp<SkSVGDOM> &svg,
 
   SkAutoCanvasRestore restore(canvas, true);
 
-  bool isRepeating = (repeat != Repeat::NO_REPEAT);
+  bool isRepeating = (repeat != Repeat::NO_REPEAT) &&
+                     (objectFit != ObjectFit::FILL) &&
+                     (objectFit != ObjectFit::COVER);
+
   bool shouldClip = clip && (objectFit == ObjectFit::COVER ||
                              objectFit == ObjectFit::NONE || isRepeating);
 
@@ -99,30 +103,35 @@ static void drawSVG(SkCanvas *canvas, const sk_sp<SkSVGDOM> &svg,
     return;
   }
 
-  float startX = (repeat == Repeat::REPEAT || repeat == Repeat::REPEAT_X)
-                     ? computeCenteredTileStart(targetWidth, tileW)
-                     : tf.translateX;
+  SkPictureRecorder recorder;
+  SkCanvas *recordingCanvas =
+      recorder.beginRecording(intrinsicSize.width(), intrinsicSize.height());
+  svg->render(recordingCanvas);
+  sk_sp<SkPicture> picture = recorder.finishRecordingAsPicture();
 
-  float startY = (repeat == Repeat::REPEAT || repeat == Repeat::REPEAT_Y)
-                     ? computeCenteredTileStart(targetHeight, tileH)
-                     : tf.translateY;
+  bool repX = (repeat == Repeat::REPEAT || repeat == Repeat::REPEAT_X);
+  bool repY = (repeat == Repeat::REPEAT || repeat == Repeat::REPEAT_Y);
 
-  float endX = (repeat == Repeat::REPEAT || repeat == Repeat::REPEAT_X)
-                   ? targetWidth
-                   : (startX + tileW);
+  SkTileMode tileX = repX ? SkTileMode::kRepeat : SkTileMode::kDecal;
+  SkTileMode tileY = repY ? SkTileMode::kRepeat : SkTileMode::kDecal;
 
-  float endY = (repeat == Repeat::REPEAT || repeat == Repeat::REPEAT_Y)
-                   ? targetHeight
-                   : (startY + tileH);
+  float offsetX =
+      repX ? computeCenteredTileStart(targetWidth, tileW) : tf.translateX;
+  float offsetY =
+      repY ? computeCenteredTileStart(targetHeight, tileH) : tf.translateY;
 
-  for (float y = startY; y < endY; y += tileH) {
-    for (float x = startX; x < endX; x += tileW) {
-      SkAutoCanvasRestore tileRestore(canvas, true);
-      canvas->translate(x, y);
-      canvas->scale(tf.scaleX, tf.scaleY);
-      svg->render(canvas);
-    }
-  }
+  SkMatrix localMatrix;
+  localMatrix.setScale(tf.scaleX, tf.scaleY);
+  localMatrix.postTranslate(offsetX, offsetY);
+
+  SkRect tileBounds =
+      SkRect::MakeWH(intrinsicSize.width(), intrinsicSize.height());
+  sk_sp<SkShader> shader = picture->makeShader(
+      tileX, tileY, SkFilterMode::kLinear, &localMatrix, &tileBounds);
+
+  SkPaint paint;
+  paint.setShader(shader);
+  canvas->drawRect(SkRect::MakeWH(targetWidth, targetHeight), paint);
 }
 
 static void drawRaster(SkCanvas *canvas, const sk_sp<SkImage> &raster,
@@ -138,7 +147,10 @@ static void drawRaster(SkCanvas *canvas, const sk_sp<SkImage> &raster,
 
   SkAutoCanvasRestore restore(canvas, true);
 
-  bool isRepeating = (repeat != Repeat::NO_REPEAT);
+  bool isRepeating = (repeat != Repeat::NO_REPEAT) &&
+                     (objectFit != ObjectFit::FILL) &&
+                     (objectFit != ObjectFit::COVER);
+
   bool shouldClip = clip && (objectFit == ObjectFit::COVER ||
                              objectFit == ObjectFit::NONE || isRepeating);
 
@@ -155,31 +167,25 @@ static void drawRaster(SkCanvas *canvas, const sk_sp<SkImage> &raster,
     return;
   }
 
-  SkTileMode tileX = (repeat == Repeat::REPEAT || repeat == Repeat::REPEAT_X)
-                         ? SkTileMode::kRepeat
-                         : SkTileMode::kClamp;
-  SkTileMode tileY = (repeat == Repeat::REPEAT || repeat == Repeat::REPEAT_Y)
-                         ? SkTileMode::kRepeat
-                         : SkTileMode::kClamp;
+  bool repX = (repeat == Repeat::REPEAT || repeat == Repeat::REPEAT_X);
+  bool repY = (repeat == Repeat::REPEAT || repeat == Repeat::REPEAT_Y);
+
+  SkTileMode tileX = repX ? SkTileMode::kRepeat : SkTileMode::kDecal;
+  SkTileMode tileY = repY ? SkTileMode::kRepeat : SkTileMode::kDecal;
 
   float tileW = intrinsicW * tf.scaleX;
   float tileH = intrinsicH * tf.scaleY;
 
-  SkMatrix localMatrix = SkMatrix::Scale(tf.scaleX, tf.scaleY);
-
-  float offsetX = (repeat == Repeat::REPEAT || repeat == Repeat::REPEAT_X)
-                      ? computeCenteredTileStart(targetWidth, tileW)
-                      : tf.translateX;
-  float offsetY = (repeat == Repeat::REPEAT || repeat == Repeat::REPEAT_Y)
-                      ? computeCenteredTileStart(targetHeight, tileH)
-                      : tf.translateY;
+  float offsetX =
+      repX ? computeCenteredTileStart(targetWidth, tileW) : tf.translateX;
+  float offsetY =
+      repY ? computeCenteredTileStart(targetHeight, tileH) : tf.translateY;
 
+  SkMatrix localMatrix = SkMatrix::Scale(tf.scaleX, tf.scaleY);
   localMatrix.postTranslate(offsetX, offsetY);
 
-  auto shader = raster->makeShader(tileX, tileY, sampling, localMatrix);
-
   SkPaint paint;
-  paint.setShader(shader);
+  paint.setShader(raster->makeShader(tileX, tileY, sampling, localMatrix));
   canvas->drawRect(SkRect::MakeWH(targetWidth, targetHeight), paint);
 }
 
@@ -207,7 +213,10 @@ static void drawLottie(SkCanvas *canvas,
 
   SkAutoCanvasRestore restore(canvas, true);
 
-  bool isRepeating = (repeat != Repeat::NO_REPEAT);
+  bool isRepeating = (repeat != Repeat::NO_REPEAT) &&
+                     (objectFit != ObjectFit::FILL) &&
+                     (objectFit != ObjectFit::COVER);
+
   bool shouldClip = clip && (objectFit == ObjectFit::COVER ||
                              objectFit == ObjectFit::NONE || isRepeating);
 
@@ -224,28 +233,34 @@ static void drawLottie(SkCanvas *canvas,
     return;
   }
 
-  float startX = (repeat == Repeat::REPEAT || repeat == Repeat::REPEAT_X)
-                     ? computeCenteredTileStart(targetWidth, tileW)
-                     : tf.translateX;
-  float startY = (repeat == Repeat::REPEAT || repeat == Repeat::REPEAT_Y)
-                     ? computeCenteredTileStart(targetHeight, tileH)
-                     : tf.translateY;
-
-  float endX = (repeat == Repeat::REPEAT || repeat == Repeat::REPEAT_X)
-                   ? targetWidth
-                   : (startX + tileW);
-  float endY = (repeat == Repeat::REPEAT || repeat == Repeat::REPEAT_Y)
-                   ? targetHeight
-                   : (startY + tileH);
-
-  for (float y = startY; y < endY; y += tileH) {
-    for (float x = startX; x < endX; x += tileW) {
-      SkAutoCanvasRestore tileRestore(canvas, true);
-      canvas->translate(x, y);
-      canvas->scale(tf.scaleX, tf.scaleY);
-      lottie->render(canvas, &dstBounds);
-    }
-  }
+  SkPictureRecorder recorder;
+  SkCanvas *recordingCanvas =
+      recorder.beginRecording(intrinsicWidth, intrinsicHeight);
+  lottie->render(recordingCanvas, &dstBounds);
+  sk_sp<SkPicture> picture = recorder.finishRecordingAsPicture();
+
+  bool repX = (repeat == Repeat::REPEAT || repeat == Repeat::REPEAT_X);
+  bool repY = (repeat == Repeat::REPEAT || repeat == Repeat::REPEAT_Y);
+
+  SkTileMode tileX = repX ? SkTileMode::kRepeat : SkTileMode::kDecal;
+  SkTileMode tileY = repY ? SkTileMode::kRepeat : SkTileMode::kDecal;
+
+  float offsetX =
+      repX ? computeCenteredTileStart(targetWidth, tileW) : tf.translateX;
+  float offsetY =
+      repY ? computeCenteredTileStart(targetHeight, tileH) : tf.translateY;
+
+  SkMatrix localMatrix;
+  localMatrix.setScale(tf.scaleX, tf.scaleY);
+  localMatrix.postTranslate(offsetX, offsetY);
+
+  SkRect tileBounds = SkRect::MakeWH(intrinsicWidth, intrinsicHeight);
+  sk_sp<SkShader> shader = picture->makeShader(
+      tileX, tileY, SkFilterMode::kLinear, &localMatrix, &tileBounds);
+
+  SkPaint paint;
+  paint.setShader(shader);
+  canvas->drawRect(SkRect::MakeWH(targetWidth, targetHeight), paint);
 }
 
 void drawAsset(SkCanvas *canvas, double asset, float targetWidth,

package/src/GameMethods.nitro.ts

@@ -6,7 +6,7 @@ import type {
   Screen,
   World,
   ScreenUpdate,
-} from './nativeTypes';
+} from './types';
 import { NitroModules } from 'react-native-nitro-modules';
 
 interface GameMethods extends HybridObject<{

package/src/GameMethods.ts

@@ -1,5 +1,5 @@
 import { gameMethods } from './GameMethods.nitro';
-import type { Entity, EntityUpdate, ScreenUpdate, System } from './nativeTypes';
+import type { Entity, EntityUpdate, ScreenUpdate } from './types';
 import type { Config } from './types';
 import { Image } from 'react-native';
 
@@ -11,25 +11,10 @@ export const configure = ({
   systems = [],
   paused = true,
 }: Config) => {
-  let nativeSystems: System[] = [];
-
-  for (const system of systems) {
-    nativeSystems.push({
-      entities: system.entities,
-      collisions: system.collisions,
-      onTick: (systemContext) => {
-        const start = Date.now();
-        system.onTick(systemContext);
-        const finish = Date.now();
-        return finish - start;
-      },
-    });
-  }
-
   gameMethods.setWorld(world);
   gameMethods.setScreen(screen);
   gameMethods.setEntities(entities);
-  gameMethods.setSystems(nativeSystems);
+  gameMethods.setSystems(systems);
   if (paused) {
     gameMethods.pause();
   } else {

package/src/index.tsx

@@ -2,13 +2,4 @@ import GameEngine from './GameEngine';
 
 export * from './GameMethods';
 export * from './types';
-export type {
-  World,
-  Screen,
-  Entity,
-  CollisionPair,
-  Collision,
-  EntityUpdate,
-  SystemContext,
-} from './nativeTypes';
 export { GameEngine };