rngine 0.5.0 → 0.6.0

package/android/src/main/cpp/GameLoopJNI.cpp

@@ -1,36 +1,93 @@
+#include "ColorUtils.hpp"
 #include "GameLoop.hpp"
+#include <cstdint>
 #include <jni.h>
+#include <mutex>
 
 extern "C" {
-JNIEXPORT jobject JNICALL
-Java_com_margelo_nitro_rngine_GameView_getRectsSnapshot(JNIEnv *env, jobject) {
-  auto rects =
-      margelo::nitro::rngine::GameLoop::getInstance().getRectsSnapshot();
-  const size_t size = rects.size() * margelo::nitro::rngine::RECT_SIZE;
-
-  static std::vector<uint8_t> buffer;
-  buffer.resize(size);
-
-  uint8_t *data = buffer.data();
-
-  for (const auto &rect : rects) {
-    memcpy(data, &rect.left, sizeof(float));
-    data += sizeof(float);
-    memcpy(data, &rect.right, sizeof(float));
-    data += sizeof(float);
-    memcpy(data, &rect.top, sizeof(float));
-    data += sizeof(float);
-    memcpy(data, &rect.bottom, sizeof(float));
-    data += sizeof(float);
-    memcpy(data, &rect.progress, sizeof(float));
-    data += sizeof(float);
-    memcpy(data, &rect.color, sizeof(uint32_t));
-    data += sizeof(uint32_t);
-    memcpy(data, &rect.asset, sizeof(int32_t));
-    data += sizeof(int32_t);
+JNIEXPORT jbyteArray JNICALL
+Java_com_margelo_nitro_rngine_GameView_getSnapshot(JNIEnv *env, jobject) {
+  auto &gameLoop = margelo::nitro::rngine::GameLoop::getInstance();
+  auto &snapshotMutex = gameLoop.getSnapshotMutexInternal();
+
+  std::lock_guard<std::mutex> snapshotLock(snapshotMutex);
+  auto &screenSnapshot = gameLoop.getScreenSnapshotInternal();
+  auto &entitiesSnapshot = gameLoop.getEntitiesSnapshotInternal();
+
+  std::vector<uint8_t> buffer;
+
+  auto writeFloat = [&](float v) {
+    const auto *bytes = reinterpret_cast<const uint8_t *>(&v);
+    buffer.insert(buffer.end(), bytes, bytes + sizeof(float));
+  };
+  auto writeI32 = [&](int32_t v) {
+    const auto *bytes = reinterpret_cast<const uint8_t *>(&v);
+    buffer.insert(buffer.end(), bytes, bytes + sizeof(int32_t));
+  };
+  auto writeU32 = [&](uint32_t v) {
+    const auto *bytes = reinterpret_cast<const uint8_t *>(&v);
+    buffer.insert(buffer.end(), bytes, bytes + sizeof(uint32_t));
+  };
+
+  const auto screenSnapshotWidth = static_cast<float>(screenSnapshot.width);
+  const auto screenSnapshotHeight = static_cast<float>(screenSnapshot.height);
+  const auto screenSnapshotColor =
+      margelo::nitro::rngine::parseHexColor(screenSnapshot.color);
+  const auto screenSnapshotAsset =
+      static_cast<int32_t>(screenSnapshot.asset.value_or(0));
+
+  writeFloat(screenSnapshotWidth);
+  writeFloat(screenSnapshotHeight);
+  writeU32(screenSnapshotColor);
+  writeI32(screenSnapshotAsset);
+
+  if (screenSnapshotAsset < 0) {
+    writeFloat(static_cast<float>(screenSnapshot.progress.value_or(0)));
+  }
+
+  for (const auto &[_, entitySnapshot] : entitiesSnapshot) {
+    const auto entitySnapshotLeft =
+        static_cast<float>(entitySnapshot.px - (entitySnapshot.width / 2));
+    const auto entitySnapshotRight =
+        static_cast<float>(entitySnapshot.px + (entitySnapshot.width / 2));
+    const auto entitySnapshotTop =
+        static_cast<float>(entitySnapshot.py - (entitySnapshot.height / 2));
+    const auto entitySnapshotBottom =
+        static_cast<float>(entitySnapshot.py + (entitySnapshot.height / 2));
+
+    if (entitySnapshotRight < 0 || entitySnapshotLeft > screenSnapshot.width ||
+        entitySnapshotBottom < 0 || entitySnapshotTop > screenSnapshot.height) {
+      continue;
+    }
+
+    const auto entitySnapshotColor =
+        margelo::nitro::rngine::parseHexColor(entitySnapshot.color);
+    const auto entitySnapshotAsset =
+        static_cast<int32_t>(entitySnapshot.asset.value_or(0));
+
+    writeFloat(entitySnapshotLeft);
+    writeFloat(entitySnapshotRight);
+    writeFloat(entitySnapshotTop);
+    writeFloat(entitySnapshotBottom);
+    writeU32(entitySnapshotColor);
+    writeI32(entitySnapshotAsset);
+
+    if (entitySnapshotAsset < 0) {
+      writeFloat(static_cast<float>(entitySnapshot.progress.value_or(0)));
+    }
   }
 
-  return env->NewDirectByteBuffer(buffer.data(), (jlong)size);
+  auto bufferSize = static_cast<jsize>(buffer.size());
+  jbyteArray result = env->NewByteArray(bufferSize);
+
+  if (result == nullptr) {
+    return nullptr;
+  }
+
+  env->SetByteArrayRegion(result, 0, bufferSize,
+                          reinterpret_cast<const jbyte *>(buffer.data()));
+
+  return result;
 }
 
 JNIEXPORT void JNICALL

package/android/src/main/java/com/margelo/nitro/rngine/GameAssets.kt

@@ -6,6 +6,7 @@ import com.airbnb.lottie.LottieDrawable
 import com.caverock.androidsvg.SVG
 import com.margelo.nitro.core.Promise
 import java.net.URL
+import com.margelo.nitro.NitroModules
 
 class GameAssets : HybridGameAssetsSpec() {
   private external fun registerLottieDuration(id: Double, duration: Double)
@@ -22,7 +23,16 @@ class GameAssets : HybridGameAssetsSpec() {
   override fun registerSvg(id: Double, uri: String): Promise<Unit> {
     return Promise.async {
       try {
-        val stream = URL(uri).openStream()
+        val stream = if (uri.startsWith("http://") || uri.startsWith("https://")) {
+          URL(uri).openStream()
+        } else {
+          val context = NitroModules.applicationContext ?: throw Error("No Context available!")
+          val resId = context.resources.getIdentifier(uri, "raw", context.packageName)
+          if (resId == 0) {
+            throw IllegalStateException("Could not resolve drawable resource for asset: $uri")
+          }
+          context.resources.openRawResource(resId)
+        }
         assetCache[id.toInt()] = Asset.Svg(SVG.getFromInputStream(stream).renderToPicture())
         Log.d("GameAssets", "assetCache: $assetCache")
       } catch (e: Exception) {

package/android/src/main/java/com/margelo/nitro/rngine/GameView.kt

@@ -4,10 +4,8 @@ import android.content.Context
 import android.graphics.Color
 import android.graphics.Paint
 import android.util.AttributeSet
-import android.util.Log
 import android.view.SurfaceView
 import android.view.View
-import java.nio.ByteBuffer
 import androidx.core.graphics.withTranslation
 import androidx.core.graphics.withClip
 
@@ -20,7 +18,7 @@ class GameView(
   attrs,
   defStyleAttr,
 ) {
-  private external fun getRectsSnapshot(): ByteBuffer
+  private external fun getSnapshot(): ByteArray
   var onAttached: () -> Unit = {}
   var onDetached: () -> Unit = {}
 
@@ -29,6 +27,48 @@ class GameView(
     style = Paint.Style.FILL
   }
 
+  private fun drawRenderable(
+    canvas: android.graphics.Canvas,
+    left: Float,
+    top: Float,
+    right: Float,
+    bottom: Float,
+    color: Int,
+    asset: Int,
+    progress: Float?,
+    clampedLeft: Float = left,
+    clampedTop: Float = top,
+    clampedRight: Float = right,
+    clampedBottom: Float = bottom,
+  ) {
+    paint.color = color
+    canvas.drawRect(clampedLeft, clampedTop, clampedRight, clampedBottom, paint)
+
+    canvas.withClip(clampedLeft, clampedTop, clampedRight, clampedBottom) {
+      withTranslation(left, top) {
+        when (val resolvedAsset = GameAssets.getAsset(asset)) {
+          is Asset.Svg -> {
+            scale(
+              (right - left) / resolvedAsset.picture.width,
+              (bottom - top) / resolvedAsset.picture.height
+            )
+            drawPicture(resolvedAsset.picture)
+          }
+
+          is Asset.Lottie -> {
+            progress?.let {
+              resolvedAsset.drawable.progress = it
+            }
+            resolvedAsset.drawable.setBounds(0, 0, (right - left).toInt(), (bottom - top).toInt())
+            resolvedAsset.drawable.draw(canvas)
+          }
+
+          null -> {}
+        }
+      }
+    }
+  }
+
   init {
     addOnAttachStateChangeListener(
       object : OnAttachStateChangeListener {
@@ -40,61 +80,53 @@ class GameView(
   fun drawFrame() {
     if (!holder.surface.isValid) return
     val canvas = holder.lockCanvas() ?: return
+    val snapshot = SnapshotSerializer.decode(getSnapshot())
 
-    val rects = RectSerializer.decode(getRectsSnapshot())
-
-    val worldRect = rects.first()
-    val scaleX = canvas.width / worldRect.right
-    val scaleY = canvas.height / worldRect.bottom
+    val scaleX = canvas.width / snapshot.screen.width
+    val scaleY = canvas.height / snapshot.screen.height
     val scale = minOf(scaleX, scaleY)
 
-    val offsetX = (canvas.width - worldRect.right * scale) / 2f
-    val offsetY = (canvas.height - worldRect.bottom * scale) / 2f
+    val screenLeft = (canvas.width - snapshot.screen.width * scale) / 2f
+    val screenTop = (canvas.height - snapshot.screen.height * scale) / 2f
+    val screenRight = screenLeft + snapshot.screen.width * scale
+    val screenBottom = screenTop + snapshot.screen.height * scale
+
+    drawRenderable(
+      canvas,
+      screenLeft,
+      screenTop,
+      screenRight,
+      screenBottom,
+      snapshot.screen.color,
+      snapshot.screen.asset,
+      snapshot.screen.progress,
+    )
 
-    rects.forEach { rect ->
-      val left = rect.left * scale + offsetX
-      val top = rect.top * scale + offsetY
-      val right = rect.right * scale + offsetX
-      val bottom = rect.bottom * scale + offsetY
+    snapshot.rects.forEach { rect ->
+      val left = rect.left * scale + screenLeft
+      val top = rect.top * scale + screenTop
+      val right = rect.right * scale + screenLeft
+      val bottom = rect.bottom * scale + screenTop
 
-      val clampedLeft = left.coerceAtLeast(offsetX)
-      val clampedTop = top.coerceAtLeast(offsetY)
-      val clampedRight = right.coerceAtMost(offsetX + worldRect.right * scale)
-      val clampedBottom = bottom.coerceAtMost(offsetY + worldRect.bottom * scale)
+      val clampedLeft = left.coerceAtLeast(screenLeft)
+      val clampedTop = top.coerceAtLeast(screenTop)
+      val clampedRight = right.coerceAtMost(screenLeft + snapshot.screen.width * scale)
+      val clampedBottom = bottom.coerceAtMost(screenTop + snapshot.screen.height * scale)
 
-      paint.color = rect.color
-      canvas.drawRect(
+      drawRenderable(
+        canvas,
+        left,
+        top,
+        right,
+        bottom,
+        rect.color,
+        rect.asset,
+        rect.progress,
         clampedLeft,
         clampedTop,
         clampedRight,
-        clampedBottom,
-        paint
+        clampedBottom
       )
-      when(val asset = GameAssets.getAsset(rect.asset)){
-        is Asset.Svg -> {
-          canvas.withClip(clampedLeft, clampedTop, clampedRight, clampedBottom) {
-            withTranslation(left, top) {
-              scale(
-                (right - left) / asset.picture.width,
-                (bottom - top) / asset.picture.height
-              )
-              drawPicture(asset.picture)
-            }
-          }
-        }
-
-        is Asset.Lottie -> {
-          canvas.withClip(clampedLeft, clampedTop, clampedRight, clampedBottom) {
-            withTranslation(left, top) {
-              asset.drawable.progress = rect.progress
-              asset.drawable.setBounds(0, 0, (right - left).toInt(), (bottom - top).toInt())
-              asset.drawable.draw(canvas)
-            }
-          }
-        }
-
-        null -> {}
-      }
     }
     holder.unlockCanvasAndPost(canvas)
   }

package/android/src/main/java/com/margelo/nitro/rngine/Rect.kt

@@ -5,7 +5,7 @@ data class Rect(
   val right: Float,
   val top: Float,
   val bottom: Float,
-  val progress: Float,
   val color: Int,
-  val asset: Int
+  val asset: Int,
+  val progress: Float?,
 )

package/android/src/main/java/com/margelo/nitro/rngine/Screen.kt

@@ -0,0 +1,9 @@
+package com.margelo.nitro.rngine
+
+data class Screen(
+  val width: Float,
+  val height: Float,
+  val color: Int,
+  val asset: Int,
+  val progress: Float?,
+)

package/android/src/main/java/com/margelo/nitro/rngine/Snapshot.kt

@@ -0,0 +1,3 @@
+package com.margelo.nitro.rngine
+
+data class Snapshot(val screen: Screen, val rects: List<Rect>)

package/android/src/main/java/com/margelo/nitro/rngine/SnapshotSerializer.kt

@@ -0,0 +1,33 @@
+package com.margelo.nitro.rngine
+
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+
+object SnapshotSerializer {
+  fun decode(bytes: ByteArray): Snapshot {
+    val buffer = ByteBuffer.wrap(bytes).order(ByteOrder.nativeOrder())
+
+    val width = buffer.float
+    val height = buffer.float
+    val color = buffer.int
+    val asset = buffer.int
+    val progress = if (asset < 0) buffer.float else null
+
+    val screen = Screen(width, height, color, asset, progress)
+    val rects = ArrayList<Rect>()
+
+    while (buffer.remaining() >= 24) {
+      val left = buffer.float
+      val right = buffer.float
+      val top = buffer.float
+      val bottom = buffer.float
+      val color = buffer.int
+      val asset = buffer.int
+      val progress = if (asset < 0) buffer.float else null
+
+      rects.add(Rect(left, right, top, bottom, color, asset, progress))
+    }
+
+    return Snapshot(screen, rects)
+  }
+}

package/lib/typescript/src/nativeTypes.d.ts

@@ -1,79 +1,60 @@
-export type Screen = {
-    /** Width of the screen in game units. */
-    width: number;
-    /** Height of the screen in game units. */
-    height: number;
-    /** Background color of the screen as a hex string e.g. `'#1a1a1a'`. */
-    color?: string;
-    /** Asset to render, use `require` with the file path to get the id. */
-    asset?: number;
-    /** Animation progress between 0 and 1, automatically advanced each tick for Lottie assets. */
-    progress?: number;
-};
-export type Entity = {
-    /** Unique identifier. Use `_` as a separator for group queries e.g. `'enemy_1'`. */
-    id: string;
+interface Positioned {
     /** X position in game units. */
     px: number;
     /** Y position in game units. */
     py: number;
+}
+interface Shaped {
     /** Width in game units. */
     width: number;
     /** Height in game units. */
     height: number;
+}
+interface Renderable {
     /** Fill color as a hex string e.g. `'#00ff00'`. */
     color?: string;
     /** Asset to render, use `require` with the file path to get the id. */
     asset?: number;
     /** Animation progress between 0 and 1, automatically advanced each tick for Lottie assets. */
     progress?: number;
+}
+interface Kinematic {
     /** Velocity on the X axis in game units per second. */
     vx?: number;
     /** Velocity on the Y axis in game units per second. */
     vy?: number;
-};
-export type CollisionPair = {
+}
+export interface Screen extends Shaped, Renderable {
+}
+export interface Entity extends Positioned, Shaped, Renderable, Kinematic {
+    /** Unique identifier. Use `_` as a separator for group queries e.g. `'enemy_1'`. */
+    id: string;
+}
+export interface EntityUpdate extends Partial<Positioned & Shaped & Renderable & Kinematic> {
+    /** Unique identifier or prefix of the entities to update. */
+    id: string;
+}
+export interface CollisionPair {
     /** Entity id or prefix of the first entity to watch. */
     a: string;
     /** Entity id or prefix of the second entity to watch. */
     b: string;
-};
-export type Collision = {
+}
+export interface Collision {
     /** Id of the first entity involved in the collision. */
     a: string;
     /** Id of the second entity involved in the collision. */
     b: string;
     /** Penetration depth of the collision. */
     depth: number;
-};
-export type System = {
+}
+export interface System {
     /** Entity ids or prefixes this system subscribes to. */
     entities?: string[];
     /** Collision pairs to watch for every tick. */
     collisions?: CollisionPair[];
     /** Called every tick with the resolved entities and collisions. */
     onTick: (entities: Entity[], collisions: Collision[]) => number;
-};
-export type EntityUpdate = {
-    /** Unique identifier or prefix of the entities to update. */
-    id: string;
-    /** X position in game units. */
-    px?: number;
-    /** Y position in game units. */
-    py?: number;
-    /** Width in game units. */
-    width?: number;
-    /** Height in game units. */
-    height?: number;
-    /** Fill color as a hex string e.g. `'#00ff00'`. */
-    color?: string;
-    /** Asset to render, use `require` with the file path to get the id. */
-    asset?: number;
-    /** Animation progress between 0 and 1, automatically advanced each tick for Lottie assets. */
-    progress?: number;
-    /** Velocity on the X axis in game units per second. */
-    vx?: number;
-    /** Velocity on the Y axis in game units per second. */
-    vy?: number;
-};
+}
+export {};
 //# sourceMappingURL=nativeTypes.d.ts.map

package/lib/typescript/src/nativeTypes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nativeTypes.d.ts","sourceRoot":"","sources":["../../../src/nativeTypes.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,MAAM,GAAG;IACnB,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,0CAA0C;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,8FAA8F;IAC9F,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG;IACnB,oFAAoF;IACpF,EAAE,EAAE,MAAM,CAAC;IACX,gCAAgC;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,gCAAgC;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,2BAA2B;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,4BAA4B;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,mDAAmD;IACnD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,8FAA8F;IAC9F,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,uDAAuD;IACvD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,uDAAuD;IACvD,EAAE,CAAC,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,wDAAwD;IACxD,CAAC,EAAE,MAAM,CAAC;IACV,yDAAyD;IACzD,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,wDAAwD;IACxD,CAAC,EAAE,MAAM,CAAC;IACV,yDAAyD;IACzD,CAAC,EAAE,MAAM,CAAC;IACV,0CAA0C;IAC1C,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG;IACnB,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,+CAA+C;IAC/C,UAAU,CAAC,EAAE,aAAa,EAAE,CAAC;IAC7B,mEAAmE;IACnE,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,MAAM,CAAC;CACjE,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,6DAA6D;IAC7D,EAAE,EAAE,MAAM,CAAC;IACX,gCAAgC;IAChC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,gCAAgC;IAChC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,2BAA2B;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4BAA4B;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mDAAmD;IACnD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,8FAA8F;IAC9F,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,uDAAuD;IACvD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,uDAAuD;IACvD,EAAE,CAAC,EAAE,MAAM,CAAC;CACb,CAAC"}
+{"version":3,"file":"nativeTypes.d.ts","sourceRoot":"","sources":["../../../src/nativeTypes.ts"],"names":[],"mappings":"AAAA,UAAU,UAAU;IAClB,gCAAgC;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,gCAAgC;IAChC,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,UAAU,MAAM;IACd,2BAA2B;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,4BAA4B;IAC5B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,UAAU;IAClB,mDAAmD;IACnD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,8FAA8F;IAC9F,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,UAAU,SAAS;IACjB,uDAAuD;IACvD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,uDAAuD;IACvD,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,MAAO,SAAQ,MAAM,EAAE,UAAU;CAAG;AAErD,MAAM,WAAW,MAAO,SAAQ,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS;IACvE,oFAAoF;IACpF,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,YAAa,SAAQ,OAAO,CAC3C,UAAU,GAAG,MAAM,GAAG,UAAU,GAAG,SAAS,CAC7C;IACC,6DAA6D;IAC7D,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,aAAa;IAC5B,wDAAwD;IACxD,CAAC,EAAE,MAAM,CAAC;IACV,yDAAyD;IACzD,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,SAAS;IACxB,wDAAwD;IACxD,CAAC,EAAE,MAAM,CAAC;IACV,yDAAyD;IACzD,CAAC,EAAE,MAAM,CAAC;IACV,0CAA0C;IAC1C,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,MAAM;IACrB,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,+CAA+C;IAC/C,UAAU,CAAC,EAAE,aAAa,EAAE,CAAC;IAC7B,mEAAmE;IACnE,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,MAAM,CAAC;CACjE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rngine",
-  "version": "0.5.0",
+  "version": "0.6.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,6 +1,5 @@
 #include "GameLoop.hpp"
 #include "Collision.hpp"
-#include "ColorUtils.hpp"
 #include "Entity.hpp"
 #include <android/log.h>
 #include <chrono>
@@ -60,37 +59,6 @@ void GameLoop::registerLottieDuration(double id, double duration) {
                       id, duration);
 }
 
-std::vector<Rect> GameLoop::getRectsSnapshot() {
-  std::lock_guard<std::mutex> snapshotLock(_snapshotMutex);
-  std::vector<Rect> rects;
-  rects.reserve(_entitiesSnapshot.size() + 1);
-
-  rects.push_back({0, static_cast<float>(_screenSnapshot.width), 0,
-                   static_cast<float>(_screenSnapshot.height),
-                   static_cast<float>(_screenSnapshot.progress.value_or(0)),
-                   parseHexColor(_screenSnapshot.color),
-                   static_cast<int32_t>(_screenSnapshot.asset.value_or(0))});
-
-  for (const auto &[id, entitySnapshot] : _entitiesSnapshot) {
-    if (entitySnapshot.px + entitySnapshot.width < 0 ||
-        entitySnapshot.px > _screenSnapshot.width ||
-        entitySnapshot.py + entitySnapshot.height < 0 ||
-        entitySnapshot.py > _screenSnapshot.height) {
-      continue;
-    }
-
-    rects.push_back(
-        {static_cast<float>(entitySnapshot.px),
-         static_cast<float>(entitySnapshot.px + entitySnapshot.width),
-         static_cast<float>(entitySnapshot.py),
-         static_cast<float>(entitySnapshot.py + entitySnapshot.height),
-         static_cast<float>(entitySnapshot.progress.value_or(0)),
-         parseHexColor(entitySnapshot.color),
-         static_cast<int32_t>(entitySnapshot.asset.value_or(0))});
-  }
-  return rects;
-}
-
 void GameLoop::runGameLoop() {
   using namespace std::chrono;
 
@@ -157,13 +125,18 @@ void GameLoop::runSystems() {
 
             uniqueEntityIdPairs.insert(uniqueEntityIdPairKey);
 
-            float aLeft = entityA->px, aRight = entityA->px + entityA->width;
-            float aTop = entityA->py, aBottom = entityA->py + entityA->height;
-            float bLeft = entityB->px, bRight = entityB->px + entityB->width;
-            float bTop = entityB->py, bBottom = entityB->py + entityB->height;
+            double aLeft = entityA->px - entityA->width / 2.0;
+            double aRight = entityA->px + entityA->width / 2.0;
+            double aTop = entityA->py - entityA->height / 2.0;
+            double aBottom = entityA->py + entityA->height / 2.0;
+
+            double bLeft = entityB->px - entityB->width / 2.0;
+            double bRight = entityB->px + entityB->width / 2.0;
+            double bTop = entityB->py - entityB->height / 2.0;
+            double bBottom = entityB->py + entityB->height / 2.0;
 
-            float overlapX = std::min(aRight, bRight) - std::max(aLeft, bLeft);
-            float overlapY = std::min(aBottom, bBottom) - std::max(aTop, bTop);
+            double overlapX = std::min(aRight, bRight) - std::max(aLeft, bLeft);
+            double overlapY = std::min(aBottom, bBottom) - std::max(aTop, bTop);
 
             if (overlapX > 0 && overlapY > 0) {
               collisions.push_back(Collision(entityA->id, entityB->id,

package/shared/GameLoop.hpp

@@ -2,7 +2,6 @@
 
 #include "Entity.hpp"
 #include "GameStats.hpp"
-#include "Rect.hpp"
 #include "Screen.hpp"
 #include "System.hpp"
 #include <atomic>
@@ -34,7 +33,6 @@ public:
 
   std::vector<Entity *> resolveEntitiesInternal(const std::string &prefix);
   void registerLottieDuration(double, double);
-  std::vector<Rect> getRectsSnapshot();
 
   void setTickRate(double tickRate) { _tickRate.store(tickRate); };
 

package/src/nativeTypes.ts

@@ -1,83 +1,68 @@
-export type Screen = {
-  /** Width of the screen in game units. */
-  width: number;
-  /** Height of the screen in game units. */
-  height: number;
-  /** Background color of the screen as a hex string e.g. `'#1a1a1a'`. */
-  color?: string;
-  /** Asset to render, use `require` with the file path to get the id. */
-  asset?: number;
-  /** Animation progress between 0 and 1, automatically advanced each tick for Lottie assets. */
-  progress?: number;
-};
-
-export type Entity = {
-  /** Unique identifier. Use `_` as a separator for group queries e.g. `'enemy_1'`. */
-  id: string;
+interface Positioned {
   /** X position in game units. */
   px: number;
   /** Y position in game units. */
   py: number;
+}
+
+interface Shaped {
   /** Width in game units. */
   width: number;
   /** Height in game units. */
   height: number;
+}
+
+interface Renderable {
   /** Fill color as a hex string e.g. `'#00ff00'`. */
   color?: string;
   /** Asset to render, use `require` with the file path to get the id. */
   asset?: number;
   /** Animation progress between 0 and 1, automatically advanced each tick for Lottie assets. */
   progress?: number;
+}
+
+interface Kinematic {
   /** Velocity on the X axis in game units per second. */
   vx?: number;
   /** Velocity on the Y axis in game units per second. */
   vy?: number;
-};
+}
 
-export type CollisionPair = {
+export interface Screen extends Shaped, Renderable {}
+
+export interface Entity extends Positioned, Shaped, Renderable, Kinematic {
+  /** Unique identifier. Use `_` as a separator for group queries e.g. `'enemy_1'`. */
+  id: string;
+}
+
+export interface EntityUpdate extends Partial<
+  Positioned & Shaped & Renderable & Kinematic
+> {
+  /** Unique identifier or prefix of the entities to update. */
+  id: string;
+}
+
+export interface CollisionPair {
   /** Entity id or prefix of the first entity to watch. */
   a: string;
   /** Entity id or prefix of the second entity to watch. */
   b: string;
-};
+}
 
-export type Collision = {
+export interface Collision {
   /** Id of the first entity involved in the collision. */
   a: string;
   /** Id of the second entity involved in the collision. */
   b: string;
   /** Penetration depth of the collision. */
   depth: number;
-};
+}
 
-export type System = {
+export interface System {
   /** Entity ids or prefixes this system subscribes to. */
   entities?: string[];
   /** Collision pairs to watch for every tick. */
   collisions?: CollisionPair[];
   /** Called every tick with the resolved entities and collisions. */
   onTick: (entities: Entity[], collisions: Collision[]) => number;
-};
-
-export type EntityUpdate = {
-  /** Unique identifier or prefix of the entities to update. */
-  id: string;
-  /** X position in game units. */
-  px?: number;
-  /** Y position in game units. */
-  py?: number;
-  /** Width in game units. */
-  width?: number;
-  /** Height in game units. */
-  height?: number;
-  /** Fill color as a hex string e.g. `'#00ff00'`. */
-  color?: string;
-  /** Asset to render, use `require` with the file path to get the id. */
-  asset?: number;
-  /** Animation progress between 0 and 1, automatically advanced each tick for Lottie assets. */
-  progress?: number;
-  /** Velocity on the X axis in game units per second. */
-  vx?: number;
-  /** Velocity on the Y axis in game units per second. */
-  vy?: number;
-};
+}

package/android/src/main/java/com/margelo/nitro/rngine/RectSerializer.kt

@@ -1,25 +0,0 @@
-package com.margelo.nitro.rngine
-
-import java.nio.ByteBuffer
-import java.nio.ByteOrder
-
-object RectSerializer {
-  private const val RECT_SIZE = 4 * 5 + 4 * 2
-  fun decode(buffer: ByteBuffer): ArrayList<Rect> {
-    buffer.order(ByteOrder.nativeOrder())
-    val rects = ArrayList<Rect>()
-
-    while (buffer.remaining() >= RECT_SIZE) {
-      val left = buffer.float
-      val right = buffer.float
-      val top = buffer.float
-      val bottom = buffer.float
-      val progress = buffer.float
-      val color = buffer.int
-      val asset = buffer.int
-
-      rects.add(Rect(left, right, top, bottom, progress, color, asset))
-    }
-    return rects
-  }
-}

package/shared/Rect.hpp

@@ -1,16 +0,0 @@
-#pragma once
-
-namespace margelo::nitro::rngine {
-static constexpr int RECT_SIZE =
-    sizeof(float) * 5 + sizeof(uint32_t) + sizeof(int32_t);
-
-struct Rect {
-  float left;
-  float right;
-  float top;
-  float bottom;
-  float progress;
-  uint32_t color;
-  int32_t asset;
-};
-} // namespace margelo::nitro::rngine