🔧

Author: wcandillon

packages/webgpu/apple/WebGPUModule.mm

@@ -24,6 +24,7 @@ - (void *)runtime;
 
 @implementation WebGPUModule {
   CADisplayLink *_displayLink;
+  BOOL _displayLinkActive;
 }
 
 RCT_EXPORT_MODULE(WebGPUModule)
@@ -52,24 +53,29 @@ - (void)invalidate {
 }
 
 - (void)startDisplayLink {
+  _displayLinkActive = YES;
   if (_displayLink != nil) {
     return;
   }
   // CADisplayLink callbacks must be scheduled on a run loop. The main run
   // loop is the safest choice: CAMetalLayer ops are main-thread-only, and
   // SurfaceInfo's mutex serialises access with the JS thread.
   dispatch_async(dispatch_get_main_queue(), ^{
+    if (!self->_displayLinkActive) {
+      return;
+    }
     if (self->_displayLink != nil) {
       return;
     }
-    self->_displayLink = [CADisplayLink displayLinkWithTarget:self
-                                                     selector:@selector(onVsync:)];
+    self->_displayLink =
+        [CADisplayLink displayLinkWithTarget:self selector:@selector(onVsync:)];
     [self->_displayLink addToRunLoop:[NSRunLoop mainRunLoop]
                              forMode:NSRunLoopCommonModes];
   });
 }
 
 - (void)stopDisplayLink {
+  _displayLinkActive = NO;
   CADisplayLink *link = _displayLink;
   _displayLink = nil;
   if (link == nil) {

packages/webgpu/cpp/rnwgpu/SurfaceRegistry.h

@@ -130,22 +130,31 @@ class SurfaceInfo {
     _presentLocked();
   }
 
-  // Called by the display-link tick. Presents only if the texture was acquired
-  // in a strictly earlier frame, so the user's render code (which runs between
-  // vsyncs) has finished encoding and submitting before we present.
+  // Called by the display-link tick. Presents only after the app has submitted
+  // work for an acquired texture and at least one tick has passed since
+  // acquire.
   void maybePresentForFrame(uint64_t currentFrame) {
     std::unique_lock<std::shared_mutex> lock(_mutex);
-    if (_acquiredAtFrame && *_acquiredAtFrame < currentFrame) {
+    if (_readyToPresent && _acquiredAtFrame &&
+        *_acquiredAtFrame < currentFrame) {
       _presentLocked();
     }
   }
 
+  void markSubmittedForPresentation() {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    if (_textureAcquired) {
+      _readyToPresent = true;
+    }
+  }
+
   wgpu::Texture getCurrentTexture(uint64_t currentFrame) {
     std::unique_lock<std::shared_mutex> lock(_mutex);
     if (surface) {
       wgpu::SurfaceTexture surfaceTexture;
       surface.GetCurrentTexture(&surfaceTexture);
       _textureAcquired = true;
+      _readyToPresent = false;
       _acquiredAtFrame = currentFrame;
       return surfaceTexture.texture;
     } else {
@@ -199,6 +208,7 @@ class SurfaceInfo {
 #endif
       surface.Present();
       _textureAcquired = false;
+      _readyToPresent = false;
       _acquiredAtFrame.reset();
     }
   }
@@ -212,6 +222,7 @@ class SurfaceInfo {
   int width;
   int height;
   bool _textureAcquired = false;
+  bool _readyToPresent = false;
   std::optional<uint64_t> _acquiredAtFrame;
 };
 
@@ -280,6 +291,20 @@ class SurfaceRegistry {
     }
   }
 
+  void markSubmittedSurfacesForPresentation() {
+    std::vector<std::shared_ptr<SurfaceInfo>> snapshot;
+    {
+      std::shared_lock<std::shared_mutex> lock(_mutex);
+      snapshot.reserve(_registry.size());
+      for (auto &entry : _registry) {
+        snapshot.push_back(entry.second);
+      }
+    }
+    for (auto &info : snapshot) {
+      info->markSubmittedForPresentation();
+    }
+  }
+
 private:
   SurfaceRegistry() = default;
   mutable std::shared_mutex _mutex;

packages/webgpu/cpp/rnwgpu/api/GPUQueue.cpp

@@ -2,9 +2,12 @@
 
 #include <limits>
 #include <memory>
+#include <string>
+#include <utility>
 #include <vector>
 
 #include "Convertors.h"
+#include "SurfaceRegistry.h"
 
 namespace rnwgpu {
 
@@ -26,6 +29,7 @@ void GPUQueue::submit(
     return;
   }
   _instance.Submit(bufs_size, bufs.data());
+  SurfaceRegistry::getInstance().markSubmittedSurfacesForPresentation();
 }
 
 void GPUQueue::writeBuffer(std::shared_ptr<GPUBuffer> buffer,