rngine 0.8.2 → 0.9.0

package/shared/GameMethods.hpp

@@ -24,14 +24,16 @@ 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;
 
   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;
+  std::shared_ptr<Promise<bool>> loadImage(double id,
+                                           const std::string &svgUri) override;
 };
 } // namespace margelo::nitro::rngine

package/shared/GameRenderer.cpp

@@ -1,4 +1,5 @@
 #include "GameRenderer.hpp"
+#include "AssetUtils.hpp"
 #include "ColorUtils.hpp"
 #include "Rect.hpp"
 
@@ -10,6 +11,7 @@
 #include "include/core/SkColorSpace.h"
 #include "include/core/SkPaint.h"
 #include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
 #include "include/core/SkSurface.h"
 
 #include "include/gpu/ganesh/GrBackendSurface.h"
@@ -133,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()) {
@@ -149,44 +156,16 @@ void GameRenderer::render(const Screen &screen,
   }
 
   if (screen.asset.has_value() && screen.asset.value() != 0) {
-    double assetId = screen.asset.value();
-
-    auto svgIt = _svgCache.find(assetId);
-    if (svgIt != _svgCache.end() && svgIt->second) {
-      auto &svgDom = svgIt->second;
-
-      SkSize intrinsicSize = svgDom->containerSize();
-      if (intrinsicSize.isEmpty()) {
-        svgDom->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);
-      svgDom->render(canvas);
-      canvas->restore();
-    } 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;
     }
 
@@ -219,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) {
@@ -239,39 +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 svgIt = _svgCache.find(assetId);
-        if (svgIt != _svgCache.end() && svgIt->second) {
-          auto &svgDom = svgIt->second;
-
-          SkSize intrinsicSize = svgDom->containerSize();
-          if (intrinsicSize.isEmpty()) {
-            svgDom->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);
-          svgDom->render(canvas);
-          canvas->restore();
-        } 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));
       }
     }
   }
@@ -284,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);
@@ -307,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

@@ -1,6 +1,8 @@
 #pragma once
 #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"
@@ -21,9 +23,11 @@ public:
 
   ~GameRenderer();
 
-  std::map<double, sk_sp<SkSVGDOM>> &getSvgCacheInternal() {
-    return _svgCache;
+  std::map<double, std::variant<sk_sp<SkSVGDOM>, sk_sp<SkImage>>> &
+  getImageCacheInternal() {
+    return _imageCache;
   };
+
   std::map<double, sk_sp<skottie::Animation>> &getLottieCacheInternal() {
     return _lottieCache;
   };
@@ -52,11 +56,10 @@ private:
   int _height{0};
   bool _initialized{false};
 
-  std::map<double, sk_sp<SkSVGDOM>> _svgCache;
   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();

package/shared/utils/AssetUtils.cpp

@@ -0,0 +1,92 @@
+#include "AssetUtils.hpp"
+#include "GameRenderer.hpp"
+#include <variant>
+
+namespace margelo::nitro::rngine::AssetUtils {
+static void drawSVG(SkCanvas *canvas, const sk_sp<SkSVGDOM> &svg, float width,
+                    float height) {
+  SkSize intrinsicSize = svg->containerSize();
+  if (intrinsicSize.isEmpty()) {
+    svg->setContainerSize(SkSize::Make(width, height));
+    intrinsicSize = SkSize::Make(width, height);
+  }
+
+  SkAutoCanvasRestore restore(canvas, true);
+  canvas->scale(width / intrinsicSize.width(), height / intrinsicSize.height());
+  svg->render(canvas);
+}
+
+static void drawRaster(SkCanvas *canvas, const sk_sp<SkImage> &raster,
+                       float width, float height) {
+  float intrinsicW = static_cast<float>(raster->width());
+  float intrinsicH = static_cast<float>(raster->height());
+  if (intrinsicW <= 0.0f || intrinsicH <= 0.0f)
+    return;
+
+  SkAutoCanvasRestore restore(canvas, true);
+  canvas->scale(width / intrinsicW, height / intrinsicH);
+  SkSamplingOptions sampling(SkFilterMode::kLinear, SkMipmapMode::kLinear);
+  canvas->drawImage(raster, 0.0f, 0.0f, sampling);
+}
+
+void drawAsset(SkCanvas *canvas, double asset, float targetWidth,
+               float targetHeight, bool flipH, bool flipV, double progress) {
+  SkAutoCanvasRestore restoreGuard(canvas, true);
+
+  if (flipH || flipV) {
+    canvas->translate(targetWidth * 0.5f, targetHeight * 0.5f);
+    canvas->scale(flipH ? -1.0f : 1.0f, flipV ? -1.0f : 1.0f);
+    canvas->translate(-targetWidth * 0.5f, -targetHeight * 0.5f);
+  }
+
+  if (asset == 0) {
+    return;
+  }
+
+  auto &gameRenderer = GameRenderer::getInstance();
+
+  if (asset > 0) {
+    auto &imageCache = gameRenderer.getImageCacheInternal();
+    auto imageIt = imageCache.find(asset);
+    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>>) {
+              drawSVG(canvas, image, targetWidth, targetHeight);
+            } else {
+              drawRaster(canvas, image, targetWidth, targetHeight);
+            }
+          },
+          imageIt->second);
+      return;
+    }
+  }
+
+  auto &lottieCache = gameRenderer.getLottieCacheInternal();
+  auto lottieIt = lottieCache.find(asset);
+  if (lottieIt != lottieCache.end() && lottieIt->second) {
+    lottieIt->second->seek(progress);
+    SkRect dstBounds = SkRect::MakeWH(targetWidth, targetHeight);
+    lottieIt->second->render(canvas, &dstBounds);
+  }
+}
+
+void updateProgress(std::optional<double> &progress,
+                    std::optional<double> &speed, double asset,
+                    double deltaTime) {
+  if (asset < 0) {
+    auto &lottieCache = GameRenderer::getInstance().getLottieCacheInternal();
+    auto it = lottieCache.find(asset);
+    if (it != lottieCache.end() && it->second) {
+      if (speed.has_value() && speed.value() > 0) {
+        progress = fmod(progress.value_or(0.0) + (deltaTime * speed.value()) /
+                                                     it->second->duration(),
+                        1.0);
+      }
+    }
+  } else if (progress.has_value()) {
+    progress.reset();
+  }
+}
+} // namespace margelo::nitro::rngine::AssetUtils

package/shared/utils/AssetUtils.hpp

@@ -0,0 +1,11 @@
+#pragma once
+#include "include/core/SkCanvas.h"
+#include "modules/svg/include/SkSVGDOM.h"
+
+namespace margelo::nitro::rngine::AssetUtils {
+void drawAsset(SkCanvas *canvas, double asset, float targetWidth,
+               float targetHeight, bool flipH, bool flipV, double progress);
+void updateProgress(std::optional<double> &progress,
+                    std::optional<double> &speed, double asset,
+                    double deltaTime);
+} // namespace margelo::nitro::rngine::AssetUtils

package/shared/{CollisionUtils.cpp → utils/CollisionUtils.cpp}

@@ -1,10 +1,11 @@
 #include "CollisionUtils.hpp"
 #include "Collision.hpp"
+#include "Overlap.hpp"
 #include <optional>
 
 namespace margelo::nitro::rngine::CollisionUtils {
-std::optional<Overlap> overlap(const Rect &a, double ax, double ay,
-                               const Rect &b, double bx, double by) {
+static std::optional<Overlap> overlap(const Rect &a, double ax, double ay,
+                                      const Rect &b, double bx, double by) {
 
   double aLeft = ax - a.width / 2.0, aRight = ax + a.width / 2.0;
   double aTop = ay - a.height / 2.0, aBottom = ay + a.height / 2.0;
@@ -26,8 +27,8 @@ std::optional<Overlap> overlap(const Rect &a, double ax, double ay,
   }
 }
 
-std::optional<Overlap> overlap(const Circle &a, double ax, double ay,
-                               const Circle &b, double bx, double by) {
+static std::optional<Overlap> overlap(const Circle &a, double ax, double ay,
+                                      const Circle &b, double bx, double by) {
   double dx = bx - ax, dy = by - ay;
   double dist = std::sqrt(dx * dx + dy * dy);
   double depth = (a.radius + b.radius) - dist;
@@ -41,8 +42,8 @@ std::optional<Overlap> overlap(const Circle &a, double ax, double ay,
   return Overlap{depth, dx / dist, dy / dist};
 }
 
-std::optional<Overlap> overlap(const Rect &a, double ax, double ay,
-                               const Circle &b, double bx, double by) {
+static std::optional<Overlap> overlap(const Rect &a, double ax, double ay,
+                                      const Circle &b, double bx, double by) {
   double left = ax - a.width / 2.0, right = ax + a.width / 2.0;
   double top = ay - a.height / 2.0, bottom = ay + a.height / 2.0;
 
@@ -67,8 +68,8 @@ std::optional<Overlap> overlap(const Rect &a, double ax, double ay,
   return Overlap{b.radius - dist, dx / dist, dy / dist};
 }
 
-std::optional<Overlap> overlap(const Circle &a, double ax, double ay,
-                               const Rect &b, double bx, double by) {
+static std::optional<Overlap> overlap(const Circle &a, double ax, double ay,
+                                      const Rect &b, double bx, double by) {
   auto result = overlap(b, bx, by, a, ax, ay);
 
   if (!result.has_value()) {

package/shared/utils/CollisionUtils.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "Collision.hpp"
+#include "Entity.hpp"
+#include <optional>
+
+namespace margelo::nitro::rngine::CollisionUtils {
+std::optional<Collision> shapeOverlap(const Entity &entityA,
+                                      const Entity &entityB);
+} // namespace margelo::nitro::rngine::CollisionUtils

package/src/GameMethods.nitro.ts

@@ -5,6 +5,7 @@ import type {
   System,
   Screen,
   World,
+  ScreenUpdate,
 } from './nativeTypes';
 import { NitroModules } from 'react-native-nitro-modules';
 
@@ -12,19 +13,28 @@ interface GameMethods extends HybridObject<{
   ios: 'c++';
   android: 'c++';
 }> {
+  /** Configuration Methods */
   setWorld(world: World): void;
   setScreen(screen: Screen): void;
   setEntities(entities: Entity[]): void;
   setSystems(systems: System[]): void;
+
+  /** Pause/Resume Methods */
   pause(): void;
   resume(): void;
+
+  /** Entity Update Methods */
   spawn(entities: Entity[]): void;
   despawn(id: string): void;
-  update(updates: EntityUpdate[]): void;
+  updateEntities(entityUpdates: EntityUpdate[]): void;
+
+  /** Screen Update Methods */
+  updateScreen(screenUpdate: ScreenUpdate): void;
 
+  /** Asset Methods */
   isAssetLoaded(id: number): boolean;
   loadLottie(id: number, jsonStr: string): Promise<boolean>;
-  loadSvg(id: number, svgUri: string): Promise<boolean>;
+  loadImage(id: number, imageUri: string): Promise<boolean>;
 }
 
 export const gameMethods =

package/src/GameMethods.ts

@@ -1,5 +1,5 @@
 import { gameMethods } from './GameMethods.nitro';
-import type { Entity, EntityUpdate, System } from './nativeTypes';
+import type { Entity, EntityUpdate, ScreenUpdate, System } from './nativeTypes';
 import type { Config } from './types';
 import { Image } from 'react-native';
 
@@ -17,9 +17,9 @@ export const configure = ({
     nativeSystems.push({
       entities: system.entities,
       collisions: system.collisions,
-      onTick: (e, c) => {
+      onTick: (systemContext) => {
         const start = Date.now();
-        system.onTick(e, c);
+        system.onTick(systemContext);
         const finish = Date.now();
         return finish - start;
       },
@@ -49,13 +49,22 @@ export const spawn = (entities: Entity | Entity[]) => {
   gameMethods.spawn(entityArray);
 };
 
-/** Removes an entity or all entities matching the given id prefix from the world. */
+/** Removes an entity or all entities matching the given id prefix from the world. Only the provided fields are changed. */
 export const despawn = (id: string) => gameMethods.despawn(id);
 
-/** Updates one or more entities. Only the provided fields are changed. */
-export const update = (updates: EntityUpdate | EntityUpdate[]) => {
-  const entityUpdateArray = Array.isArray(updates) ? updates : [updates];
-  gameMethods.update(entityUpdateArray);
+/** Fires one update, applied to entities matching the given id prefix from the world. Only the provided fields are changed. */
+export const updateEntity = (entityUpdate: EntityUpdate) => {
+  gameMethods.updateEntities([entityUpdate]);
+};
+
+/** Fires multiple updates, each applied to entities matching the given id prefix from the world. */
+export const updateEntities = (entityUpdates: EntityUpdate[]) => {
+  gameMethods.updateEntities(entityUpdates);
+};
+
+/** Updates the screen. Only the provided fields are changed. */
+export const updateScreen = (screenUpdate: ScreenUpdate) => {
+  gameMethods.updateScreen(screenUpdate);
 };
 
 const assetCache = new WeakMap<object, number>();
@@ -89,9 +98,9 @@ const loadAsset = async (asset: unknown) => {
       if (!assetUri) {
         throw new Error(`loadAssets: could not resolve asset URI for ${asset}`);
       }
-      const isSvgLoaded = await gameMethods.loadSvg(asset, assetUri);
-      if (!isSvgLoaded) {
-        throw new Error('loadAssets: Failed to load svg asset');
+      const isLoaded = await gameMethods.loadImage(asset, assetUri);
+      if (!isLoaded) {
+        throw new Error('loadAssets: Failed to load image asset');
       }
       return asset;
   }
@@ -99,6 +108,9 @@ const loadAsset = async (asset: unknown) => {
   throw new Error(`loadAssets: unsupported asset type "${typeof asset}"`);
 };
 
+/** Preloads one or more SVG, PNG or Lottie assets ahead of time.
+ * Takes an object mapping names to `require(...)` sources (SVG/PNG) or imported JSON (Lottie),
+ * and resolves to an object of the same shape with numeric asset ids. */
 export const loadAssets = async <T extends Record<string, unknown>>(
   assets: T
 ): Promise<{ [K in keyof T]: number }> => {

package/src/index.tsx

@@ -9,5 +9,6 @@ export type {
   CollisionPair,
   Collision,
   EntityUpdate,
+  SystemContext,
 } from './nativeTypes';
 export { GameEngine };

package/src/nativeTypes.ts

@@ -61,7 +61,7 @@ export interface World {
   gy?: number;
 }
 
-export interface Screen extends Rect, Renderable {}
+export interface Screen extends Positioned, Rect, Renderable {}
 
 export interface Entity extends Positioned, Shaped, Renderable, Kinematic {
   /** Unique identifier. Use `_` as a separator for group queries e.g. `'enemy_1'`. */
@@ -75,6 +75,8 @@ export interface EntityUpdate extends Partial<
   id: string;
 }
 
+export interface ScreenUpdate extends Partial<Screen> {}
+
 export interface CollisionPair {
   /** Entity id or prefix of the first entity to watch. */
   a: string;
@@ -95,11 +97,20 @@ export interface Collision {
   ny: number;
 }
 
+export interface SystemContext {
+  /** Current game screen state. */
+  screen: Screen;
+  /** Entities resolved from the system's entity subscriptions. */
+  entities: Entity[];
+  /** Collisions matching the system's collision subscriptions. */
+  collisions: Collision[];
+}
+
 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;
+  onTick: (systemContext: SystemContext) => number;
 }

package/src/types.ts

@@ -1,14 +1,14 @@
 import type {
   System as NativeSystem,
-  Collision,
   Screen,
   Entity,
   World,
+  SystemContext,
 } from './nativeTypes';
 
 export type System = Omit<NativeSystem, 'onTick'> & {
   /** Called every tick with the resolved entities and collisions. */
-  onTick: (entities: Entity[], collisions: Collision[]) => void;
+  onTick: (systemContext: SystemContext) => void;
 };
 
 export type Config = {

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

@@ -1,24 +0,0 @@
-package com.margelo.nitro.rngine
-
-import androidx.annotation.Keep
-import com.margelo.nitro.NitroModules
-import java.net.URL
-
-@Keep
-object SvgLoaderHelper {
-  @JvmStatic
-  fun loadFromUrl(uri: String): ByteArray {
-    return URL(uri).openStream().use { it.readBytes() }
-  }
-
-  @JvmStatic
-  fun loadFromResource(uri: String): ByteArray {
-    val context = NitroModules.applicationContext
-      ?: throw IllegalStateException("No Context available!")
-    val resId = context.resources.getIdentifier(uri, "raw", context.packageName)
-    if (resId == 0) {
-      throw IllegalStateException("Could not resolve raw resource for asset: $uri")
-    }
-    return context.resources.openRawResource(resId).use { it.readBytes() }
-  }
-}

package/shared/CollisionUtils.hpp

@@ -1,21 +0,0 @@
-#pragma once
-
-#include "Circle.hpp"
-#include "Collision.hpp"
-#include "Entity.hpp"
-#include "Overlap.hpp"
-#include "Rect.hpp"
-#include <optional>
-
-namespace margelo::nitro::rngine::CollisionUtils {
-std::optional<Overlap> overlap(const Rect &a, double ax, double ay,
-                               const Rect &b, double bx, double by);
-std::optional<Overlap> overlap(const Circle &a, double ax, double ay,
-                               const Circle &b, double bx, double by);
-std::optional<Overlap> overlap(const Rect &a, double ax, double ay,
-                               const Circle &b, double bx, double by);
-std::optional<Overlap> overlap(const Circle &a, double ax, double ay,
-                               const Rect &b, double bx, double by);
-std::optional<Collision> shapeOverlap(const Entity &entityA,
-                                      const Entity &entityB);
-} // namespace margelo::nitro::rngine::CollisionUtils