fixed a bug where inventory cell would not position correctly when streamermode is changed; where screencapturing for saving would only capture from FboRGB

src/net/torvald/terrarum/console/ScreencapNogui.kt

@@ -11,14 +11,14 @@ object ScreencapNogui: ConsoleCommand {
 
     override fun execute(args: Array<String>) {
         if (args.size == 2) {
-            IngameRenderer.fboRGBexportCallback = {
+            IngameRenderer.screencapExportCallback = {
                 val w = 960
                 val h = 640
                 val p = Pixmap.createFromFrameBuffer((it.width - w).ushr(1), (it.height - h).ushr(1), w, h)
                 PixmapIO2.writeTGA(Gdx.files.absolute(App.defaultDir + "/Exports/${args[1]}.tga"), p, true)
                 p.dispose()
             }
-            IngameRenderer.fboRGBexportRequested = true
+            IngameRenderer.screencapRequested = true
             Echo("FBO exported to$ccG Exports/${args[1]}.tga")
         }
     }

src/net/torvald/terrarum/modulebasegame/IngameRenderer.kt

@@ -44,8 +44,10 @@ object IngameRenderer : Disposable {
     private lateinit var fboRGB_lightMixed: FrameBuffer
     private lateinit var fboA: FrameBuffer
     private lateinit var fboA_lightMixed: FrameBuffer
+    private lateinit var fboMixedOut: FrameBuffer
     private lateinit var rgbTex: TextureRegion
     private lateinit var aTex: TextureRegion
+    private lateinit var mixedOutTex: TextureRegion
     private lateinit var lightTex: TextureRegion
     private lateinit var blurTex: TextureRegion
 
@@ -93,17 +95,9 @@ object IngameRenderer : Disposable {
         shaderBlur = App.loadShaderFromFile("assets/blur.vert", "assets/blur.frag")
 
 
-        if (App.getConfigBoolean("fx_dither")) {
+        shaderBayer = App.loadShaderFromFile("assets/4096.vert", "assets/4096_bayer.frag") // always load the shader regardless of config because the config may cange
-            shaderBayer = App.loadShaderFromFile("assets/4096.vert", "assets/4096_bayer.frag")
-        }
-        else {
-            shaderBayer = App.loadShaderFromFile("assets/4096.vert", "assets/passthrurgb.frag")
-        }
-
         shaderAlphaDither = App.loadShaderFromFile("assets/4096.vert", "assets/alphadither.frag")
-
         shaderBlendGlow = App.loadShaderFromFile("assets/blendGlow.vert", "assets/blendGlow.frag")
-
         shaderRGBOnly = App.loadShaderFromFile("assets/4096.vert", "assets/rgbonly.frag")
         shaderAtoGrey = App.loadShaderFromFile("assets/4096.vert", "assets/aonly.frag")
 
@@ -223,117 +217,131 @@ object IngameRenderer : Disposable {
 
         ///////////////////////////////////////////////////////////////////////
 
-        // draw sky
-        WeatherMixer.render(camera, batch, world)
-
-        ///////////////////////////////////////////////////////////////////////
-
         // use shader to mix RGB and A
         setCameraPosition(0f, 0f)
 
         rgbTex.texture.setFilter(Texture.TextureFilter.Nearest, Texture.TextureFilter.Nearest)
         aTex.texture.setFilter(Texture.TextureFilter.Nearest, Texture.TextureFilter.Nearest)
 
-        // normal behaviour
+        fboMixedOut.inAction(camera, batch) {
-        if (!KeyToggler.isOn(Input.Keys.F6) &&
+            gdxClearAndSetBlend(0f, 0f, 0f, 0f)
-            !KeyToggler.isOn(Input.Keys.F7)
-        ) {
-            debugMode = 0
 
-            aTex.texture.bind(1)
+            // draw sky
-            Gdx.gl.glActiveTexture(GL20.GL_TEXTURE0) // so that batch that comes next will bind any tex to it
+            WeatherMixer.render(camera, batch, world)
 
 
-            batch.inUse {
+            // normal behaviour
-                blendNormal(batch)
+            if (!KeyToggler.isOn(Input.Keys.F6) &&
-                batch.shader = shaderBlendGlow
+                !KeyToggler.isOn(Input.Keys.F7)
-                shaderBlendGlow.setUniformi("tex1", 1)
+            ) {
-                batch.draw(rgbTex,
+                debugMode = 0
-                        -0.5f * rgbTex.regionWidth * zoom + 0.5f * rgbTex.regionWidth,
+
-                        -0.5f * rgbTex.regionHeight * zoom + 0.5f * rgbTex.regionHeight,
+                aTex.texture.bind(1)
-                        rgbTex.regionWidth * zoom,
+                Gdx.gl.glActiveTexture(GL20.GL_TEXTURE0) // so that batch that comes next will bind any tex to it
-                        rgbTex.regionHeight * zoom
+
-                )
+
+                batch.inUse {
+                    blendNormal(batch)
+                    batch.shader = shaderBlendGlow
+                    shaderBlendGlow.setUniformi("tex1", 1)
+                    batch.draw(rgbTex,
+                            -0.5f * rgbTex.regionWidth * zoom + 0.5f * rgbTex.regionWidth,
+                            -0.5f * rgbTex.regionHeight * zoom + 0.5f * rgbTex.regionHeight,
+                            rgbTex.regionWidth * zoom,
+                            rgbTex.regionHeight * zoom
+                    )
+                }
+
+
+                // blending is correct... somewhat. Alpha must be premultiplied
             }
+            // something about RGB
+            else if (KeyToggler.isOn(Input.Keys.F6) &&
+                     !KeyToggler.isOn(Input.Keys.F7)
+            ) {
+                debugMode = 1
+                batch.inUse {
+                    blendNormal(batch)
+                    batch.shader = null
+                    batch.draw(rgbTex,
+                            -0.5f * rgbTex.regionWidth * zoom + 0.5f * rgbTex.regionWidth,
+                            -0.5f * rgbTex.regionHeight * zoom + 0.5f * rgbTex.regionHeight,
+                            rgbTex.regionWidth * zoom,
+                            rgbTex.regionHeight * zoom
+                    )
 
+                    // indicator
+                    batch.color = Color.RED
+                    batch.fillRect(0f, 0f, 6f, 10f)
+                    batch.color = Color.LIME
+                    batch.fillRect(6f, 0f, 6f, 10f)
+                    batch.color = Color.ROYAL
+                    batch.fillRect(12f, 0f, 6f, 10f)
+                    batch.color = Color.WHITE
+                }
 
-            // blending is correct... somewhat. Alpha must be premultiplied
+                // works as intended
-        }
-        // something about RGB
-        else if (KeyToggler.isOn(Input.Keys.F6) &&
-                 !KeyToggler.isOn(Input.Keys.F7)
-        ) {
-            debugMode = 1
-            batch.inUse {
-                blendNormal(batch)
-                batch.shader = null
-                batch.draw(rgbTex,
-                        -0.5f * rgbTex.regionWidth * zoom + 0.5f * rgbTex.regionWidth,
-                        -0.5f * rgbTex.regionHeight * zoom + 0.5f * rgbTex.regionHeight,
-                        rgbTex.regionWidth * zoom,
-                        rgbTex.regionHeight * zoom
-                )
-
-                // indicator
-                batch.color = Color.RED
-                batch.fillRect(0f, 0f, 6f, 10f)
-                batch.color = Color.LIME
-                batch.fillRect(6f, 0f, 6f, 10f)
-                batch.color = Color.ROYAL
-                batch.fillRect(12f, 0f, 6f, 10f)
-                batch.color = Color.WHITE
             }
+            // something about A
+            else if (!KeyToggler.isOn(Input.Keys.F6) &&
+                     KeyToggler.isOn(Input.Keys.F7)
+            ) {
+                debugMode = 2
+                batch.inUse {
+                    blendNormal(batch)
+                    batch.shader = null
+                    batch.draw(aTex,
+                            -0.5f * aTex.regionWidth * zoom + 0.5f * aTex.regionWidth,
+                            -0.5f * aTex.regionHeight * zoom + 0.5f * aTex.regionHeight,
+                            aTex.regionWidth * zoom,
+                            aTex.regionHeight * zoom
+                    )
 
-            // works as intended
+                    // indicator
-        }
+                    batch.color = Color.WHITE
-        // something about A
+                    batch.fillRect(18f, 0f, 18f, 10f)
-        else if (!KeyToggler.isOn(Input.Keys.F6) &&
+                }
-                 KeyToggler.isOn(Input.Keys.F7)
-        ) {
-            debugMode = 2
-            batch.inUse {
-                blendNormal(batch)
-                batch.shader = null
-                batch.draw(aTex,
-                        -0.5f * aTex.regionWidth * zoom + 0.5f * aTex.regionWidth,
-                        -0.5f * aTex.regionHeight * zoom + 0.5f * aTex.regionHeight,
-                        aTex.regionWidth * zoom,
-                        aTex.regionHeight * zoom
-                )
 
-                // indicator
+                // works as intended
-                batch.color = Color.WHITE
-                batch.fillRect(18f, 0f, 18f, 10f)
-            }
-
-            // works as intended
-        }
-        else {
-            if (debugMode == 1) {
-                KeyToggler.forceSet(Input.Keys.F6, false)
-                KeyToggler.forceSet(Input.Keys.F7, true)
-            }
-            else if (debugMode == 2) {
-                KeyToggler.forceSet(Input.Keys.F6, true)
-                KeyToggler.forceSet(Input.Keys.F7, false)
             }
             else {
-                KeyToggler.forceSet(Input.Keys.F6, false)
+                if (debugMode == 1) {
-                KeyToggler.forceSet(Input.Keys.F7, false)
+                    KeyToggler.forceSet(Input.Keys.F6, false)
+                    KeyToggler.forceSet(Input.Keys.F7, true)
+                }
+                else if (debugMode == 2) {
+                    KeyToggler.forceSet(Input.Keys.F6, true)
+                    KeyToggler.forceSet(Input.Keys.F7, false)
+                }
+                else {
+                    KeyToggler.forceSet(Input.Keys.F6, false)
+                    KeyToggler.forceSet(Input.Keys.F7, false)
+                }
+
+                // works as intended
             }
-
-            // works as intended
         }
 
-
         blendNormal(batch)
 
+        batch.inUse {
+            // it's no use applying dithering here: colours are no longer "floats" once they're written to the FBO
+            // proof: disable dithering on skybox and enable dither here -- banding is still visible
+            // it would work if GDX supported HDR, or GL_RGBA32F as a texture format, but alas.
+            // but mixedOutTex is still needed for the screen capturing
+
+            //batch.shader = if (App.getConfigBoolean("fx_dither")) IngameRenderer.shaderBayer else null
+            batch.shader = null
+            batch.draw(mixedOutTex, 0f, 0f)
+        }
+
+
         ///////////////////////////////////////////////////////////////////////
 
-        if (fboRGBexportRequested) {
+        if (screencapRequested) {
-            fboRGBexportRequested = false
+            screencapRequested = false
             try {
-                fboRGBexportCallback(fboRGB)
+                screencapExportCallback(fboMixedOut)
             }
             catch (e: Throwable) {
                 e.printStackTrace()
@@ -376,9 +384,9 @@ object IngameRenderer : Disposable {
         processBlur(lightmapFboA, lightmapFboB)
     }
 
-    @Volatile internal var fboRGBexportRequested = false
+    @Volatile internal var screencapRequested = false
     @Volatile internal var fboRGBexportedLatch = false
-    @Volatile internal var fboRGBexportCallback: (FrameBuffer) -> Unit = {}
+    @Volatile internal var screencapExportCallback: (FrameBuffer) -> Unit = {}
     @Volatile internal lateinit var fboRGBexport: Pixmap
 
     private fun drawToRGB(
@@ -691,6 +699,7 @@ object IngameRenderer : Disposable {
         fboRGB_lightMixed = FrameBuffer(Pixmap.Format.RGBA8888, width, height, true)
         fboA = FrameBuffer(Pixmap.Format.RGBA8888, width, height, true)
         fboA_lightMixed = FrameBuffer(Pixmap.Format.RGBA8888, width, height, true)
+        fboMixedOut = FrameBuffer(Pixmap.Format.RGBA8888, width, height, true)
         lightmapFboA = FrameBuffer(
                 Pixmap.Format.RGBA8888,
                 LightmapRenderer.lightBuffer.width * LightmapRenderer.DRAW_TILE_SIZE.toInt(),
@@ -707,6 +716,7 @@ object IngameRenderer : Disposable {
         aTex = TextureRegion(fboA_lightMixed.colorBufferTexture)
         lightTex = TextureRegion(lightmapFboB.colorBufferTexture)
         blurTex = TextureRegion()
+        mixedOutTex = TextureRegion(fboMixedOut.colorBufferTexture)
 
         BlocksDrawer.resize(width, height)
         LightmapRenderer.resize(width, height)
@@ -726,6 +736,7 @@ object IngameRenderer : Disposable {
         fboA.dispose()
         fboRGB_lightMixed.dispose()
         fboA_lightMixed.dispose()
+        fboMixedOut.dispose()
         lightmapFboA.dispose()
         lightmapFboB.dispose()
 

src/net/torvald/terrarum/modulebasegame/gameactors/FixtureStorageChest.kt

@@ -135,8 +135,8 @@ internal class UIStorageChest : UICanvas(
                     this,
                     catBar,
                     { getFixtureInventory() },
-                    INVENTORY_CELLS_OFFSET_X - halfSlotOffset,
+                    INVENTORY_CELLS_OFFSET_X() - halfSlotOffset,
-                    INVENTORY_CELLS_OFFSET_Y,
+                    INVENTORY_CELLS_OFFSET_Y(),
                     6, CELLS_VRT,
                     drawScrollOnRightside = false,
                     drawWallet = false,
@@ -152,8 +152,8 @@ internal class UIStorageChest : UICanvas(
                     this,
                     catBar,
                     { INGAME.actorNowPlaying!!.inventory }, // literally a player's inventory
-                    INVENTORY_CELLS_OFFSET_X - halfSlotOffset + (listGap + UIItemInventoryElemWide.height) * 7,
+                    INVENTORY_CELLS_OFFSET_X() - halfSlotOffset + (listGap + UIItemInventoryElemWide.height) * 7,
-                    INVENTORY_CELLS_OFFSET_Y,
+                    INVENTORY_CELLS_OFFSET_Y(),
                     6, CELLS_VRT,
                     drawScrollOnRightside = true,
                     drawWallet = false,

src/net/torvald/terrarum/modulebasegame/ui/UIInventoryCells.kt

@@ -42,8 +42,8 @@ internal class UIInventoryCells(
                     full,
                     full.catBar,
                     { full.actor.inventory },
-                    INVENTORY_CELLS_OFFSET_X,
+                    INVENTORY_CELLS_OFFSET_X(),
-                    INVENTORY_CELLS_OFFSET_Y,
+                    INVENTORY_CELLS_OFFSET_Y(),
                     CELLS_HOR, CELLS_VRT,
                     keyDownFun = createInvCellGenericKeyDownFun(),
                     touchDownFun = createInvCellGenericTouchDownFun { rebuildList() }
@@ -54,7 +54,7 @@ internal class UIInventoryCells(
             UIItemInventoryEquippedView(
                     full,
                     internalWidth - UIItemInventoryEquippedView.WIDTH + (width - internalWidth) / 2,
-                    INVENTORY_CELLS_OFFSET_Y,
+                    INVENTORY_CELLS_OFFSET_Y(),
                     { rebuildList() }
             )
 

src/net/torvald/terrarum/modulebasegame/ui/UIInventoryEscMenu.kt

@@ -34,7 +34,7 @@ class UIInventoryEscMenu(val full: UIInventoryFull) : UICanvas() {
     private val gameMenuButtons = UIItemTextButtonList(
             this, DEFAULT_LINE_HEIGHT, gameMenu,
             (width - gameMenuListWidth) / 2,
-            INVENTORY_CELLS_OFFSET_Y + (INVENTORY_CELLS_UI_HEIGHT - gameMenuListHeight) / 2,
+            INVENTORY_CELLS_OFFSET_Y() + (INVENTORY_CELLS_UI_HEIGHT - gameMenuListHeight) / 2,
             gameMenuListWidth, gameMenuListHeight,
             readFromLang = true,
             textAreaWidth = gameMenuListWidth,
@@ -47,7 +47,7 @@ class UIInventoryEscMenu(val full: UIInventoryFull) : UICanvas() {
     private val areYouSureMainMenuButtons = UIItemTextButtonList(
             this, DEFAULT_LINE_HEIGHT, arrayOf("MENU_LABEL_RETURN_MAIN_QUESTION", "MENU_LABEL_RETURN_MAIN", "MENU_LABEL_CANCEL"),
             (width - gameMenuListWidth) / 2,
-            INVENTORY_CELLS_OFFSET_Y + (INVENTORY_CELLS_UI_HEIGHT - (DEFAULT_LINE_HEIGHT * 3)) / 2,
+            INVENTORY_CELLS_OFFSET_Y() + (INVENTORY_CELLS_UI_HEIGHT - (DEFAULT_LINE_HEIGHT * 3)) / 2,
             gameMenuListWidth, DEFAULT_LINE_HEIGHT * 3,
             readFromLang = true,
             textAreaWidth = gameMenuListWidth,
@@ -60,7 +60,7 @@ class UIInventoryEscMenu(val full: UIInventoryFull) : UICanvas() {
     private val areYouSureQuitButtons = UIItemTextButtonList(
             this, DEFAULT_LINE_HEIGHT, arrayOf("MENU_LABEL_DESKTOP_QUESTION", "MENU_LABEL_DESKTOP", "MENU_LABEL_CANCEL"),
             (width - gameMenuListWidth) / 2,
-            INVENTORY_CELLS_OFFSET_Y + (INVENTORY_CELLS_UI_HEIGHT - (DEFAULT_LINE_HEIGHT * 3)) / 2,
+            INVENTORY_CELLS_OFFSET_Y() + (INVENTORY_CELLS_UI_HEIGHT - (DEFAULT_LINE_HEIGHT * 3)) / 2,
             gameMenuListWidth, DEFAULT_LINE_HEIGHT * 3,
             readFromLang = true,
             textAreaWidth = gameMenuListWidth,

src/net/torvald/terrarum/modulebasegame/ui/UIInventoryFull.kt

@@ -49,8 +49,8 @@ class UIInventoryFull(
         val itemListHeight: Int = CELLS_VRT * UIItemInventoryElemSimple.height + (CELLS_VRT - 1) * net.torvald.terrarum.modulebasegame.ui.UIItemInventoryItemGrid.Companion.listGap
 
         val INVENTORY_CELLS_UI_HEIGHT: Int = CELLS_VRT * UIItemInventoryElemSimple.height + (CELLS_VRT - 1) * UIItemInventoryItemGrid.listGap
-        val INVENTORY_CELLS_OFFSET_X = 0 + (Toolkit.drawWidth - internalWidth) / 2
+        val INVENTORY_CELLS_OFFSET_X = { 0 + (Toolkit.drawWidth - internalWidth) / 2 }
-        val INVENTORY_CELLS_OFFSET_Y: Int = 107 + (App.scr.height - internalHeight) / 2
+        val INVENTORY_CELLS_OFFSET_Y = { 107 + (App.scr.height - internalHeight) / 2 }
 
         val catBarWidth = 330
 
@@ -164,7 +164,7 @@ class UIInventoryFull(
     private val transitionPanel = UIItemHorizontalFadeSlide(
             this,
             (width - internalWidth) / 2,
-            INVENTORY_CELLS_OFFSET_Y,
+            INVENTORY_CELLS_OFFSET_Y(),
             width,
             App.scr.height,
             1f,

src/net/torvald/terrarum/modulebasegame/ui/UIInventoryMinimap.kt

@@ -42,11 +42,13 @@ class UIInventoryMinimap(val full: UIInventoryFull) : UICanvas() {
 
     override fun renderUI(batch: SpriteBatch, camera: Camera) {
         blendNormal(batch)
+        val cellOffY = INVENTORY_CELLS_OFFSET_Y()
+
 
         // update map panning
         // if left click is down and cursor is in the map area
         if (Gdx.input.isButtonPressed(App.getConfigInt("config_mouseprimary")) &&
-            Terrarum.mouseScreenY in INVENTORY_CELLS_OFFSET_Y..INVENTORY_CELLS_OFFSET_Y + INVENTORY_CELLS_UI_HEIGHT) {
+            Terrarum.mouseScreenY in cellOffY..cellOffY + INVENTORY_CELLS_UI_HEIGHT) {
             minimapPanX += Terrarum.mouseDeltaX * 2f / minimapZoom
             minimapPanY += Terrarum.mouseDeltaY * 2f / minimapZoom
         }
@@ -116,23 +118,23 @@ class UIInventoryMinimap(val full: UIInventoryFull) : UICanvas() {
         batch.begin()
 
         if (debugvals) {
-            App.fontSmallNumbers.draw(batch, "$minimapPanX, $minimapPanY; x$minimapZoom", (width - MINIMAP_WIDTH) / 2, -10f + INVENTORY_CELLS_OFFSET_Y)
+            App.fontSmallNumbers.draw(batch, "$minimapPanX, $minimapPanY; x$minimapZoom", (width - MINIMAP_WIDTH) / 2, -10f + cellOffY)
         }
 
         batch.projectionMatrix = camera.combined
         // 1px stroke
         batch.color = Color.WHITE
-        batch.fillRect((width - MINIMAP_WIDTH) / 2, -1 + INVENTORY_CELLS_OFFSET_Y.toFloat(), MINIMAP_WIDTH, 1f)
+        batch.fillRect((width - MINIMAP_WIDTH) / 2, -1 + cellOffY.toFloat(), MINIMAP_WIDTH, 1f)
-        batch.fillRect((width - MINIMAP_WIDTH) / 2, INVENTORY_CELLS_OFFSET_Y + MINIMAP_HEIGHT, MINIMAP_WIDTH, 1f)
+        batch.fillRect((width - MINIMAP_WIDTH) / 2, cellOffY + MINIMAP_HEIGHT, MINIMAP_WIDTH, 1f)
-        batch.fillRect(-1 + (width - MINIMAP_WIDTH) / 2, INVENTORY_CELLS_OFFSET_Y.toFloat(), 1f, MINIMAP_HEIGHT)
+        batch.fillRect(-1 + (width - MINIMAP_WIDTH) / 2, cellOffY.toFloat(), 1f, MINIMAP_HEIGHT)
-        batch.fillRect((width - MINIMAP_WIDTH) / 2 + MINIMAP_WIDTH, INVENTORY_CELLS_OFFSET_Y.toFloat(), 1f, MINIMAP_HEIGHT)
+        batch.fillRect((width - MINIMAP_WIDTH) / 2 + MINIMAP_WIDTH, cellOffY.toFloat(), 1f, MINIMAP_HEIGHT)
 
         // control hints
         batch.color = Color.WHITE
         App.fontGame.draw(batch, full.minimapControlHelp, full.offsetX, full.yEnd - 20)
 
         // the minimap
-        batch.draw(minimapFBO.colorBufferTexture, (width - MINIMAP_WIDTH) / 2, INVENTORY_CELLS_OFFSET_Y.toFloat())
+        batch.draw(minimapFBO.colorBufferTexture, (width - MINIMAP_WIDTH) / 2, cellOffY.toFloat())
     }
 
     override fun doOpening(delta: Float) {}

src/net/torvald/terrarum/serialise/WriteSavegame.kt

@@ -1,6 +1,5 @@
 package net.torvald.terrarum.serialise
 
-import com.badlogic.gdx.Gdx
 import com.badlogic.gdx.graphics.Pixmap
 import net.torvald.terrarum.*
 import net.torvald.terrarum.App.printdbg
@@ -33,7 +32,7 @@ object WriteSavegame {
 
         Echo("Save queued")
 
-        IngameRenderer.fboRGBexportCallback = {
+        IngameRenderer.screencapExportCallback = {
             Echo("Generating thumbnail...")
 
             val w = 960
@@ -46,7 +45,7 @@ object WriteSavegame {
 
             Echo("Done thumbnail generation")
         }
-        IngameRenderer.fboRGBexportRequested = true
+        IngameRenderer.screencapRequested = true
 
         val savingThread = Thread(GameSavingThread(disk, outFile, ingame, true, isAuto, callback), "TerrarumBasegameGameSaveThread")
         savingThread.start()
@@ -73,7 +72,7 @@ object WriteSavegame {
 
         Echo("Quicksave queued")
 
-        IngameRenderer.fboRGBexportCallback = {
+        IngameRenderer.screencapExportCallback = {
             Echo("Generating thumbnail...")
 
             val w = 960
@@ -86,7 +85,7 @@ object WriteSavegame {
 
             Echo("Done thumbnail generation")
         }
-        IngameRenderer.fboRGBexportRequested = true
+        IngameRenderer.screencapRequested = true
 
         val savingThread = Thread(QuickSaveThread(disk, file, ingame, true, isAuto, callback), "TerrarumBasegameGameSaveThread")
         savingThread.start()

src/net/torvald/terrarum/weather/WeatherMixer.kt

@@ -177,12 +177,7 @@ internal object WeatherMixer : RNGConsumer {
         skyboxTexture.dispose()
         skyboxTexture = Texture(skyboxPixmap); skyboxTexture.setFilter(Texture.TextureFilter.Linear, Texture.TextureFilter.Linear)
 
-        if (App.getConfigBoolean("fx_dither")) {
+        IngameRenderer.batch.shader = if (App.getConfigBoolean("fx_dither")) IngameRenderer.shaderBayer else null
-            batch.shader = IngameRenderer.shaderBayer
-        }
-        else {
-            batch.shader = null
-        }
         batch.inUse {
             it.draw(skyboxTexture, 0f, -App.scr.halfhf, App.scr.wf, App.scr.hf * 2f) // because of how the linear filter works, we extend the image by two
         }