rngine 0.5.0 → 0.7.0

package/README.md

@@ -21,28 +21,33 @@ configure({
   entities: [
     {
       id: 'player',
-      px: 400,
-      py: 400,
-      width: 40,
-      height: 40,
-      color: '#00ff00',
+      px: 420,
+      py: 420,
+      color: '#0f0',
+      shape: {
+        radius: 20,
+      },
     },
     {
       id: 'enemy_1',
-      px: 100,
-      py: 100,
-      width: 40,
-      height: 40,
-      color: '#ff0000',
+      px: 120,
+      py: 120,
+      color: '#f00',
+      shape: {
+        width: 40,
+        height: 40,
+      },
       vx: 1000,
     },
     {
       id: 'enemy_2',
-      px: 200,
-      py: 200,
-      width: 40,
-      height: 40,
-      color: '#ff0000',
+      px: 220,
+      py: 220,
+      color: '#f00',
+      shape: {
+        width: 40,
+        height: 40,
+      },
       vx: -1000,
     },
   ],
@@ -53,7 +58,10 @@ configure({
       onTick: (enemies) => {
         enemies.forEach((enemy) => {
           // reverse direction when reaching screen edges
-          if (enemy.px <= 0 || enemy.px + enemy.width >= 800) {
+          if (
+            enemy.px - enemy.width / 2 <= 0 ||
+            enemy.px + enemy.width / 2 >= 800
+          ) {
             update({ id: enemy.id, vx: -enemy.vx });
           }
         });
@@ -70,7 +78,7 @@ export default function App() {
 
 ## Concepts
 
-**Entities** are the objects in your game world. Each entity has a position, size, color, and velocity. See [`Entity`](./src/nativeTypes.ts).
+**Entities** are the objects in your game world. Each entity has a position, shape, color, and velocity. See [`Entity`](./src/nativeTypes.ts).
 
 **Systems** define your game logic. Each system optionally declares which entities it cares about via `entities`, which collision pairs to watch via `collisions`, or both. Systems run every tick receiving the resolved entities and any active collisions. See [`System`](./src/types.ts).
 

package/android/CMakeLists.txt

@@ -13,6 +13,7 @@ add_library(
         src/main/cpp/GameLoopJNI.cpp
         ../shared/GameLoop.cpp
         ../shared/GameMethods.cpp
+        ../shared/CollisionUtils.cpp
 )
 
 # Add Nitrogen specs :)

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

@@ -1,36 +1,126 @@
+#include "ColorUtils.hpp"
 #include "GameLoop.hpp"
+#include <cstdint>
 #include <jni.h>
+#include <mutex>
+#include <variant>
 
 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)));
   }
 
-  return env->NewDirectByteBuffer(buffer.data(), (jlong)size);
+  for (const auto &[_, entitySnapshot] : entitiesSnapshot) {
+    uint8_t shapeType{0};
+    float entitySnapshotLeft{0}, entitySnapshotRight{0}, entitySnapshotTop{0},
+        entitySnapshotBottom{0}, circleRadius{0};
+
+    std::visit(
+        [&](const auto &shape) {
+          using T = std::decay_t<decltype(shape)>;
+          if constexpr (std::is_same_v<T, margelo::nitro::rngine::Rect>) {
+            shapeType = 0;
+            entitySnapshotLeft =
+                static_cast<float>(entitySnapshot.px - shape.width / 2.0);
+            entitySnapshotRight =
+                static_cast<float>(entitySnapshot.px + shape.width / 2.0);
+            entitySnapshotTop =
+                static_cast<float>(entitySnapshot.py - shape.height / 2.0);
+            entitySnapshotBottom =
+                static_cast<float>(entitySnapshot.py + shape.height / 2.0);
+          } else {
+            shapeType = 1;
+            circleRadius = static_cast<float>(shape.radius);
+            entitySnapshotLeft =
+                static_cast<float>(entitySnapshot.px - shape.radius);
+            entitySnapshotRight =
+                static_cast<float>(entitySnapshot.px + shape.radius);
+            entitySnapshotTop =
+                static_cast<float>(entitySnapshot.py - shape.radius);
+            entitySnapshotBottom =
+                static_cast<float>(entitySnapshot.py + shape.radius);
+          }
+        },
+        entitySnapshot.shape);
+
+    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));
+
+    buffer.push_back(shapeType);
+
+    if (shapeType == 0) {
+      writeFloat(entitySnapshotLeft);
+      writeFloat(entitySnapshotRight);
+      writeFloat(entitySnapshotTop);
+      writeFloat(entitySnapshotBottom);
+    } else {
+      writeFloat(static_cast<float>(entitySnapshot.px));
+      writeFloat(static_cast<float>(entitySnapshot.py));
+      writeFloat(circleRadius);
+    }
+
+    writeU32(entitySnapshotColor);
+    writeI32(entitySnapshotAsset);
+
+    if (entitySnapshotAsset < 0) {
+      writeFloat(static_cast<float>(entitySnapshot.progress.value_or(0)));
+    }
+  }
+
+  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

@@ -1,13 +1,11 @@
 package com.margelo.nitro.rngine
 
 import android.content.Context
-import android.graphics.Color
+import android.graphics.Canvas
 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,15 +18,98 @@ class GameView(
   attrs,
   defStyleAttr,
 ) {
-  private external fun getRectsSnapshot(): ByteBuffer
+  private external fun getSnapshot(): ByteArray
   var onAttached: () -> Unit = {}
   var onDetached: () -> Unit = {}
 
   private val paint = Paint().apply {
-    color = Color.TRANSPARENT
     style = Paint.Style.FILL
   }
 
+  private fun drawAsset(
+    canvas: Canvas,
+    left: Float,
+    top: Float,
+    right: Float,
+    bottom: Float,
+    asset: Int,
+    progress: Float?,
+  ) {
+    canvas.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 -> {}
+      }
+    }
+  }
+
+  private fun drawRect(
+    canvas: Canvas,
+    left: Float,
+    top: Float,
+    right: Float,
+    bottom: Float,
+    color: Int,
+    asset: Int,
+    progress: Float?,
+  ) {
+    paint.color = color
+    canvas.drawRect(left, top, right, bottom, paint)
+
+    drawAsset(
+      canvas,
+      left,
+      top,
+      right,
+      bottom,
+      asset,
+      progress
+    )
+  }
+
+  private fun drawCircle(
+    canvas: Canvas,
+    cx: Float,
+    cy: Float,
+    radius: Float,
+    color: Int,
+    asset: Int,
+    progress: Float?,
+  ) {
+    val left = cx - radius
+    val top = cy - radius
+    val right = cx + radius
+    val bottom = cy + radius
+
+    paint.color = color
+    canvas.drawCircle(cx, cy, radius, paint)
+
+    drawAsset(
+      canvas,
+      left,
+      top,
+      right,
+      bottom,
+      asset,
+      progress,
+    )
+  }
+
   init {
     addOnAttachStateChangeListener(
       object : OnAttachStateChangeListener {
@@ -40,60 +121,65 @@ 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
-
-    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
-
-      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)
-
-      paint.color = rect.color
-      canvas.drawRect(
-        clampedLeft,
-        clampedTop,
-        clampedRight,
-        clampedBottom,
-        paint
-      )
-      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)
-            }
+    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
+
+    drawRect(
+      canvas,
+      screenLeft,
+      screenTop,
+      screenRight,
+      screenBottom,
+      snapshot.screen.color,
+      snapshot.screen.asset,
+      snapshot.screen.progress,
+    )
+
+    canvas.withClip(screenLeft, screenTop, screenRight, screenBottom) {
+      snapshot.shapes.forEach { shape ->
+        when (shape) {
+          is Shape.Rect -> {
+            val left = shape.left * scale + screenLeft
+            val top = shape.top * scale + screenTop
+            val right = shape.right * scale + screenLeft
+            val bottom = shape.bottom * scale + screenTop
+
+            drawRect(
+              canvas,
+              left,
+              top,
+              right,
+              bottom,
+              shape.color,
+              shape.asset,
+              shape.progress,
+            )
           }
-        }
 
-        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)
-            }
+          is Shape.Circle -> {
+            val cx = shape.px * scale + screenLeft
+            val cy = shape.py * scale + screenTop
+            val radius = shape.radius * scale
+
+            drawCircle(
+              canvas,
+              cx,
+              cy,
+              radius,
+              shape.color,
+              shape.asset,
+              shape.progress,
+            )
           }
         }
-
-        null -> {}
       }
     }
     holder.unlockCanvasAndPost(canvas)

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/Shape.kt

@@ -0,0 +1,26 @@
+package com.margelo.nitro.rngine
+
+sealed class Shape(
+  val color: Int,
+  val asset: Int,
+  val progress: Float?,
+) {
+  class Rect(
+    val left: Float,
+    val right: Float,
+    val top: Float,
+    val bottom: Float,
+    color: Int,
+    asset: Int,
+    progress: Float?,
+  ) : Shape(color, asset, progress)
+
+  class Circle(
+    val px: Float,
+    val py: Float,
+    val radius: Float,
+    color: Int,
+    asset: Int,
+    progress: Float?,
+  ) : Shape(color, asset, progress)
+}

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 shapes: List<Shape>)

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

@@ -0,0 +1,53 @@
+package com.margelo.nitro.rngine
+
+import android.util.Log
+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 shapes = ArrayList<Shape>()
+
+    while (buffer.hasRemaining()) {
+      when (val shapeType = buffer.get().toInt()) {
+        0 -> {
+          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
+
+          shapes.add(Shape.Rect(left, right, top, bottom, color, asset, progress))
+        }
+
+        1 -> {
+          val px = buffer.float
+          val py = buffer.float
+          val radius = buffer.float
+
+          val color = buffer.int
+          val asset = buffer.int
+          val progress = if (asset < 0) buffer.float else null
+
+          shapes.add(Shape.Circle(px, py, radius, color, asset, progress))
+        }
+
+        else -> Log.e("SnapshotSerializer", "Unknown shapeType: $shapeType")
+      }
+    }
+
+    return Snapshot(screen, shapes)
+  }
+}