rm fence syncs;

They are too buggy and are not as efficient as orphaning.

src/modules/graphics/graphics.c

@@ -103,21 +103,6 @@ static void* lovrGraphicsMapBuffer(BufferRole role, uint32_t count) {
   if (state.cursors[role] + count > limit) {
     lovrGraphicsFlush();
     state.cursors[role] = 0;
-
-    // Locks are placed as late as possible, causing the last lock to never get placed.  Whenever we
-    // wrap around a buffer, we gotta place that last missing lock.
-    state.locks[role][MAX_LOCKS - 1] = lovrGpuLock();
-  }
-
-  // Wait on any pending locks for the mapped region(s)
-  int firstLock = state.cursors[role] / (BUFFER_COUNTS[role] / MAX_LOCKS);
-  int lastLock = MIN(state.cursors[role] + count, BUFFER_COUNTS[role] - 1) / (BUFFER_COUNTS[role] / MAX_LOCKS);
-  for (int i = firstLock; i <= lastLock; i++) {
-    if (state.locks[role][i]) {
-      lovrGpuUnlock(state.locks[role][i]);
-      lovrGpuDestroyLock(state.locks[role][i]);
-      state.locks[role][i] = NULL;
-    }
   }
 
   return lovrBufferMap(buffer, state.cursors[role] * BUFFER_STRIDES[role]);
@@ -166,9 +151,6 @@ void lovrGraphicsDestroy() {
   }
   for (int i = 0; i < MAX_BUFFER_ROLES; i++) {
     lovrRelease(Buffer, state.buffers[i]);
-    for (int j = 0; j < MAX_LOCKS; j++) {
-      lovrGpuDestroyLock(state.locks[i][j]);
-    }
   }
   lovrRelease(Mesh, state.mesh);
   lovrRelease(Mesh, state.instancedMesh);
@@ -660,20 +642,6 @@ void lovrGraphicsFlush() {
       .height = batch->canvas ? lovrCanvasGetHeight(batch->canvas) : state.height,
       .stereo = batch->type != BATCH_FILL && (batch->canvas ? lovrCanvasIsStereo(batch->canvas) : state.camera.stereo)
     });
-
-    // Pop lock and drop it
-    for (int i = 0; i < MAX_BUFFER_ROLES; i++) {
-      if (batch->cursors[i].count > 0) {
-        size_t lockSize = BUFFER_COUNTS[i] / MAX_LOCKS;
-        size_t start = batch->cursors[i].start;
-        size_t count = batch->cursors[i].count + 1;
-        size_t firstLock = start / lockSize;
-        size_t lastLock = MIN(start + count, BUFFER_COUNTS[i] - 1) / lockSize;
-        for (size_t j = firstLock; j < lastLock; j++) {
-          state.locks[i][j] = lovrGpuLock();
-        }
-      }
-    }
   }
 }
 

src/modules/graphics/graphics.h

@@ -12,7 +12,6 @@
 #define MAX_TRANSFORMS 64
 #define MAX_BATCHES 16
 #define MAX_DRAWS 256
-#define MAX_LOCKS 4
 
 struct Buffer;
 struct Canvas;
@@ -192,7 +191,6 @@ typedef struct {
   struct Buffer* identityBuffer;
   struct Buffer* buffers[MAX_BUFFER_ROLES];
   uint32_t cursors[MAX_BUFFER_ROLES];
-  void* locks[MAX_BUFFER_ROLES][MAX_LOCKS];
   Batch batches[MAX_BATCHES];
   uint8_t batchCount;
 } GraphicsState;
@@ -334,9 +332,6 @@ void lovrGpuDraw(DrawCommand* draw);
 void lovrGpuStencil(StencilAction action, int replaceValue, StencilCallback callback, void* userdata);
 void lovrGpuPresent(void);
 void lovrGpuDirtyTexture(void);
-void* lovrGpuLock(void);
-void lovrGpuUnlock(void* lock);
-void lovrGpuDestroyLock(void* lock);
 void lovrGpuTick(const char* label);
 void lovrGpuTock(const char* label);
 const GpuFeatures* lovrGpuGetFeatures(void);

src/modules/graphics/opengl.c

@@ -1223,32 +1223,6 @@ void lovrGpuDirtyTexture() {
   state.textures[state.activeTexture] = NULL;
 }
 
-// We only need to sync when using mapped buffers
-void* lovrGpuLock() {
-#ifndef LOVR_WEBGL
-  return (void*) glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
-#endif
-  return NULL;
-}
-
-void lovrGpuUnlock(void* lock) {
-#ifndef LOVR_WEBGL
-  if (!lock) return;
-  GLsync sync = (GLsync) lock;
-  if (glClientWaitSync(sync, 0, 0) == GL_TIMEOUT_EXPIRED) {
-    while (glClientWaitSync(sync, GL_SYNC_FLUSH_COMMANDS_BIT, 32768) == GL_TIMEOUT_EXPIRED) {
-      continue;
-    }
-  }
-#endif
-}
-
-void lovrGpuDestroyLock(void* lock) {
-#ifndef LOVR_WEBGL
-  if (lock) glDeleteSync((GLsync) lock);
-#endif
-}
-
 void lovrGpuTick(const char* label) {
   TimerList* timer = map_get(&state.timers, label);
 

src/modules/graphics/opengl.h

@@ -12,7 +12,6 @@
 #pragma once
 
 #define GPU_BUFFER_FIELDS \
-  GLsync lock; \
   uint32_t id; \
   uint8_t incoherent;