v0.4.23: fix wall z-fight and texture discard at distance

Reported: with render_distance_blocks=256, the panel started shimmering
and the wall texture bled through at ~30 blocks away. Both issues are
inherent distance-rendering bugs that were previously hidden by the
default ~64-block view distance.

Two fixes in VideoAnchorRenderer:
1. SURFACE_EPSILON 0.001 → 0.02. With 24-bit depth and near=0.05, the
   smallest resolvable depth step at 30 blocks is ~1mm, so the old 1mm
   offset was right at the z-fight boundary. 2cm gives ~20× margin at
   30 blocks and remains visually unnoticeable up close.
2. RenderType entityCutout → entitySolid. swscale outputs RGBA with
   alpha=255, so there is no real cutout. Cutout's alpha-discard step
   makes distant sampling unstable on a dynamic non-mipmapped texture;
   solid removes that and is the semantically correct type.

gradle.properties

@@ -5,7 +5,7 @@ org.gradle.configuration-cache=false
 
 # Mod
 mod_id=video_player
-mod_version=0.4.22
+mod_version=0.4.23
 maven_group=com.ejclaw.videoplayer
 archives_base_name=video_player
 

src/main/java/com/ejclaw/videoplayer/client/render/VideoAnchorRenderer.java

@@ -31,8 +31,19 @@ import org.joml.Matrix4f;
 @Environment(EnvType.CLIENT)
 public class VideoAnchorRenderer implements BlockEntityRenderer<VideoAnchorBlockEntity, VideoAnchorRenderer.State> {
 
-    /** Tiny outward offset so the quad doesn't z-fight with the wall. */
+    /**
-    private static final float SURFACE_EPSILON = 0.001F;
+     * Outward offset so the quad doesn't z-fight with the wall it sits on.
+     *
+     * <p>Depth-buffer precision drops with the square of view distance: with near=0.05 and
+     * 24-bit depth, the smallest resolvable step at 30 blocks is ~1mm, and ~12mm at 100
+     * blocks. The old 0.001 (1mm) offset was right at the precision boundary at ~30 blocks
+     * — which is exactly the distance users started seeing the wall texture flicker through
+     * the video panel once {@code render_distance_blocks} was raised past the default.
+     *
+     * <p>2cm gives ~20× margin at 30 blocks and is still visually unnoticeable up close
+     * (~3% of a block thickness).
+     */
+    private static final float SURFACE_EPSILON = 0.02F;
 
     public VideoAnchorRenderer(BlockEntityRendererProvider.Context ctx) {
         // no-op
@@ -75,7 +86,12 @@ public class VideoAnchorRenderer implements BlockEntityRenderer<VideoAnchorBlock
         pose.translate(-0.5F, -0.5F, -0.5F + SURFACE_EPSILON);
 
         final Matrix4f mat = new Matrix4f(pose.last().pose());
-        RenderType rt = RenderTypes.entityCutout(tex);
+        // entitySolid (not entityCutout): video frames come from swscale → AV_PIX_FMT_RGBA with
+        // alpha hard-set to 255, so there is no alpha-tested cutout. Cutout's alpha-discard step
+        // adds nothing here and makes distant sampling unstable — without mipmaps on a dynamic
+        // texture, neighbouring texels can shimmer above/below the discard threshold at sub-pixel
+        // sampling rates, contributing to the flicker users see once render distance is raised.
+        RenderType rt = RenderTypes.entitySolid(tex);
         collector.submitCustomGeometry(pose, rt, (poseUnused, vc) -> {
             // Single-sided: the back of the anchor is by design pressed against the wall the
             // player clicked, so a back face is pure GPU waste. Halves the fragment shader work