rngine 0.9.0 → 0.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rngine",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "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

@@ -71,6 +71,8 @@ void GameLoop::runGameLoop() {
   auto &gameRenderer = GameRenderer::getInstance();
 
   while (_isRunning) {
+    gameRenderer.processPendingTasks();
+
     double targetDeltaTime;
     {
       std::lock_guard<std::mutex> lock(_worldMutex);

package/shared/GameRenderer.cpp

@@ -43,63 +43,85 @@ GameRenderer::~GameRenderer() {
 }
 
 void GameRenderer::onSurfaceCreated(ANativeWindow *window) {
-  __android_log_print(ANDROID_LOG_INFO, "GameRenderer", "onSurfaceCreated");
 
-  _nativeWindow = window;
+  std::lock_guard<std::mutex> lock(_taskMutex);
+  _taskQueue.push([this, window]() {
+    __android_log_print(ANDROID_LOG_INFO, "GameRenderer", "onSurfaceCreated");
 
-  if (!_initialized) {
-    if (!initializeEGL()) {
-      __android_log_print(ANDROID_LOG_ERROR, "GameRenderer",
-                          "onSurfaceCreated: EGL initialization failed");
-      return;
+    _nativeWindow = window;
+
+    if (!_initialized) {
+      if (!initializeEGL()) {
+        __android_log_print(ANDROID_LOG_ERROR, "GameRenderer",
+                            "onSurfaceCreated: EGL initialization failed");
+        return;
+      }
+      _initialized = true;
     }
-    _initialized = true;
-  }
 
-  if (!createEGLSurface()) {
-    __android_log_print(ANDROID_LOG_ERROR, "GameRenderer",
-                        "onSurfaceCreated: EGL surface creation failed");
-  }
+    if (!createEGLSurface()) {
+      __android_log_print(ANDROID_LOG_ERROR, "GameRenderer",
+                          "onSurfaceCreated: EGL surface creation failed");
+    }
+  });
 }
 
 void GameRenderer::onSurfaceChanged(int width, int height) {
-  _width = width;
-  _height = height;
-  _surface = nullptr;
-
-  __android_log_print(ANDROID_LOG_INFO, "GameRenderer",
-                      "onSurfaceChanged: Width: %d, Height: %d", _width,
-                      _height);
+  std::lock_guard<std::mutex> lock(_taskMutex);
+  _taskQueue.push([this, width, height]() {
+    _width = width;
+    _height = height;
+    _surface = nullptr;
+
+    __android_log_print(ANDROID_LOG_INFO, "GameRenderer",
+                        "onSurfaceChanged: Width: %d, Height: %d", _width,
+                        _height);
+  });
 }
 
 void GameRenderer::onSurfaceDestroyed() {
-  if (_eglDisplay != EGL_NO_DISPLAY) {
-    eglMakeCurrent(_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+  std::lock_guard<std::mutex> lock(_taskMutex);
+  _taskQueue.push([this]() {
+    if (_eglDisplay != EGL_NO_DISPLAY) {
+      eglMakeCurrent(_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
+                     EGL_NO_CONTEXT);
+
+      if (_eglSurface != EGL_NO_SURFACE) {
+        eglDestroySurface(_eglDisplay, _eglSurface);
+        _eglSurface = EGL_NO_SURFACE;
+      }
+    }
 
-    if (_eglSurface != EGL_NO_SURFACE) {
-      eglDestroySurface(_eglDisplay, _eglSurface);
-      _eglSurface = EGL_NO_SURFACE;
+    if (_nativeWindow) {
+      ANativeWindow_release(_nativeWindow);
+      _nativeWindow = nullptr;
     }
-  }
 
-  if (_nativeWindow) {
-    ANativeWindow_release(_nativeWindow);
-    _nativeWindow = nullptr;
-  }
+    _surface = nullptr;
+    _width = 0;
+    _height = 0;
+
+    __android_log_print(ANDROID_LOG_INFO, "GameRenderer", "onSurfaceDestroyed");
+  });
+}
 
-  _surface = nullptr;
-  _width = 0;
-  _height = 0;
+void GameRenderer::processPendingTasks() {
+  std::queue<std::function<void()>> tasksToProcess;
 
-  __android_log_print(ANDROID_LOG_INFO, "GameRenderer", "onSurfaceDestroyed");
+  {
+    std::lock_guard<std::mutex> lock(_taskMutex);
+    std::swap(tasksToProcess, _taskQueue);
+  }
+
+  while (!tasksToProcess.empty()) {
+    tasksToProcess.front()(); // Executes on the game loop thread
+    tasksToProcess.pop();
+  }
 }
 
 void GameRenderer::render(const Screen &screen,
                           const std::map<std::string, Entity> &entities) {
 
-  __android_log_print(ANDROID_LOG_DEBUG, "GameRenderer",
-                      "render: called, entities=%zu", entities.size());
-
   if (!_grContext || _eglSurface == EGL_NO_SURFACE || _width == 0 ||
       _height == 0) {
     __android_log_print(ANDROID_LOG_WARN, "GameRenderer",
@@ -107,12 +129,6 @@ void GameRenderer::render(const Screen &screen,
     return;
   }
 
-  if (!eglMakeCurrent(_eglDisplay, _eglSurface, _eglSurface, _eglContext)) {
-    __android_log_print(ANDROID_LOG_ERROR, "GameRenderer",
-                        "render: eglMakeCurrent failed: 0x%x", eglGetError());
-    return;
-  }
-
   if (!_surface) {
     if (!createSkSurface()) {
       return;
@@ -228,8 +244,6 @@ void GameRenderer::render(const Screen &screen,
 
   _grContext->flushAndSubmit(_surface.get());
   eglSwapBuffers(_eglDisplay, _eglSurface);
-
-  __android_log_print(ANDROID_LOG_DEBUG, "GameRenderer", "render: complete");
 }
 
 bool GameRenderer::isEntityVisible(const Entity &entity,
@@ -342,8 +356,6 @@ bool GameRenderer::createEGLSurface() {
     }
   }
 
-  eglMakeCurrent(_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
-
   __android_log_print(ANDROID_LOG_INFO, "GameRenderer",
                       "createEGLSurface: EGL surface created");
   return true;

package/shared/GameRenderer.hpp

@@ -36,6 +36,7 @@ public:
   void onSurfaceChanged(int width, int height);
   void onSurfaceDestroyed();
 
+  void processPendingTasks();
   void render(const Screen &screen,
               const std::map<std::string, Entity> &entities);
 
@@ -59,6 +60,9 @@ private:
   std::map<double, sk_sp<skottie::Animation>> _lottieCache;
   std::map<double, std::variant<sk_sp<SkSVGDOM>, sk_sp<SkImage>>> _imageCache;
 
+  std::mutex _taskMutex;
+  std::queue<std::function<void()>> _taskQueue;
+
   bool isEntityVisible(const Entity &entity, const SkRect &viewBounds);
 
   bool initializeEGL();