Merge pull request #7 from silenium-dev/fix/black-frames-on-resize

fix: black frames on resize

Author: silenium-dev

…a/dev/silenium/compose/gl/fbo/FBOFifo.kt …enium/compose/gl/fbo/FBOFifoSwapChain.ktsrc/main/java/dev/silenium/compose/gl/fbo/FBOFifo.kt renamed to src/main/java/dev/silenium/compose/gl/fbo/FBOFifoSwapChain.kt src/main/java/dev/silenium/compose/gl/fbo/FBOFifo.kt renamed to src/main/java/dev/silenium/compose/gl/fbo/FBOFifoSwapChain.kt

@@ -5,7 +5,9 @@ import java.util.concurrent.ArrayBlockingQueue
 import java.util.concurrent.locks.ReentrantLock
 import kotlin.concurrent.withLock
 
-class FBOFifo(capacity: Int, private val fboCreator: (IntSize) -> FBOPool.FBO) : IFBOPresentMode {
+class FBOFifoSwapChain(capacity: Int, override val fboCreator: (IntSize) -> FBOPool.FBO) : FBOSwapChain() {
+    override var size: IntSize = IntSize.Zero
+        private set
     private val displayLock = ReentrantLock()
     private var toDisplay: FBOPool.FBO? = null
     private val renderQueue = ArrayBlockingQueue<FBOPool.FBO>(capacity)
@@ -14,21 +16,30 @@ class FBOFifo(capacity: Int, private val fboCreator: (IntSize) -> FBOPool.FBO) :
     override fun display(block: (FBOPool.FBO) -> Unit) = displayLock.withLock {
         toDisplay?.let(block)
         if (!displayQueue.isEmpty()) {
-            toDisplay?.let(renderQueue::offer)
+            toDisplay?.let{
+                if (it.size != size) it.destroy()
+                else renderQueue.offer(it)
+            }
             toDisplay = displayQueue.poll()
         }
     }
 
     override suspend fun <R> render(block: suspend (FBOPool.FBO) -> R): R? {
         val fbo = renderQueue.poll() ?: return null
         val result = block(fbo)
+        if (fbo.size != size) {
+            fbo.destroy()
+            return null
+        }
         displayQueue.offer(fbo)
         return result
     }
 
     override fun resize(size: IntSize) {
-        destroyFBOs()
-        fillRenderQueue { fboCreator(size) }
+        this.size = size
+        renderQueue.onEach { it.destroy() }.clear()
+        displayQueue.onEach { it.destroy() }.clear()
+        renderQueue.fillRenderQueue(fboCreator, size)
     }
 
     override fun destroyFBOs() {
@@ -39,10 +50,4 @@ class FBOFifo(capacity: Int, private val fboCreator: (IntSize) -> FBOPool.FBO) :
             toDisplay = null
         }
     }
-
-    private fun fillRenderQueue(generator: () -> FBOPool.FBO) {
-        while (renderQueue.remainingCapacity() > 0) {
-            renderQueue.offer(generator())
-        }
-    }
 }

…ev/silenium/compose/gl/fbo/FBOMailbox.kt …um/compose/gl/fbo/FBOMailboxSwapChain.ktsrc/main/java/dev/silenium/compose/gl/fbo/FBOMailbox.kt renamed to src/main/java/dev/silenium/compose/gl/fbo/FBOMailboxSwapChain.kt src/main/java/dev/silenium/compose/gl/fbo/FBOMailbox.kt renamed to src/main/java/dev/silenium/compose/gl/fbo/FBOMailboxSwapChain.kt

@@ -5,7 +5,9 @@ import java.util.concurrent.ArrayBlockingQueue
 import java.util.concurrent.locks.ReentrantLock
 import kotlin.concurrent.withLock
 
-class FBOMailbox(capacity: Int, private val fboCreator: (IntSize) -> FBOPool.FBO) : IFBOPresentMode {
+class FBOMailboxSwapChain(capacity: Int, override val fboCreator: (IntSize) -> FBOPool.FBO) : FBOSwapChain() {
+    override var size: IntSize = IntSize.Zero
+        private set
     private val displayLock = ReentrantLock()
     private val waitingLock = ReentrantLock()
     private var waitingFBO: FBOPool.FBO? = null
@@ -15,7 +17,12 @@ class FBOMailbox(capacity: Int, private val fboCreator: (IntSize) -> FBOPool.FBO
     override fun display(block: (FBOPool.FBO) -> Unit) = displayLock.withLock {
         toDisplay?.let(block)
         waitingLock.withLock {
-            if (waitingFBO == null) return
+            val waiting = waitingFBO ?: return
+            if (waiting.size != size) {
+                waiting.destroy()
+                waitingFBO = null
+                return
+            }
             toDisplay = waitingFBO
             waitingFBO = null
         }
@@ -24,8 +31,15 @@ class FBOMailbox(capacity: Int, private val fboCreator: (IntSize) -> FBOPool.FBO
     override suspend fun <R> render(block: suspend (FBOPool.FBO) -> R): R? {
         val fbo = renderQueue.poll() ?: return null
         val result = block(fbo)
+        if (fbo.size != size) {
+            fbo.destroy()
+            return null
+        }
         displayLock.withLock {
-            toDisplay?.let(renderQueue::offer)
+            toDisplay?.let {
+                if (it.size != size) it.destroy()
+                else renderQueue.offer(it)
+            }
             toDisplay = fbo
         }
         if (displayLock.tryLock()) {
@@ -38,8 +52,9 @@ class FBOMailbox(capacity: Int, private val fboCreator: (IntSize) -> FBOPool.FBO
     }
 
     override fun resize(size: IntSize) {
-        destroyFBOs()
-        fillRenderQueue { fboCreator(size) }
+        this.size = size
+        renderQueue.onEach { it.destroy() }.clear()
+        renderQueue.fillRenderQueue(fboCreator, size)
     }
 
     override fun destroyFBOs() {
@@ -53,10 +68,4 @@ class FBOMailbox(capacity: Int, private val fboCreator: (IntSize) -> FBOPool.FBO
             waitingFBO = null
         }
     }
-
-    private fun fillRenderQueue(generator: () -> FBOPool.FBO) {
-        while (renderQueue.remainingCapacity() > 0) {
-            renderQueue.offer(generator())
-        }
-    }
 }

src/main/java/dev/silenium/compose/gl/fbo/FBOPool.kt

@@ -18,7 +18,7 @@ class FBOPool(
     private val render: EGLContext,
     private val display: EGLContext,
     var size: IntSize,
-    swapChainFactory: (Int, (IntSize) -> FBO) -> IFBOPresentMode,
+    swapChainFactory: (Int, (IntSize) -> FBO) -> FBOSwapChain,
     swapChainSize: Int = 10,
 ) {
     data class FBO(
@@ -49,7 +49,7 @@ class FBOPool(
         }
     }
 
-    private val swapChain: IFBOPresentMode = swapChainFactory(swapChainSize, ::createFBO)
+    private val swapChain: FBOSwapChain = swapChainFactory(swapChainSize, ::createFBO)
 
     private enum class ContextType {
         RENDER,
@@ -153,11 +153,11 @@ class FBOPool(
      * @return wait time for the next frame
      */
     suspend fun render(deltaTime: Duration, block: suspend GLDrawScope.() -> Unit): Duration? =
-        swapChain.render { fbo ->
-            ensureContext(ContextType.RENDER) {
-                if (fbo.size != size) ensureContext(ContextType.RENDER) {
-                    swapChain.resize(size)
-                }
+        ensureContext(ContextType.RENDER) {
+            if (swapChain.size != size) {
+                swapChain.resize(size)
+            }
+            swapChain.render { fbo ->
                 fbo.bind()
                 val drawScope = GLDrawScopeImpl(fbo, deltaTime)
                 drawScope.block()

src/main/java/dev/silenium/compose/gl/fbo/FBOSwapChain.kt

@@ -0,0 +1,19 @@
+package dev.silenium.compose.gl.fbo
+
+import androidx.compose.ui.unit.IntSize
+import java.util.concurrent.ArrayBlockingQueue
+
+abstract class FBOSwapChain {
+    abstract val size: IntSize
+    protected abstract val fboCreator: (IntSize) -> FBOPool.FBO
+    abstract fun display(block: (FBOPool.FBO) -> Unit)
+    abstract suspend fun <R> render(block: suspend (FBOPool.FBO) -> R): R?
+    abstract fun resize(size: IntSize)
+    abstract fun destroyFBOs()
+}
+
+fun ArrayBlockingQueue<FBOPool.FBO>.fillRenderQueue(fboCreator: (IntSize) -> FBOPool.FBO, size: IntSize) {
+    while (remainingCapacity() > 0) {
+        offer(fboCreator(size))
+    }
+}

src/main/java/dev/silenium/compose/gl/fbo/IFBOPresentMode.kt

@@ -72,19 +72,19 @@ class GLSurfaceView internal constructor(
     private val presentMode: PresentMode = PresentMode.MAILBOX,
     private val swapChainSize: Int = 10,
 ) {
-    enum class PresentMode(internal val impl: (Int, (IntSize) -> FBOPool.FBO) -> IFBOPresentMode) {
+    enum class PresentMode(internal val impl: (Int, (IntSize) -> FBOPool.FBO) -> FBOSwapChain) {
         /**
          * Renders the latest frame and discards all the previous frames.
          * Results in the lowest latency.
          */
-        MAILBOX(::FBOMailbox),
+        MAILBOX(::FBOMailboxSwapChain),
 
         /**
          * Renders all the frames in the order they were produced.
          * Results in a higher latency, but smoother animations.
          * Limits the framerate to the display refresh rate.
          */
-        FIFO(::FBOFifo),
+        FIFO(::FBOFifoSwapChain),
     }
 
     private var directContext: DirectContext? = null

src/main/java/dev/silenium/compose/gl/surface/GLSurfaceView.kt

@@ -42,6 +42,7 @@ fun ApplicationScope.App() {
             GLSurfaceView(
                 state = state,
                 modifier = Modifier.aspectRatio(1f).fillMaxSize(),
+                presentMode = GLSurfaceView.PresentMode.MAILBOX,
             ) {
                 glClearColor(color.red, color.green, color.blue, color.alpha)
 //                glClearColor(1.0f, 0.2f, 0.6f, 0.5f)