Fix Unaligned Sort Triggering

common/src/main/java/net/caffeinemc/mods/sodium/client/model/quad/properties/ModelQuadFacing.java

@@ -23,6 +23,7 @@ public enum ModelQuadFacing {
 
     public static final int COUNT = VALUES.length;
     public static final int DIRECTIONS = VALUES.length - 1;
+    public static final int UNASSIGNED_ORDINAL = ModelQuadFacing.UNASSIGNED.ordinal();
 
     public static final int NONE = 0;
     public static final int ALL = (1 << COUNT) - 1;

common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/TranslucentGeometryCollector.java

@@ -52,6 +52,7 @@ public class TranslucentGeometryCollector {
 
     // true if there are any unaligned quads
     private boolean hasUnaligned = false;
+    private int untrackedUnalignedNormalCount = 0;
 
     // a bitmap of the aligned facings present in the section
     private int alignedFacingBitmap = 0;
@@ -273,6 +274,8 @@ public void appendQuad(int packedNormal, ChunkVertexEncoder.Vertex[] vertices, M
             } else if (this.unalignedBNormal == -1) {
                 this.unalignedBNormal = packedNormal;
                 this.unalignedBDistance1 = distance;
+            } else {
+                this.untrackedUnalignedNormalCount++;
             }
         }
     }
@@ -356,7 +359,7 @@ private SortType sortTypeHeuristic() {
         int alignedNormalCount = Integer.bitCount(this.alignedFacingBitmap);
         int planeCount = getPlaneCount(alignedNormalCount);
 
-        int unalignedNormalCount = 0;
+        int unalignedNormalCount = this.untrackedUnalignedNormalCount;
         if (this.unalignedANormal != -1) {
             unalignedNormalCount++;
         }

common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/data/DynamicTopoData.java

@@ -1,6 +1,6 @@
 package net.caffeinemc.mods.sodium.client.render.chunk.translucent_sorting.data;
 
-import it.unimi.dsi.fastutil.objects.Object2ReferenceOpenHashMap;
+import it.unimi.dsi.fastutil.objects.Object2ReferenceMap;
 import net.caffeinemc.mods.sodium.client.render.chunk.translucent_sorting.TQuad;
 import net.caffeinemc.mods.sodium.client.render.chunk.translucent_sorting.trigger.GeometryPlanes;
 import net.caffeinemc.mods.sodium.client.util.sorting.RadixSort;
@@ -42,11 +42,11 @@ public class DynamicTopoData extends DynamicData {
     private boolean pendingTriggerIsDirect;
 
     private final TQuad[] quads;
-    private final Object2ReferenceOpenHashMap<Vector3fc, float[]> distancesByNormal;
+    private final Object2ReferenceMap<Vector3fc, float[]> distancesByNormal;
 
     private DynamicTopoData(SectionPos sectionPos, int vertexCount, TQuad[] quads,
                             GeometryPlanes geometryPlanes, Vector3dc initialCameraPos,
-                            Object2ReferenceOpenHashMap<Vector3fc, float[]> distancesByNormal) {
+                            Object2ReferenceMap<Vector3fc, float[]> distancesByNormal) {
         super(sectionPos, vertexCount, quads.length, geometryPlanes, initialCameraPos);
         this.quads = quads;
         this.distancesByNormal = distancesByNormal;

common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/data/TopoGraphSorting.java

@@ -1,9 +1,9 @@
 package net.caffeinemc.mods.sodium.client.render.chunk.translucent_sorting.data;
 
-import it.unimi.dsi.fastutil.objects.Object2ReferenceOpenHashMap;
+import it.unimi.dsi.fastutil.objects.Object2ReferenceMap;
 import net.caffeinemc.mods.sodium.client.model.quad.properties.ModelQuadFacing;
-import net.caffeinemc.mods.sodium.client.render.chunk.translucent_sorting.AlignableNormal;
 import net.caffeinemc.mods.sodium.client.render.chunk.translucent_sorting.TQuad;
+import net.caffeinemc.mods.sodium.client.render.chunk.translucent_sorting.trigger.NormalList;
 import net.caffeinemc.mods.sodium.client.util.collections.BitArray;
 import org.joml.Vector3fc;
 
@@ -92,17 +92,17 @@ public static boolean orthogonalQuadVisibleThrough(TQuad quadA, TQuad quadB) {
         return vis;
     }
 
-    private static boolean testSeparatorRange(Object2ReferenceOpenHashMap<Vector3fc, float[]> distancesByNormal,
+    private static boolean testSeparatorRange(Object2ReferenceMap<Vector3fc, float[]> distancesByNormal,
                                               Vector3fc normal, float start, float end) {
         var distances = distancesByNormal.get(normal);
         if (distances == null) {
             return false;
         }
-        return AlignableNormal.queryRange(distances, start, end);
+        return NormalList.queryRange(distances, start, end);
     }
 
     private static boolean visibilityWithSeparator(TQuad quadA, TQuad quadB,
-                                                   Object2ReferenceOpenHashMap<Vector3fc, float[]> distancesByNormal, Vector3fc cameraPos) {
+                                                   Object2ReferenceMap<Vector3fc, float[]> distancesByNormal, Vector3fc cameraPos) {
         // check if there is an aligned separator
         for (int direction = 0; direction < ModelQuadFacing.DIRECTIONS; direction++) {
             var facing = ModelQuadFacing.VALUES[direction];
@@ -163,7 +163,7 @@ private static boolean visibilityWithSeparator(TQuad quadA, TQuad quadB,
      * @return true if the other quad is visible through the first quad
      */
     private static boolean quadVisibleThrough(TQuad quad, TQuad other,
-                                              Object2ReferenceOpenHashMap<Vector3fc, float[]> distancesByNormal, Vector3fc cameraPos) {
+                                              Object2ReferenceMap<Vector3fc, float[]> distancesByNormal, Vector3fc cameraPos) {
         if (quad == other) {
             return false;
         }
@@ -250,7 +250,7 @@ private static boolean quadVisibleThrough(TQuad quad, TQuad other,
      */
     public static boolean topoGraphSort(
             IntConsumer indexConsumer, TQuad[] allQuads,
-            Object2ReferenceOpenHashMap<Vector3fc, float[]> distancesByNormal,
+            Object2ReferenceMap<Vector3fc, float[]> distancesByNormal,
             Vector3fc cameraPos) {
         // if enabled, check for visibility and produce a mapping of indices
         TQuad[] quads;
@@ -284,7 +284,7 @@ public static boolean topoGraphSort(
         return topoGraphSort(indexConsumer, quads, quadCount, activeToRealIndex, distancesByNormal, cameraPos);
     }
 
-    public static boolean topoGraphSort(IntConsumer indexConsumer, TQuad[] quads, int quadCount, int[] activeToRealIndex, Object2ReferenceOpenHashMap<Vector3fc, float[]> distancesByNormal, Vector3fc cameraPos) {
+    public static boolean topoGraphSort(IntConsumer indexConsumer, TQuad[] quads, int quadCount, int[] activeToRealIndex, Object2ReferenceMap<Vector3fc, float[]> distancesByNormal, Vector3fc cameraPos) {
         // special case for 0 to 2 quads
         if (quadCount == 0) {
             return true;

common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/trigger/GFNITriggers.java

@@ -1,12 +1,12 @@
 package net.caffeinemc.mods.sodium.client.render.chunk.translucent_sorting.trigger;
 
-import org.joml.Vector3fc;
-
+import it.unimi.dsi.fastutil.objects.Object2ReferenceMap;
 import it.unimi.dsi.fastutil.objects.Object2ReferenceOpenHashMap;
 import net.caffeinemc.mods.sodium.client.render.chunk.translucent_sorting.data.DynamicData;
 import net.caffeinemc.mods.sodium.client.render.chunk.translucent_sorting.data.TranslucentData;
 import net.caffeinemc.mods.sodium.client.render.chunk.translucent_sorting.trigger.SortTriggering.SectionTriggers;
 import net.minecraft.core.SectionPos;
+import org.joml.Vector3fc;
 
 /**
  * Performs triggering based on globally-indexed face planes, bucketed by their normals.
@@ -20,7 +20,7 @@ class GFNITriggers implements SectionTriggers<DynamicData> {
     /**
      * A map of all the normal lists, indexed by their normal.
      */
-    private Object2ReferenceOpenHashMap<Vector3fc, NormalList> normalLists = new Object2ReferenceOpenHashMap<>();
+    private final Object2ReferenceMap<Vector3fc, NormalList> normalLists = new Object2ReferenceOpenHashMap<>();
 
     int getUniqueNormalCount() {
         return this.normalLists.size();
@@ -33,11 +33,11 @@ public void processTriggers(SortTriggering ts, CameraMovement movement) {
         }
     }
 
-    private void addSectionInNewNormalLists(DynamicData dynamicData, NormalPlanes normalPlanes) {
+    private void addSectionInNewNormalLists(NormalPlanes normalPlanes) {
         var normal = normalPlanes.normal;
         var normalList = this.normalLists.get(normal);
         if (normalList == null) {
-            normalList = new NormalList(normal);
+            normalList = new NormalList(normal, normalPlanes.alignedDirection);
             this.normalLists.put(normal, normalList);
             normalList.addSection(normalPlanes, normalPlanes.sectionPos.asLong());
         }
@@ -94,14 +94,14 @@ public void integrateSection(SortTriggering ts, SectionPos pos, DynamicData data
         if (aligned != null) {
             for (var normalPlane : aligned) {
                 if (normalPlane != null) {
-                    this.addSectionInNewNormalLists(data, normalPlane);
+                    this.addSectionInNewNormalLists(normalPlane);
                 }
             }
         }
         var unaligned = geometryPlanes.getUnaligned();
         if (unaligned != null) {
             for (var normalPlane : unaligned) {
-                this.addSectionInNewNormalLists(data, normalPlane);
+                this.addSectionInNewNormalLists(normalPlane);
             }
         }
 

common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/trigger/GeometryPlanes.java

@@ -1,21 +1,23 @@
 package net.caffeinemc.mods.sodium.client.render.chunk.translucent_sorting.trigger;
 
-import java.util.Collection;
-
-import org.joml.Vector3fc;
-
+import it.unimi.dsi.fastutil.objects.Object2ReferenceMap;
 import it.unimi.dsi.fastutil.objects.Object2ReferenceOpenHashMap;
 import net.caffeinemc.mods.sodium.client.model.quad.properties.ModelQuadFacing;
 import net.caffeinemc.mods.sodium.client.render.chunk.translucent_sorting.TQuad;
 import net.minecraft.core.SectionPos;
+import org.joml.Vector3f;
+import org.joml.Vector3fc;
+
+import java.util.Collection;
 
 /**
  * GeometryPlanes stores the NormalPlanes for different normals, both aligned
  * and unaligned.
  */
 public class GeometryPlanes {
     private NormalPlanes[] alignedPlanes;
-    private Object2ReferenceOpenHashMap<Vector3fc, NormalPlanes> unalignedPlanes;
+    private Object2ReferenceMap<Vector3fc, NormalPlanes> unalignedPlanes;
+    private final Vector3f unalignedNormalScratch = new Vector3f();
 
     public NormalPlanes[] getAligned() {
         return this.alignedPlanes;
@@ -35,27 +37,20 @@ public Collection<NormalPlanes> getUnaligned() {
         return this.unalignedPlanes.values();
     }
 
-    public Object2ReferenceOpenHashMap<Vector3fc, NormalPlanes> getUnalignedOrCreate() {
+    public Object2ReferenceMap<Vector3fc, NormalPlanes> getUnalignedOrCreate() {
         if (this.unalignedPlanes == null) {
             this.unalignedPlanes = new Object2ReferenceOpenHashMap<>();
         }
         return this.unalignedPlanes;
     }
 
-    public Collection<Vector3fc> getUnalignedNormals() {
-        if (this.unalignedPlanes == null) {
-            return null;
-        }
-        return this.unalignedPlanes.keySet();
-    }
-
     NormalPlanes getPlanesForNormal(NormalList normalList) {
         var normal = normalList.getNormal();
-        if (normal.isAligned()) {
+        if (normalList.isAligned()) {
             if (this.alignedPlanes == null) {
                 return null;
             }
-            return this.alignedPlanes[normal.getAlignedDirection()];
+            return this.alignedPlanes[normalList.getAlignedDirection()];
         } else {
             if (this.unalignedPlanes == null) {
                 return null;
@@ -81,14 +76,37 @@ public void addDoubleSidedPlane(SectionPos sectionPos, int axis, float distance)
 
     public void addUnalignedPlane(SectionPos sectionPos, Vector3fc normal, float distance) {
         var unalignedDistances = this.getUnalignedOrCreate();
-        var normalPlanes = unalignedDistances.get(normal);
+
+        // create a copy of the vector where -0 is turned into +0,
+        // this avoids non-equality when comparing normals where just the sign on 0 is different
+        var cleanedNormal = this.cleanNormal(normal);
+
+        var normalPlanes = unalignedDistances.get(cleanedNormal);
         if (normalPlanes == null) {
-            normalPlanes = new NormalPlanes(sectionPos, normal);
-            unalignedDistances.put(normal, normalPlanes);
+            normalPlanes = new NormalPlanes(sectionPos, new Vector3f(normal));
+
+            // NOTE: importantly use the cleaned normal here, not the cleanedNormal, which is mutable
+            unalignedDistances.put(normalPlanes.normal, normalPlanes);
         }
         normalPlanes.addPlaneMember(distance);
     }
 
+    private Vector3f cleanNormal(Vector3fc normal) {
+        var cleanedNormal = this.unalignedNormalScratch.set(normal);
+
+        // convert any occurrences of 0 into +0, note that -0.0f == 0.0f
+        if (cleanedNormal.x == 0.0f) {
+            cleanedNormal.x = 0.0f;
+        }
+        if (cleanedNormal.y == 0.0f) {
+            cleanedNormal.y = 0.0f;
+        }
+        if (cleanedNormal.z == 0.0f) {
+            cleanedNormal.z = 0.0f;
+        }
+        return cleanedNormal;
+    }
+
     public void addQuadPlane(SectionPos sectionPos, TQuad quad) {
         var facing = quad.useQuantizedFacing();
         if (facing.isAligned()) {
@@ -98,7 +116,7 @@ public void addQuadPlane(SectionPos sectionPos, TQuad quad) {
         }
     }
 
-    private void prepareAndInsert(Object2ReferenceOpenHashMap<Vector3fc, float[]> distancesByNormal) {
+    private void prepareAndInsert(Object2ReferenceMap<Vector3fc, float[]> distancesByNormal) {
         if (this.alignedPlanes != null) {
             for (var normalPlanes : this.alignedPlanes) {
                 if (normalPlanes != null) {
@@ -117,7 +135,7 @@ public void prepareIntegration() {
         this.prepareAndInsert(null);
     }
 
-    public Object2ReferenceOpenHashMap<Vector3fc, float[]> prepareAndGetDistances() {
+    public Object2ReferenceMap<Vector3fc, float[]> prepareAndGetDistances() {
         var distancesByNormal = new Object2ReferenceOpenHashMap<Vector3fc, float[]>(10);
         this.prepareAndInsert(distancesByNormal);
         return distancesByNormal;