feat: Add world curvature effect (DH-inspired)

Implements spherical world curvature for LOD terrain, simulating
standing on a planetary surface. Distant terrain curves downward
based on configurable curvature ratio.

- Add earthCurveRatio config (0=disabled, 50-500 valid range)
- Add uEarthRadius uniform to shader SceneUniform
- Implement applyWorldCurvature() in quad_util.glsl
- Add "World Curvature" slider to Sodium Video Settings
- Sync config between NeoForge config system and VoxyConfig

Math based on Distant Horizons' curve.vert implementation.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: j-shelfwood

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

@@ -37,6 +37,14 @@ public class VoxyConfig {
     // Range: 0-4 blocks, default 1 (original Voxy behavior)
     public int lodBoundaryBuffer = 1;
 
+    // World curvature: simulates standing on a spherical planet
+    // 0 = disabled (flat world)
+    // 1 = real Earth curvature (6371km radius)
+    // Higher values = more extreme curvature (smaller planet effect)
+    // Range: 0, or 50-5000 (values 1-49 are invalid and auto-corrected to 50)
+    // Inspired by Distant Horizons' earth curvature feature
+    public int earthCurveRatio = 0;
+
     private static VoxyConfig loadOrCreate() {
         if (VoxyCommon.isAvailable()) {
             var path = getConfigPath();

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

@@ -67,6 +67,16 @@ public class VoxyNeoForgeConfig {
                      "0 = exact match (may have gaps), 1 = minimal overlap, 2-4 = smoother for fast flight")
             .defineInRange("lodBoundaryBuffer", 1, 0, 4);
 
+    // World curvature (experimental)
+    private static final ModConfigSpec.IntValue EARTH_CURVE_RATIO = BUILDER
+            .comment("World curvature effect - simulates standing on a spherical planet",
+                     "0 = disabled (flat world)",
+                     "1 = real Earth curvature (6371km radius)",
+                     "Higher values = more extreme curvature (smaller planet effect)",
+                     "Valid range: 0 (off), or 50-5000. Values 1-49 are auto-corrected to 50.",
+                     "Inspired by Distant Horizons' earth curvature feature")
+            .defineInRange("earthCurveRatio", 0, 0, 5000);
+
     // Debug settings
     private static final ModConfigSpec.BooleanValue RENDER_STATISTICS = BUILDER
             .comment("Show render statistics in F3 debug screen",
@@ -96,6 +106,7 @@ private static void syncToVoxyConfig() {
         VoxyConfig.CONFIG.useEnvironmentalFog = USE_ENVIRONMENTAL_FOG.get();
         VoxyConfig.CONFIG.dontUseSodiumBuilderThreads = DONT_USE_SODIUM_BUILDER_THREADS.get();
         VoxyConfig.CONFIG.lodBoundaryBuffer = LOD_BOUNDARY_BUFFER.get();
+        VoxyConfig.CONFIG.earthCurveRatio = EARTH_CURVE_RATIO.get();
 
         // RenderStatistics is a runtime-only setting (not saved to JSON)
         RenderStatistics.enabled = RENDER_STATISTICS.get();
@@ -158,4 +169,8 @@ public static int getLodBoundaryBuffer() {
     public static boolean isRenderStatisticsEnabled() {
         return RENDER_STATISTICS.get();
     }
+
+    public static int getEarthCurveRatio() {
+        return EARTH_CURVE_RATIO.get();
+    }
 }

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

@@ -150,6 +150,18 @@ private static OptionGroup createAdvancedGroup(VoxyConfigStorage storage) {
                                 config -> RenderStatistics.enabled
                         )
                         .build())
+                .add(OptionImpl.createBuilder(int.class, storage)
+                        .setName(Component.translatable("voxy.sodium.option.earth_curve_ratio"))
+                        .setTooltip(Component.translatable("voxy.sodium.option.earth_curve_ratio.tooltip"))
+                        .setControl(opt -> new SliderControl(opt, 0, 500, 10,
+                                v -> v == 0 ? Component.literal("Disabled") :
+                                     v < 50 ? Component.literal("→ 50 (min)") :
+                                     Component.literal(v + "x")))
+                        .setBinding(
+                                (config, value) -> config.earthCurveRatio = value < 50 && value > 0 ? 50 : value,
+                                config -> config.earthCurveRatio
+                        )
+                        .build())
                 .build();
     }
 

src/main/java/me/cortex/voxy/client/core/rendering/section/backend/mdic/MDICSectionRenderer.java

@@ -17,6 +17,7 @@
 import me.cortex.voxy.client.core.rendering.util.LightMapHelper;
 import me.cortex.voxy.client.core.rendering.util.SharedIndexBuffer;
 import me.cortex.voxy.client.core.rendering.util.UploadStream;
+import me.cortex.voxy.client.config.VoxyConfig;
 import me.cortex.voxy.common.Logger;
 import me.cortex.voxy.common.world.WorldEngine;
 import net.minecraft.client.Minecraft;
@@ -146,6 +147,16 @@ private void uploadUniformBuffer(MDICViewport viewport) {
         MemoryUtil.memPutInt(ptr, viewport.frameId&0x7fffffff); ptr += 4;
         viewport.innerTranslation.getToAddress(ptr); ptr += 4*3;
 
+        // Earth curvature radius: 0 = disabled, otherwise compute radius in blocks
+        // DH uses: radius = 6371000.0 / ratio (Earth radius in meters / ratio factor)
+        // We use blocks (1 block = 1 meter), so same formula
+        int earthCurveRatio = VoxyConfig.CONFIG.earthCurveRatio;
+        float earthRadius = 0.0f;
+        if (earthCurveRatio >= 50) {
+            earthRadius = 6371000.0f / earthCurveRatio;
+        }
+        MemoryUtil.memPutFloat(ptr, earthRadius); ptr += 4;
+
         UploadStream.INSTANCE.commit();
     }
 

src/main/resources/assets/voxy/lang/en_us.json

@@ -64,5 +64,8 @@
   "voxy.sodium.option.lod_boundary_buffer.tooltip": "Controls overlap between vanilla chunks and LODs. Higher = smoother transitions when flying fast, but slight overdraw.",
 
   "voxy.sodium.option.render_statistics": "Debug Statistics",
-  "voxy.sodium.option.render_statistics.tooltip": "Show LOD render statistics in the F3 debug screen"
+  "voxy.sodium.option.render_statistics.tooltip": "Show LOD render statistics in the F3 debug screen",
+
+  "voxy.sodium.option.earth_curve_ratio": "World Curvature",
+  "voxy.sodium.option.earth_curve_ratio.tooltip": "Simulates standing on a spherical planet. 0 = flat world. Higher values = smaller planet effect (more curvature). Inspired by Distant Horizons."
 }

src/main/resources/assets/voxy/shaders/lod/gl46/bindings.glsl

@@ -3,6 +3,7 @@ layout(binding = 0, std140) uniform SceneUniform {
     ivec3 baseSectionPos;
     uint frameId;
     vec3 cameraSubPos;
+    float uEarthRadius; // 0.0 = disabled, otherwise radius in blocks for world curvature
 };
 
 //TODO: see if making the stride 2*4*4 bytes or something cause you get that 16 byte write

src/main/resources/assets/voxy/shaders/lod/quad_util.glsl

@@ -162,9 +162,39 @@ void setupQuad(out QuadData quad, const in Quad rawQuad, uvec2 sPos, bool genera
     quad.uvCorner = faceSize.xz;
 }
 
+// Apply spherical world curvature effect (inspired by Distant Horizons)
+// Makes distant terrain curve downward as if standing on a spherical planet
+vec3 applyWorldCurvature(vec3 worldPos) {
+    if (uEarthRadius <= 0.0) {
+        return worldPos;
+    }
+
+    // Calculate local radius at vertex height
+    float localRadius = uEarthRadius + worldPos.y;
+
+    // Calculate the arc angle based on horizontal distance
+    float horizontalDist = length(worldPos.xz);
+    float phi = horizontalDist / localRadius;
+
+    // Apply spherical projection
+    // Y displacement: terrain curves down at distance
+    worldPos.y += (cos(phi) - 1.0) * localRadius;
+
+    // XZ scaling: slight convergence at extreme distances (prevents horizon stretching)
+    if (phi > 0.0001) {
+        worldPos.xz = worldPos.xz * sin(phi) / phi;
+    }
+
+    return worldPos;
+}
+
 vec4 getQuadCornerPos(in QuadData quad, uint cornerId) {
     vec2 cornerMask = vec2((cornerId>>1)&1u, cornerId&1u)*quad.lodScale;
     vec3 point = quad.basePoint + swizzelDataAxis(quad.axis,vec3(quad.quadSizeAddin*cornerMask,0));
+
+    // Apply world curvature before MVP transformation
+    point = applyWorldCurvature(point);
+
     vec4 pos = MVP * vec4(point, 1.0f);
     pos.xy += taaOffset*pos.w;
     return pos;