feat: Embeddium compat, fog, lightmap, and model texture fixes

- Fix environmental fog in NormalRenderPipeline — use RenderSystem fog state
  (fogStart/fogEnd/fogColor) matching Embeddium's ChunkShaderFogComponent approach;
  encode linear fog params into uniforms 4/5 instead of zeroing them
- Fix lightmap UV calculation in getLighting() — divide by 16.0 with 0.5/16
  pixel-center clamp to match Embeddium's lightmap sampling, fixing brightness excess
- Fix dark cutout mip detection — MipmapStrategy.DARK_CUTOUT absent in NeoForge
  vanilla; detect via RenderType.cutoutMipped() in ModelTextureBakery instead
- Add plan.md tracking Embeddium compat work
- Various rendering, mixin, config, and shader cleanups (ChunkBoundRenderer,
  RenderGenerationService, AsyncNodeManager, MDICSectionRenderer,
  MixinRenderSectionManager, MixinClientChunkCache, VoxyRenderSystem,
  AbstractRenderPipeline, ModelBakerySubsystem, ModelStore,
  EmbeddiumOptionsCompat, VoxyConfig, VoxyNeoForgeConfig,
  lang/en_us.json, shaders/chunkoutline/outline.vsh, shaders/lod/gl46/quads.frag)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: j-shelfwood

plan.md

@@ -0,0 +1,156 @@
+# Voxy LOD Boundary Fix Plan
+
+## Problem Statement
+
+6-chunk gaps appear at the LOD/vanilla boundary when moving or flying.
+The depth mask (ChunkBoundRenderer) does not cover the full area that MC
+considers "loaded", so LOD geometry bleeds through.
+
+---
+
+## Root Cause Analysis
+
+### The lifecycle chain
+
+```
+Server packet → ClientChunkCache.replaceWithPacketData()
+  → ClientLevel.onChunkLoaded()
+      → Embeddium ChunkTracker: FLAG_HAS_BLOCK_DATA set
+  → (async) applyLightData()
+      → Embeddium ChunkTracker: FLAG_HAS_LIGHT_DATA set
+          → 3×3 neighbour check: if centre + all 8 neighbours have FLAG_ALL
+              → next frame: RenderSectionManager.onChunkAdded() fires
+                  → our mixin hook fires → ChunkBoundRenderer.addSection()
+```
+
+### Finding 1 — renderDistance +3 mismatch (systematic, always present)
+
+`ClientChunkCache.inRange()` accepts chunks up to radius `max(2, renderDistance) + 3`
+from the player centre. MC loads **3 extra rings** of chunks beyond the render
+distance setting for lighting and neighbour purposes.
+
+Our `shouldRender()` in `outline.vsh` tests against `negInnerSec.w`, which is set
+to `getEffectiveRenderDistance() * 16` (bare render distance, no +3).
+
+Result: the 3 extra rings of chunks ARE added to ChunkBoundRenderer on load,
+but `shouldRender` clips their AABBs out — they produce no depth mask geometry.
+The depth mask ends 3 chunks (48 blocks) short of where MC actually has chunks.
+
+**This alone accounts for a 3-chunk systematic gap, regardless of movement.**
+
+### Finding 2 — 3×3 neighbour requirement (movement-dependent gap)
+
+Embeddium's `ChunkTracker.updateMerged()` requires all 8 neighbours to also have
+`FLAG_ALL` before `onChunkAdded` fires. When moving, the leading edge always has
+chunks loaded but without all neighbours yet → those chunks are not in
+ChunkBoundRenderer → gap at the leading edge.
+
+This is partially unavoidable, but is **amplified** by Finding 1.
+
+### Finding 3 — 1-block AABB expansion missing
+
+Upstream `outline.vsh` uses `icorner-1` / `icorner+17` (1-block outward expansion)
+when computing the closest AABB corner for the distance test. This gives a 1-block
+numerical tolerance for floating-point rounding in the camera position.
+
+Our version uses `icorner` / `icorner+16` (exact boundaries). Missing this
+contributes sub-chunk flickering at the exact boundary edge.
+
+### Finding 4 — circular vs square (minor, already partially fixed)
+
+Upstream uses circular distance (`x² + z² < r²`). MC chunk loading is square
+(Chebyshev: `max(|x|,|z|) <= r`). We already switched to Chebyshev in
+`shouldRender`, which is correct for matching MC's square pattern. No change
+needed here.
+
+---
+
+## Planned Fixes
+
+### Fix 1 — Correct `renderDistance` in `ChunkBoundRenderer.java`
+
+**File**: `src/main/java/me/cortex/voxy/client/core/rendering/ChunkBoundRenderer.java`
+
+Change:
+```java
+final float renderDistance = Minecraft.getInstance().options.getEffectiveRenderDistance() * 16;
+```
+To:
+```java
+// MC loads chunks at radius (renderDistance + 3) — see ClientChunkCache.calculateStorageRange().
+// The depth mask must cover this full radius, not just bare renderDistance, or a systematic
+// 3-chunk gap appears between the mask edge and where LODs start.
+final float renderDistance = (Minecraft.getInstance().options.getEffectiveRenderDistance() + 3) * 16.0f;
+```
+
+This is the single most impactful fix. It closes the 3-chunk systematic gap.
+
+### Fix 2 — Restore 1-block AABB expansion in `outline.vsh`
+
+**File**: `src/main/resources/assets/voxy/shaders/chunkoutline/outline.vsh`
+
+Match upstream's corner computation exactly:
+
+```glsl
+// Expand AABB by 1 block outward (matches upstream) for numerical robustness.
+// Prevents sub-chunk flicker from FP rounding of the camera position.
+vec3 corner = vec3(
+    mix(
+        mix(ivec3(0), icorner - 1, greaterThan(icorner - 1, ivec3(0))),
+        icorner + 17,
+        lessThan(icorner + 17, ivec3(0))
+    )
+) - negInnerSec.xyz;
+```
+
+### Fix 3 — Remove `boundaryBuffer` (now unnecessary)
+
+With Fix 1 applied, the systematic gap is closed. `boundaryBuffer` was a workaround
+for the gap; it is now harmful (causes water flickering) and should be removed.
+
+- **`ChunkBoundRenderer.java`**: remove `boundaryBuffer` from uniform upload
+- **`outline.vsh`**: remove `boundaryBuffer` from UBO and `shouldRender` logic
+- **`VoxyNeoForgeConfig.java`**: remove `LOD_BOUNDARY_BUFFER` config entry
+- **`VoxyConfig.java`**: remove `getLodBoundaryBuffer()` delegation
+
+### Fix 4 — Consider reverting to mesh-build tracking (optional / investigative)
+
+Our change to load-level tracking (Fix from previous session) ensures no holes for
+chunks loaded but not yet meshed. However, the 3×3 neighbour requirement means the
+mask boundary will always lag by ~1 chunk at the leading edge while moving.
+
+Whether to revert or keep load-level tracking should be evaluated after Fix 1 is
+applied and tested. If movement gaps persist, reverting to mesh-build tracking
+(which naturally respects the 3×3 neighbour boundary) may give a tighter
+visual match at the cost of some "see-through" on direction changes.
+
+---
+
+## Implementation Order
+
+1. Apply Fix 1 (`renderDistance + 3`) — highest impact, no side effects
+2. Apply Fix 2 (1-block AABB expansion) — correctness, matches upstream
+3. Apply Fix 3 (remove `boundaryBuffer`) — cleanup after Fix 1 makes it moot
+4. Build, deploy, test in Craftoria
+5. Evaluate Fix 4 based on test results
+
+---
+
+## Files to Change
+
+| File | Change |
+|------|--------|
+| `src/main/java/me/cortex/voxy/client/core/rendering/ChunkBoundRenderer.java` | `renderDistance` → `(rd + 3) * 16` |
+| `src/main/resources/assets/voxy/shaders/chunkoutline/outline.vsh` | 1-block expansion, remove boundaryBuffer |
+| `src/main/java/me/cortex/voxy/client/config/VoxyNeoForgeConfig.java` | Remove LOD_BOUNDARY_BUFFER |
+| `src/main/java/me/cortex/voxy/client/config/VoxyConfig.java` | Remove getLodBoundaryBuffer() |
+
+---
+
+## Key References
+
+- `ClientChunkCache.calculateStorageRange()`: `max(2, renderDistance) + 3`
+- `ClientChunkCache.Storage.inRange()`: `Math.abs(x - centerX) <= chunkRadius`
+- `ChunkTracker.updateMerged()`: 3×3 neighbourhood `FLAG_ALL` requirement
+- Upstream `outline.vsh`: `icorner-1` / `icorner+17` expansion, circular distance
+- `EmbeddiumWorldRenderer.processChunkEvents()`: drives `onChunkAdded`/`onChunkRemoved`

src/main/java/me/cortex/voxy/client/compat/EmbeddiumOptionsCompat.java

@@ -125,14 +125,6 @@ private static OptionPage buildPage() {
                         VoxyConfig::enableShaderPackFallbackPatch,
                         OptionImpact.LOW,
                         OptionFlag.REQUIRES_RENDERER_RELOAD))
-                .add(intSliderOption(
-                        "lod_boundary_buffer",
-                        "voxy.config.general.lod_boundary_buffer",
-                        "voxy.config.general.lod_boundary_buffer.tooltip",
-                        0, 4, 1, ControlValueFormatter.number(),
-                        (cfg, value) -> cfg.setLodBoundaryBuffer(value),
-                        VoxyConfig::getLodBoundaryBuffer,
-                        OptionImpact.LOW))
                 .add(intSliderOption(
                         "earth_curve_ratio",
                         "voxy.config.general.earth_curve_ratio",

src/main/java/me/cortex/voxy/client/config/VoxyConfig.java

@@ -60,10 +60,6 @@ public boolean dontUseEmbeddiumBuilderThreads() {
         return VoxyNeoForgeConfig.dontUseEmbeddiumBuilderThreads();
     }
 
-    public int getLodBoundaryBuffer() {
-        return VoxyNeoForgeConfig.getLodBoundaryBuffer();
-    }
-
     public int getEarthCurveRatio() {
         return VoxyNeoForgeConfig.getEarthCurveRatio();
     }
@@ -110,10 +106,6 @@ public void setDontUseEmbeddiumBuilderThreads(boolean value) {
         VoxyNeoForgeConfig.setDontUseEmbeddiumBuilderThreads(value);
     }
 
-    public void setLodBoundaryBuffer(int value) {
-        VoxyNeoForgeConfig.setLodBoundaryBuffer(value);
-    }
-
     public void setEarthCurveRatio(int value) {
         VoxyNeoForgeConfig.setEarthCurveRatio(value);
     }

src/main/java/me/cortex/voxy/client/config/VoxyNeoForgeConfig.java

@@ -72,15 +72,6 @@ public class VoxyNeoForgeConfig {
             .comment("Don't share threads with Embeddium's chunk builder")
             .define("dontUseEmbeddiumBuilderThreads", false);
 
-    // LOD boundary buffer (overdraw/overlap)
-    static final ModConfigSpec.IntValue LOD_BOUNDARY_BUFFER = BUILDER
-            .comment("LOD boundary overlap in chunks (each unit = 16 blocks of inward bleed)",
-                     "Shrinks the vanilla depth-mask by N chunks, letting LODs render inside",
-                     "the vanilla chunk boundary to hide the seam when flying.",
-                     "0 = exact match (may show seam/gap), 1 = 16 blocks overlap (recommended),",
-                     "2 = 32 blocks, 3 = 48 blocks, 4 = 64 blocks (most aggressive)")
-            .defineInRange("lodBoundaryBuffer", 1, 0, 4);
-
     // World curvature (experimental, LOD-only - vanilla chunks are not affected)
     static final ModConfigSpec.IntValue EARTH_CURVE_RATIO = BUILDER
             .comment("World curvature effect - simulates standing on a spherical planet (LOD terrain only)",
@@ -194,10 +185,6 @@ public static boolean dontUseEmbeddiumBuilderThreads() {
         return DONT_USE_EMBEDDIUM_BUILDER_THREADS.get();
     }
 
-    public static int getLodBoundaryBuffer() {
-        return LOD_BOUNDARY_BUFFER.get();
-    }
-
     public static boolean isRenderStatisticsEnabled() {
         return RENDER_STATISTICS.get();
     }
@@ -248,10 +235,6 @@ public static void setDontUseEmbeddiumBuilderThreads(boolean value) {
         DONT_USE_EMBEDDIUM_BUILDER_THREADS.set(value);
     }
 
-    public static void setLodBoundaryBuffer(int value) {
-        LOD_BOUNDARY_BUFFER.set(value);
-    }
-
     public static void setEarthCurveRatio(int value) {
         EARTH_CURVE_RATIO.set(value);
     }

src/main/java/me/cortex/voxy/client/core/AbstractRenderPipeline.java

@@ -203,20 +203,26 @@ private static int getDepthAttachmentTextureId(int framebuffer) {
 
     private static final long SCRATCH = MemoryUtil.nmemAlloc(4*4*4);
     protected static void transformBlitDepth(FullscreenBlit blitShader, int srcDepthTex, int dstFB, Viewport<?> viewport, Matrix4f targetTransform) {
-        // at this point the dst frame buffer doesn't have a stencil attachment so we don't need to keep the stencil test on for the blit
-        // in the worst case the dstFB does have a stencil attachment causing this pass to become 'corrupted'
         glDisable(GL_STENCIL_TEST);
         glBindFramebuffer(GL30.GL_FRAMEBUFFER, dstFB);
 
         blitShader.bind();
         glBindTextureUnit(0, srcDepthTex);
         new Matrix4f(viewport.MVP).invert().getToAddress(SCRATCH);
         nglUniformMatrix4fv(1, 1, false, SCRATCH);//inverse fromProjection
-        targetTransform.getToAddress(SCRATCH);//new Matrix4f(tooProjection).mul(vp.modelView).get(data);
+        targetTransform.getToAddress(SCRATCH);
         nglUniformMatrix4fv(2, 1, false, SCRATCH);//tooProjection
 
+        // Use GL_LESS so Voxy's reprojected depth only wins where it is strictly closer than
+        // whatever MC already wrote. At the water/LOD boundary MC's water depth is already in
+        // the depth buffer; the double-projection (MC→Voxy→MC) introduces sub-ULP error that
+        // can make Voxy's value marginally smaller under GL_LEQUAL, overwriting MC's depth by
+        // epsilon. TAA then sees the depth flicker every frame at that boundary, producing the
+        // flickering-behind-water artefact at chunk borders. GL_LESS prevents the overwrite.
         glEnable(GL_DEPTH_TEST);
+        glDepthFunc(GL_LESS);
         blitShader.blit();
+        glDepthFunc(GL_LEQUAL);
         glDisable(GL_STENCIL_TEST);
         glDisable(GL_DEPTH_TEST);
     }

src/main/java/me/cortex/voxy/client/core/NormalRenderPipeline.java

@@ -11,6 +11,7 @@
 import me.cortex.voxy.client.core.rendering.hierachical.NodeCleaner;
 import me.cortex.voxy.client.core.rendering.post.FullscreenBlit;
 import me.cortex.voxy.client.core.rendering.util.DepthFramebuffer;
+import com.mojang.blaze3d.systems.RenderSystem;
 import net.minecraft.client.Minecraft;
 import org.joml.Matrix4f;
 import org.lwjgl.system.MemoryStack;
@@ -109,14 +110,19 @@ protected boolean shouldRenderTemporal(Viewport<?> viewport) {
     @Override
     protected void finish(Viewport<?> viewport, int sourceFrameBuffer, int srcWidth, int srcHeight) {
         this.finalBlit.bind();
-        // MC 1.21.1 / Embeddium 1.0.x: Environmental fog disabled
-        // FogParameters.environmental*() methods don't exist in Embeddium 1.0.x
-        // RenderSystem.getShaderFog*() returns standard fog (underwater/lava) not environmental fog
-        // TODO: Research Embeddium environmental fog API or implement custom distance-based fog
         if (this.useEnvFog) {
-            // Disable fog uniforms - set to zero (no fog effect)
-            glUniform4f(4, 0, 0, 0, 0);
-            glUniform4f(5, 0, 0, 0, 0);
+            // MC 1.21.1: Use RenderSystem fog state which is set by BackgroundRenderer before chunk rendering.
+            // This matches what Embeddium passes to its chunk shader (ChunkShaderFogComponent uses same API).
+            float fogStart = RenderSystem.getShaderFogStart();
+            float fogEnd   = RenderSystem.getShaderFogEnd();
+            float[] fogColor = RenderSystem.getShaderFogColor();
+            // Encode linear fog as: fogLerp = clamp(dist * x + y, 0, z)
+            // → x = 1/(end-start), y = -start/(end-start), z = 1
+            float invRange = (fogEnd > fogStart) ? 1.0f / (fogEnd - fogStart) : 0.0f;
+            glUniform4f(4, invRange, -fogStart * invRange, 1.0f, 0.0f);
+            // fogColour.a used as blend gate: 1.0 = fog active, 0.0 = no fog
+            float fogAlpha = (invRange > 0.0f) ? fogColor[3] : 0.0f;
+            glUniform4f(5, fogColor[0], fogColor[1], fogColor[2], fogAlpha);
         }
 
         glBindTextureUnit(3, this.colourSSAOTex.id);

src/main/java/me/cortex/voxy/client/core/VoxyRenderSystem.java

@@ -153,7 +153,7 @@ public VoxyRenderSystem(WorldEngine world, ServiceManager sm) {
                     maxSec = 7;
                 }
 
-                this.renderDistanceTracker = new RenderDistanceTracker(20,
+                this.renderDistanceTracker = new RenderDistanceTracker(200,
                         minSec,
                         maxSec,
                         this.nodeManager::addTopLevel,
@@ -201,8 +201,14 @@ public Viewport<?> setupViewport(Matrix4fc projection, Matrix4fc modelView, doub
         //var projection = ShadowMatrices.createOrthoMatrix(160, -16*300, 16*300);
         //var projection = new Matrix4f(matrices.projection());
 
+        // Query GL state once here; results are cached so renderOpaque() can skip the GL round-trips.
         int[] dims = new int[4];
         glGetIntegerv(GL_VIEWPORT, dims);
+        this.cachedFramebufferId = GL11.glGetInteger(GL_DRAW_FRAMEBUFFER_BINDING);
+        this.cachedViewportX = dims[0];
+        this.cachedViewportY = dims[1];
+        this.cachedViewportW = dims[2];
+        this.cachedViewportH = dims[3];
 
         int width = dims[2];
         int height = dims[3];
@@ -352,6 +358,10 @@ public void renderShadow(Viewport<?> viewport) {
         }
     }
 
+    // Cached GL state from setupViewport() so renderOpaque() avoids synchronous GL queries.
+    private int cachedFramebufferId = 0;
+    private int cachedViewportX = 0, cachedViewportY = 0, cachedViewportW = 0, cachedViewportH = 0;
+
     private boolean renderOpaqueFirstCall = true;
     private int setupViewportWarnCount = 0;
 
@@ -375,12 +385,9 @@ public void renderOpaque(Viewport<?> viewport) {
 
         if (renderOpaqueFirstCall) {
             renderOpaqueFirstCall = false;
-            int[] dbgDims = new int[4];
-            glGetIntegerv(GL_VIEWPORT, dbgDims);
-            int dbgFB = GL11.glGetInteger(GL_DRAW_FRAMEBUFFER_BINDING);
             Logger.info("[DIAG] renderOpaque first call: viewport=" + viewport.width + "x" + viewport.height
-                    + " GL_VIEWPORT=" + dbgDims[2] + "x" + dbgDims[3]
-                    + " boundFB=" + dbgFB
+                    + " GL_VIEWPORT=" + this.cachedViewportW + "x" + this.cachedViewportH
+                    + " boundFB=" + this.cachedFramebufferId
                     + " shadowActive=" + IrisCompatManager.isShadowActive()
                     + " pipeline=" + this.pipeline.getClass().getSimpleName());
         }
@@ -403,12 +410,11 @@ public void renderOpaque(Viewport<?> viewport) {
         // Was: int[] oldBufferBindings = new int[10]; glGetIntegeri(...) × 10 per frame.
 
 
-        int oldFB = GL11.glGetInteger(GL_DRAW_FRAMEBUFFER_BINDING);
+        // Use cached GL state from setupViewport() — avoids two synchronous GPU→CPU round-trips per frame.
+        // cachedFramebufferId / cachedViewport* are populated in setupViewport() which is called just before.
+        int oldFB = this.cachedFramebufferId;
         int boundFB = oldFB;
 
-        int[] dims = new int[4];
-        glGetIntegerv(GL_VIEWPORT, dims);
-
         glViewport(0,0, viewport.width, viewport.height);
 
         //var target = DefaultTerrainRenderPasses.CUTOUT.getTarget();
@@ -432,7 +438,7 @@ public void renderOpaque(Viewport<?> viewport) {
 
         GPUTiming.INSTANCE.marker();
         //The entire rendering pipeline (excluding the chunkbound thing)
-        this.pipeline.runPipeline(viewport, boundFB, dims[2], dims[3]);
+        this.pipeline.runPipeline(viewport, boundFB, this.cachedViewportW, this.cachedViewportH);
         GPUTiming.INSTANCE.marker();
 
         TimingStatistics.main.stop();
@@ -461,7 +467,7 @@ public void renderOpaque(Viewport<?> viewport) {
         GPUTiming.INSTANCE.tick();
 
         glBindFramebuffer(GlConst.GL_FRAMEBUFFER, oldFB);
-        glViewport(dims[0], dims[1], dims[2], dims[3]);
+        glViewport(this.cachedViewportX, this.cachedViewportY, this.cachedViewportW, this.cachedViewportH);
 
         {//Reset state manager stuffs
             glUseProgram(0);