fix(hud): offscreen legacy HUD rendering across 1.21

minecraft/src/main/java/org/polyfrost/oneconfig/internal/OneConfig.java

@@ -184,14 +184,10 @@ public static void render(GuiGraphicsExtractor graphics, float partial) {
         HudManager.targetPixelHeight = Platform.screen().viewportHeight();
 
         //~ if < 1.21.8 '.suppressInGameHudRender' -> '.shouldSuppressInGameHudRender()'
-        if (!SkiaCtx.INSTANCE.suppressInGameHudRender) {
+        boolean hudRendersLive = !SkiaCtx.INSTANCE.suppressInGameHudRender;
+        if (hudRendersLive || !org.polyfrost.oneconfig.internal.ui.hud.LegacyHudOffscreen.INSTANCE.render()) {
             LegacyHudRenderer.INSTANCE.renderLive(graphics);
         }
-        //? if >= 26.1 {
-        else org.polyfrost.oneconfig.internal.ui.hud.LegacyHudOffscreen.INSTANCE.render();
-        //? } else {
-        /*else LegacyHudRenderer.INSTANCE.renderLive(graphics);
-        *///? }
         // records the F3 overlay offscreen so Skia can put it above the Compose UI instead of below the
         // blur and it must run every frame regardless of the HUD dirty gate
         org.polyfrost.oneconfig.internal.ui.hud.DebugOverlayOffscreen.INSTANCE.render();

minecraft/src/main/kotlin/org/polyfrost/oneconfig/internal/ui/SkiaOffscreenTarget.kt

@@ -0,0 +1,103 @@
+package org.polyfrost.oneconfig.internal.ui
+
+import com.mojang.blaze3d.pipeline.RenderTarget
+import com.mojang.blaze3d.pipeline.TextureTarget
+import org.jetbrains.skia.BackendRenderTarget
+import org.jetbrains.skia.ColorSpace
+import org.jetbrains.skia.Surface
+import org.jetbrains.skia.SurfaceOrigin
+import org.polyfrost.oneconfig.internal.ui.compose.SkiaCtx
+import org.slf4j.LoggerFactory
+
+/** Owns a Minecraft render target and its Skia surface, cached by size. */
+class SkiaOffscreenTarget {
+    init {
+        live += this
+    }
+
+    var target: RenderTarget? = null
+        private set
+    private var brt: BackendRenderTarget? = null
+    var surface: Surface? = null
+        private set
+    private var lastW = -1
+    private var lastH = -1
+
+    fun resolveTarget(w: Int, h: Int): Boolean {
+        if (target != null && lastW == w && lastH == h && surface != null) return true
+        destroy()
+        val svc = SkiaCtx.vulkanService ?: return false
+        try {
+            //? if >= 26.2 {
+            val rt = TextureTarget(null, w, h, true, com.mojang.blaze3d.GpuFormat.RGBA8_UNORM)
+            //?} else if >= 1.21.5 {
+            /*val rt = TextureTarget(null, w, h, true)
+            *///?} else if >= 1.21.4 {
+            /*val rt = TextureTarget(w, h, true)
+            *///?} else {
+            /*val rt = TextureTarget(w, h, true, net.minecraft.client.Minecraft.ON_OSX)
+            *///?}
+            target = rt
+            //? if < 1.21.5
+            //rt.setClearColor(0f, 0f, 0f, 0f)
+            if (!SkiaCtx.isVulkanMode && RenderTargetFbo.getFboId(rt) <= 0) {
+                destroy()
+                return false
+            }
+            val (b, colorFmt) = svc.makeOffscreenBRT(rt, w, h)
+            brt = b
+            val origin = if (SkiaCtx.isDeferredComposeBackend) SurfaceOrigin.TOP_LEFT else SurfaceOrigin.BOTTOM_LEFT
+            surface = Surface.makeFromBackendRenderTarget(
+                SkiaCtx.directContext, b, origin, colorFmt, ColorSpace.sRGB, null,
+            )
+            if (surface == null) {
+                destroy()
+                return false
+            }
+            lastW = w; lastH = h
+            return true
+        } catch (t: Throwable) {
+            LOG.warn("Failed to create offscreen target", t)
+            destroy()
+            return false
+        }
+    }
+
+    fun clearTarget() {
+        val rt = target ?: return
+        //? if >= 26.2 {
+        val colorTex = rt.colorTexture ?: return
+        com.mojang.blaze3d.systems.RenderSystem.getDevice().createCommandEncoder()
+            .clearColorTexture(colorTex, org.joml.Vector4f(0f, 0f, 0f, 0f))
+        //? } else if >= 1.21.5 {
+        /*val colorTex = rt.colorTexture ?: return
+        val encoder = com.mojang.blaze3d.systems.RenderSystem.getDevice().createCommandEncoder()
+        encoder.clearColorTexture(colorTex, 0)
+        //? if < 1.21.10 {
+        /*//1.21.5 does not clear depth, and 1.21.8 clears it only after rendering the before-blur range
+        rt.depthTexture?.let { encoder.clearDepthTexture(it, 1.0) }
+        *///?}
+        *///?} elif >= 1.21.4 {
+        /*rt.clear()
+        *///?} else {
+        /*rt.clear(net.minecraft.client.Minecraft.ON_OSX)
+        *///?}
+    }
+
+    fun destroy() {
+        surface?.close(); surface = null
+        brt?.close(); brt = null
+        target?.destroyBuffers(); target = null
+        lastW = -1; lastH = -1
+    }
+
+    companion object {
+        private val LOG = LoggerFactory.getLogger("OneConfig/SkiaOffscreenTarget")
+
+        private val live = ArrayList<SkiaOffscreenTarget>(2)
+
+        fun destroyAll() {
+            for (t in live) t.destroy()
+        }
+    }
+}

minecraft/src/main/kotlin/org/polyfrost/oneconfig/internal/ui/compose/SkiaCtx.kt

@@ -572,6 +572,7 @@ object SkiaCtx {
         }
         destroyHudTarget()
         destroyComposeTarget()
+        org.polyfrost.oneconfig.internal.ui.SkiaOffscreenTarget.destroyAll()
     }
 
     private fun flushToTarget(draws: List<() -> Unit>, surface: Surface, flipY: Boolean = false) {
@@ -762,6 +763,7 @@ object SkiaCtx {
         composeAllocFailedAt = System.currentTimeMillis()
         destroyComposeTarget()
         destroyHudTarget()
+        org.polyfrost.oneconfig.internal.ui.SkiaOffscreenTarget.destroyAll()
         if (isVulkanMode) invalidateVkSurfaces()
         runCatching { directContext.flush() }
         LOG.error("SkiaCtx: failed to allocate the {}x{} compose target; skipping compose frames", w, h, error)

minecraft/src/main/kotlin/org/polyfrost/oneconfig/internal/ui/compose/impls/OneConfigUIScreen.kt

@@ -200,6 +200,7 @@ class OneConfigUIScreen @JvmOverloads constructor(
         SkiaCtx.suppressInGameHudRender = false
         HudManager.overrideShowInScreens = false
         HudManager.isConfigUiOpen = false
+        org.polyfrost.oneconfig.internal.ui.SkiaOffscreenTarget.destroyAll()
         UiSounds.releaseAmbience()
         // writing every registered tree hitches and Minecraft only re-grabs the cursor once this returns
         SAVE_EXECUTOR.execute {

minecraft/src/main/kotlin/org/polyfrost/oneconfig/internal/ui/hud/DebugOverlayOffscreen.kt

@@ -1,6 +1,6 @@
 package org.polyfrost.oneconfig.internal.ui.hud
 
-import com.mojang.blaze3d.pipeline.TextureTarget
+import com.mojang.blaze3d.pipeline.RenderTarget
 import net.minecraft.client.Minecraft
 import net.minecraft.client.gui.GuiGraphicsExtractor
 //? if >= 26.1 {
@@ -12,12 +12,9 @@ import org.polyfrost.oneconfig.internal.mixin.render.GuiRendererAccessor
 import org.polyfrost.oneconfig.internal.mixin.render.GameRendererAccessor
 import org.polyfrost.oneconfig.internal.mixin.render.GuiRendererAccessor
 *///? }
-import org.jetbrains.skia.BackendRenderTarget
-import org.jetbrains.skia.ColorSpace
 import org.jetbrains.skia.Paint
-import org.jetbrains.skia.Surface
-import org.jetbrains.skia.SurfaceOrigin
 import org.polyfrost.oneconfig.api.platform.v1.Platform
+import org.polyfrost.oneconfig.internal.ui.SkiaOffscreenTarget
 import org.polyfrost.oneconfig.internal.ui.compose.ComposeScreen
 import org.polyfrost.oneconfig.internal.ui.compose.SkiaCtx
 import org.slf4j.LoggerFactory
@@ -33,11 +30,7 @@ object DebugOverlayOffscreen {
     private val LOG = LoggerFactory.getLogger("OneConfig/DebugOverlayOffscreen")
     private val client get() = Minecraft.getInstance()
 
-    private var target: TextureTarget? = null
-    private var brt: BackendRenderTarget? = null
-    private var surface: Surface? = null
-    private var lastW = -1
-    private var lastH = -1
+    private val offscreen = SkiaOffscreenTarget()
 
     @Volatile private var hasContent = false
     @Volatile private var failed = false
@@ -67,8 +60,8 @@ object DebugOverlayOffscreen {
         if (w <= 0 || h <= 0) return
 
         try {
-            if (!resolveTarget(w, h)) return
-            val rt = target ?: return
+            if (!offscreen.resolveTarget(w, h)) return
+            val rt = offscreen.target ?: return
             //? if >= 1.21.8 {
             renderRecorded(rt)
             //? } else if >= 1.21.5 {
@@ -81,21 +74,20 @@ object DebugOverlayOffscreen {
             LOG.warn("Debug overlay offscreen render failed; disabling", t)
             failed = true
             capturing = false
-            //? if >= 1.21.5
             GuiTargetRedirect.target = null
         }
     }
 
     //? if >= 1.21.8 {
-    private fun renderRecorded(rt: TextureTarget) {
+    private fun renderRecorded(rt: RenderTarget) {
         val guiRenderer = (client.gameRenderer as GameRendererAccessor).`oneconfig$getGuiRenderer`()
         val accessor = guiRenderer as GuiRendererAccessor
 
         val state = GuiRenderState()
         //? if >= 1.21.11 {
         val ext = GuiGraphicsExtractor(client, state, Platform.screen().guiWidth(), Platform.screen().guiHeight())
         //? } else
-        /*val ext = GuiGraphicsExtractor(client, state)*/
+        //val ext = GuiGraphicsExtractor(client, state)
         capturing = true
         try {
             //~ if >= 26.1 'render' -> 'extractRenderState'
@@ -104,7 +96,7 @@ object DebugOverlayOffscreen {
             capturing = false
         }
 
-        clearTarget(rt)
+        offscreen.clearTarget()
 
         val prevState = accessor.`oneconfig$getRenderState`()
         GuiTargetRedirect.target = rt
@@ -123,11 +115,9 @@ object DebugOverlayOffscreen {
         }
     }
     //? } else if >= 1.21.5 {
-
-    /*
-    private fun renderImmediate(rt: TextureTarget) {
+    /*private fun renderImmediate(rt: RenderTarget) {
         val graphics = GuiGraphicsExtractor(client, client.renderBuffers().bufferSource())
-        clearTarget(rt)
+        offscreen.clearTarget()
         capturing = true
         GuiTargetRedirect.target = rt
         try {
@@ -139,106 +129,31 @@ object DebugOverlayOffscreen {
         }
     }
     *///? } else {
-
-    /*
-    private fun renderImmediateLegacy(rt: TextureTarget) {
+    /*private fun renderImmediateLegacy(rt: RenderTarget) {
         val graphics = GuiGraphicsExtractor(client, client.renderBuffers().bufferSource())
-        clearTarget(rt)
+        offscreen.clearTarget()
         capturing = true
-        rt.bindWrite(true)
+        GuiTargetRedirect.target = rt
         try {
+            rt.bindWrite(true)
             client.debugOverlay.render(graphics)
             graphics.flush()
         } finally {
+            GuiTargetRedirect.target = null
             client.mainRenderTarget.bindWrite(true)
             capturing = false
         }
     }
     *///? }
 
-    private fun clearTarget(rt: TextureTarget) {
-        //? if >= 26.2 {
-        val colorTex = rt.colorTexture ?: return
-        com.mojang.blaze3d.systems.RenderSystem.getDevice().createCommandEncoder()
-            .clearColorTexture(colorTex, org.joml.Vector4f(0f, 0f, 0f, 0f))
-        //? } else if >= 1.21.5 {
-        /*val colorTex = rt.colorTexture ?: return
-        com.mojang.blaze3d.systems.RenderSystem.getDevice().createCommandEncoder()
-            .clearColorTexture(colorTex, 0)
-        *///? } else if >= 1.21.4 {
-        /*rt.clear()
-        *///? } else {
-        /*rt.clear(Minecraft.ON_OSX)
-        *///? }
-    }
-
-    private fun resolveTarget(w: Int, h: Int): Boolean {
-        if (target != null && lastW == w && lastH == h && surface != null) return true
-        destroy()
-        try {
-            //? if >= 26.2 {
-            val rt = TextureTarget(null, w, h, true, com.mojang.blaze3d.GpuFormat.RGBA8_UNORM)
-            //? } else if >= 1.21.5 {
-            /*val rt = TextureTarget(null, w, h, true)
-            *///? } else if >= 1.21.4 {
-            /*val rt = TextureTarget(w, h, true)
-            *///? } else {
-            /*val rt = TextureTarget(w, h, true, Minecraft.ON_OSX)
-            *///? }
-            target = rt
-            //? if < 1.21.5
-            /*rt.setClearColor(0f, 0f, 0f, 0f)*/
-            val svc = SkiaCtx.vulkanService ?: return false
-            if (!SkiaCtx.isVulkanMode) {
-                //? if >= 1.21.5 {
-                val fboId = org.polyfrost.oneconfig.internal.ui.RenderTargetFbo.getFboId(rt)
-                //? } else
-                /*val fboId = rt.frameBufferId*/
-                if (fboId <= 0) {
-                    target = null
-                    rt.destroyBuffers()
-                    return false
-                }
-            }
-            val (b, colorFmt) = svc.makeOffscreenBRT(rt, w, h)
-            brt = b
-            val origin = if (SkiaCtx.isDeferredComposeBackend) SurfaceOrigin.TOP_LEFT else SurfaceOrigin.BOTTOM_LEFT
-            surface = Surface.makeFromBackendRenderTarget(
-                SkiaCtx.directContext, b, origin, colorFmt, ColorSpace.sRGB, null,
-            )
-            if (surface == null) {
-                b.close(); brt = null
-                return false
-            }
-            lastW = w; lastH = h
-            return true
-        } catch (t: Throwable) {
-            LOG.warn("Failed to create debug overlay offscreen target", t)
-            destroy()
-            return false
-        }
-    }
-
     private fun drawInto(canvas: org.jetbrains.skia.Canvas) {
         if (!hasContent) return
-        val s = surface ?: return
+        val s = offscreen.surface ?: return
         try {
             s.notifyContentWillChange(org.jetbrains.skia.ContentChangeMode.RETAIN)
             s.draw(canvas, 0, 0, blitPaint)
         } catch (t: Throwable) {
             LOG.debug("debug overlay blit failed", t)
         }
     }
-
-    private fun destroy() {
-        surface?.close(); surface = null
-        brt?.close(); brt = null
-        target?.destroyBuffers(); target = null
-        lastW = -1; lastH = -1
-    }
-
-    fun invalidate() {
-        destroy()
-        hasContent = false
-    }
 }