From 65068c552b513df441149fdc294304d3204d1f34 Mon Sep 17 00:00:00 2001 From: douira Date: Sat, 26 Oct 2024 04:03:20 +0200 Subject: [PATCH] Fix sorting failures on rotated cuboids (#2812) Use the accurate vertex positions for unaligned and aligned (but rotated) quads. --- .../chunk/translucent_sorting/TQuad.java | 74 +++++++++++--- .../TranslucentGeometryCollector.java | 45 +++++++-- .../translucent_sorting/bsp_tree/BSPNode.java | 2 +- .../bsp_tree/InnerPartitionBSPNode.java | 4 +- .../data/DynamicTopoData.java | 1 - .../data/StaticNormalRelativeData.java | 9 +- .../data/TopoGraphSorting.java | 99 ++++++++++++++----- .../trigger/GeometryPlanes.java | 4 +- 8 files changed, 182 insertions(+), 56 deletions(-) diff --git a/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/TQuad.java b/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/TQuad.java index bdf230a6ac..8d0ae60c73 100644 --- a/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/TQuad.java +++ b/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/TQuad.java @@ -25,37 +25,42 @@ public class TQuad { private ModelQuadFacing facing; private final float[] extents; + private float[] vertexPositions; private final int packedNormal; - private float dotProduct; + private final float accurateDotProduct; + private float quantizedDotProduct; private Vector3fc center; // null on aligned quads private Vector3fc quantizedNormal; + private Vector3fc accurateNormal; - private TQuad(ModelQuadFacing facing, float[] extents, Vector3fc center, int packedNormal) { + private TQuad(ModelQuadFacing facing, float[] extents, float[] vertexPositions, Vector3fc center, int packedNormal) { this.facing = facing; this.extents = extents; + this.vertexPositions = vertexPositions; this.center = center; this.packedNormal = packedNormal; if (this.facing.isAligned()) { - this.dotProduct = getAlignedDotProduct(this.facing, this.extents); + this.accurateDotProduct = getAlignedDotProduct(this.facing, this.extents); } else { float normX = NormI8.unpackX(this.packedNormal); float normY = NormI8.unpackY(this.packedNormal); float normZ = NormI8.unpackZ(this.packedNormal); - this.dotProduct = this.getCenter().dot(normX, normY, normZ); + this.accurateDotProduct = this.getCenter().dot(normX, normY, normZ); } + this.quantizedDotProduct = this.accurateDotProduct; } private static float getAlignedDotProduct(ModelQuadFacing facing, float[] extents) { return extents[facing.ordinal()] * facing.getSign(); } - static TQuad fromAligned(ModelQuadFacing facing, float[] extents, Vector3fc center) { - return new TQuad(facing, extents, center, ModelQuadFacing.PACKED_ALIGNED_NORMALS[facing.ordinal()]); + static TQuad fromAligned(ModelQuadFacing facing, float[] extents, float[] vertexPositions, Vector3fc center) { + return new TQuad(facing, extents, vertexPositions, center, ModelQuadFacing.PACKED_ALIGNED_NORMALS[facing.ordinal()]); } - static TQuad fromUnaligned(ModelQuadFacing facing, float[] extents, Vector3fc center, int packedNormal) { - return new TQuad(facing, extents, center, packedNormal); + static TQuad fromUnaligned(ModelQuadFacing facing, float[] extents, float[] vertexPositions, Vector3fc center, int packedNormal) { + return new TQuad(facing, extents, vertexPositions, center, packedNormal); } public ModelQuadFacing getFacing() { @@ -73,9 +78,9 @@ public ModelQuadFacing useQuantizedFacing() { this.getQuantizedNormal(); this.facing = ModelQuadFacing.fromNormal(this.quantizedNormal.x(), this.quantizedNormal.y(), this.quantizedNormal.z()); if (this.facing.isAligned()) { - this.dotProduct = getAlignedDotProduct(this.facing, this.extents); + this.quantizedDotProduct = getAlignedDotProduct(this.facing, this.extents); } else { - this.dotProduct = this.getCenter().dot(this.quantizedNormal); + this.quantizedDotProduct = this.getCenter().dot(this.quantizedNormal); } } @@ -86,6 +91,31 @@ public float[] getExtents() { return this.extents; } + public float[] getVertexPositions() { + // calculate vertex positions from extents if there's no cached value + // (we don't want to be preemptively collecting vertex positions for all aligned quads) + if (this.vertexPositions == null) { + this.vertexPositions = new float[12]; + + var facingAxis = this.facing.getAxis(); + var xRange = facingAxis == 0 ? 0 : 3; + var yRange = facingAxis == 1 ? 0 : 3; + var zRange = facingAxis == 2 ? 0 : 3; + + var itemIndex = 0; + for (int x = 0; x <= xRange; x += 3) { + for (int y = 0; y <= yRange; y += 3) { + for (int z = 0; z <= zRange; z += 3) { + this.vertexPositions[itemIndex++] = this.extents[x]; + this.vertexPositions[itemIndex++] = this.extents[y + 1]; + this.vertexPositions[itemIndex++] = this.extents[z + 2]; + } + } + } + } + return this.vertexPositions; + } + public Vector3fc getCenter() { // calculate aligned quad center on demand if (this.center == null) { @@ -97,8 +127,12 @@ public Vector3fc getCenter() { return this.center; } - public float getDotProduct() { - return this.dotProduct; + public float getAccurateDotProduct() { + return this.accurateDotProduct; + } + + public float getQuantizedDotProduct() { + return this.quantizedDotProduct; } public int getPackedNormal() { @@ -116,6 +150,20 @@ public Vector3fc getQuantizedNormal() { return this.quantizedNormal; } + public Vector3fc getAccurateNormal() { + if (this.facing.isAligned()) { + return this.facing.getAlignedNormal(); + } else { + if (this.accurateNormal == null) { + this.accurateNormal = new Vector3f( + NormI8.unpackX(this.packedNormal), + NormI8.unpackY(this.packedNormal), + NormI8.unpackZ(this.packedNormal)); + } + return this.accurateNormal; + } + } + private void computeQuantizedNormal() { float normX = NormI8.unpackX(this.packedNormal); float normY = NormI8.unpackY(this.packedNormal); @@ -150,7 +198,7 @@ int getQuadHash() { } else { result = 31 * result + this.packedNormal; } - result = 31 * result + Float.hashCode(this.dotProduct); + result = 31 * result + Float.hashCode(this.quantizedDotProduct); return result; } diff --git a/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/TranslucentGeometryCollector.java b/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/TranslucentGeometryCollector.java index 6edd1314e7..2125b23b45 100644 --- a/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/TranslucentGeometryCollector.java +++ b/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/TranslucentGeometryCollector.java @@ -116,7 +116,7 @@ public void appendQuad(int packedNormal, ChunkVertexEncoder.Vertex[] vertices, M float lastX = vertices[3].x; float lastY = vertices[3].y; float lastZ = vertices[3].z; - int uniqueQuads = 0; + int uniqueVertexes = 0; float posXExtent = Float.NEGATIVE_INFINITY; float posYExtent = Float.NEGATIVE_INFINITY; @@ -141,7 +141,7 @@ public void appendQuad(int packedNormal, ChunkVertexEncoder.Vertex[] vertices, M xSum += x; ySum += y; zSum += z; - uniqueQuads++; + uniqueVertexes++; } if (i != 3) { lastX = x; @@ -185,13 +185,38 @@ public void appendQuad(int packedNormal, ChunkVertexEncoder.Vertex[] vertices, M } Vector3fc center = null; - if (!facing.isAligned() || uniqueQuads != 4) { - var centerX = xSum / uniqueQuads; - var centerY = ySum / uniqueQuads; - var centerZ = zSum / uniqueQuads; + if (!facing.isAligned() || uniqueVertexes != 4) { + var centerX = xSum / uniqueVertexes; + var centerY = ySum / uniqueVertexes; + var centerZ = zSum / uniqueVertexes; center = new Vector3f(centerX, centerY, centerZ); } + // check if we need to store vertex positions for this quad, only necessary if it's unaligned or rotated (yet aligned) + var needsVertexPositions = uniqueVertexes != 4 || !facing.isAligned(); + if (!needsVertexPositions) { + for (int i = 0; i < 4; i++) { + var vertex = vertices[i]; + if (vertex.x != posYExtent && vertex.x != negYExtent || + vertex.y != posZExtent && vertex.y != negZExtent || + vertex.z != posXExtent && vertex.z != negXExtent) { + needsVertexPositions = true; + break; + } + } + } + + float[] vertexPositions = null; + if (needsVertexPositions) { + vertexPositions = new float[12]; + for (int i = 0, itemIndex = 0; i < 4; i++) { + var vertex = vertices[i]; + vertexPositions[itemIndex++] = vertex.x; + vertexPositions[itemIndex++] = vertex.y; + vertexPositions[itemIndex++] = vertex.z; + } + } + if (facing.isAligned()) { // only update global extents if there are no unaligned quads since this is only // used for the convex box test which doesn't work with unaligned quads anyway @@ -204,11 +229,11 @@ public void appendQuad(int packedNormal, ChunkVertexEncoder.Vertex[] vertices, M this.extents[5] = Math.min(this.extents[5], negZExtent); } - var quad = TQuad.fromAligned(facing, extents, center); + var quad = TQuad.fromAligned(facing, extents, vertexPositions, center); quadList.add(quad); var extreme = this.alignedExtremes[direction]; - var distance = quad.getDotProduct(); + var distance = quad.getAccurateDotProduct(); // check if this is a new dot product for this distance var existingExtreme = this.alignedExtremes[direction]; @@ -225,11 +250,11 @@ public void appendQuad(int packedNormal, ChunkVertexEncoder.Vertex[] vertices, M } else { this.hasUnaligned = true; - var quad = TQuad.fromUnaligned(facing, extents, center, packedNormal); + var quad = TQuad.fromUnaligned(facing, extents, vertexPositions, center, packedNormal); quadList.add(quad); // update the two unaligned normals that are tracked - var distance = quad.getDotProduct(); + var distance = quad.getAccurateDotProduct(); if (packedNormal == this.unalignedANormal) { if (Float.isNaN(this.unalignedADistance1)) { this.unalignedADistance1 = distance; diff --git a/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/bsp_tree/BSPNode.java b/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/bsp_tree/BSPNode.java index 20a48780d1..6362cbc07f 100644 --- a/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/bsp_tree/BSPNode.java +++ b/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/bsp_tree/BSPNode.java @@ -65,7 +65,7 @@ private static boolean doubleLeafPossible(TQuad quadA, TQuad quadB) { // opposite normal (distance irrelevant) if (NormI8.isOpposite(packedNormalA, packedNormalB) // same normal and same distance - || packedNormalA == packedNormalB && quadA.getDotProduct() == quadB.getDotProduct()) { + || packedNormalA == packedNormalB && quadA.getAccurateDotProduct() == quadB.getAccurateDotProduct()) { return true; } } diff --git a/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/bsp_tree/InnerPartitionBSPNode.java b/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/bsp_tree/InnerPartitionBSPNode.java index f56c9a501d..3ee6572093 100644 --- a/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/bsp_tree/InnerPartitionBSPNode.java +++ b/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/bsp_tree/InnerPartitionBSPNode.java @@ -540,7 +540,7 @@ static private BSPNode buildSNRLeafNodeFromQuads(BSPWorkspace workspace, IntArra for (int i = 0; i < indexes.size(); i++) { var quadIndex = indexes.getInt(i); - keys[i] = MathUtil.floatToComparableInt(workspace.quads[quadIndex].getDotProduct()); + keys[i] = MathUtil.floatToComparableInt(workspace.quads[quadIndex].getAccurateDotProduct()); } quadIndexes = RadixSort.sort(keys); @@ -553,7 +553,7 @@ static private BSPNode buildSNRLeafNodeFromQuads(BSPWorkspace workspace, IntArra for (int i = 0; i < indexes.size(); i++) { var quadIndex = indexes.getInt(i); - int dotProductComponent = MathUtil.floatToComparableInt(workspace.quads[quadIndex].getDotProduct()); + int dotProductComponent = MathUtil.floatToComparableInt(workspace.quads[quadIndex].getAccurateDotProduct()); sortData[i] = (long) dotProductComponent << 32 | quadIndex; } diff --git a/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/data/DynamicTopoData.java b/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/data/DynamicTopoData.java index 7b5fc1e491..200ec74a93 100644 --- a/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/data/DynamicTopoData.java +++ b/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/data/DynamicTopoData.java @@ -1,7 +1,6 @@ package net.caffeinemc.mods.sodium.client.render.chunk.translucent_sorting.data; import it.unimi.dsi.fastutil.objects.Object2ReferenceOpenHashMap; -import net.caffeinemc.mods.sodium.client.render.chunk.data.BuiltSectionMeshParts; 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; diff --git a/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/data/StaticNormalRelativeData.java b/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/data/StaticNormalRelativeData.java index e0f253697f..888ccd2034 100644 --- a/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/data/StaticNormalRelativeData.java +++ b/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/data/StaticNormalRelativeData.java @@ -1,6 +1,5 @@ package net.caffeinemc.mods.sodium.client.render.chunk.translucent_sorting.data; -import net.caffeinemc.mods.sodium.client.render.chunk.data.BuiltSectionMeshParts; import net.caffeinemc.mods.sodium.client.render.chunk.translucent_sorting.SortType; import net.caffeinemc.mods.sodium.client.render.chunk.translucent_sorting.TQuad; import net.caffeinemc.mods.sodium.client.util.MathUtil; @@ -50,7 +49,7 @@ private static StaticNormalRelativeData fromDoubleUnaligned(int[] vertexCounts, final var keys = new int[quads.length]; for (int q = 0; q < quads.length; q++) { - keys[q] = MathUtil.floatToComparableInt(quads[q].getDotProduct()); + keys[q] = MathUtil.floatToComparableInt(quads[q].getAccurateDotProduct()); } var indices = RadixSort.sort(keys); @@ -62,7 +61,7 @@ private static StaticNormalRelativeData fromDoubleUnaligned(int[] vertexCounts, final var sortData = new long[quads.length]; for (int q = 0; q < quads.length; q++) { - int dotProductComponent = MathUtil.floatToComparableInt(quads[q].getDotProduct()); + int dotProductComponent = MathUtil.floatToComparableInt(quads[q].getAccurateDotProduct()); sortData[q] = (long) dotProductComponent << 32 | q; } @@ -116,7 +115,7 @@ private static StaticNormalRelativeData fromMixed(int[] vertexCounts, final var keys = new int[count]; for (int q = 0; q < count; q++) { - keys[q] = MathUtil.floatToComparableInt(quads[quadIndex++].getDotProduct()); + keys[q] = MathUtil.floatToComparableInt(quads[quadIndex++].getAccurateDotProduct()); } var indices = RadixSort.sort(keys); @@ -127,7 +126,7 @@ private static StaticNormalRelativeData fromMixed(int[] vertexCounts, } else { for (int i = 0; i < count; i++) { var quad = quads[quadIndex++]; - int dotProductComponent = MathUtil.floatToComparableInt(quad.getDotProduct()); + int dotProductComponent = MathUtil.floatToComparableInt(quad.getAccurateDotProduct()); sortData[i] = (long) dotProductComponent << 32 | i; } diff --git a/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/data/TopoGraphSorting.java b/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/data/TopoGraphSorting.java index d45af2c756..eb8e9b3dea 100644 --- a/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/data/TopoGraphSorting.java +++ b/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/data/TopoGraphSorting.java @@ -19,6 +19,8 @@ * significantly more robust topo sorting. */ public class TopoGraphSorting { + private static final float HALF_SPACE_EPSILON = 0.001f; + private TopoGraphSorting() { } @@ -35,8 +37,36 @@ private static boolean pointOutsideHalfSpace(float planeDistance, Vector3fc plan return planeNormal.dot(point) > planeDistance; } - private static boolean pointInsideHalfSpace(float planeDistance, Vector3fc planeNormal, Vector3fc point) { - return planeNormal.dot(point) < planeDistance; + /** + * Test if the given point is within the half space defined by the plane anchor and the plane normal. The normal points away from the space considered to be inside. + *

+ * A small epsilon is added in the test to account for floating point errors, making it harder for a point on the edge to be considered inside. + * + * @param planeDistance dot product of the plane + * @param planeNormal the normal of the plane + * @param x x coordinate of the point + * @param y y coordinate of the point + * @param z z coordinate of the point + * @return true if the point is inside the half space + */ + private static boolean pointInsideHalfSpaceEpsilon(float planeDistance, Vector3fc planeNormal, float x, float y, float z) { + return planeNormal.dot(x, y, z) + HALF_SPACE_EPSILON < planeDistance; + } + + /** + * Test if the given point is outside the half space defined by the plane anchor and the plane normal. The normal points away from the space considered to be inside. + *

+ * A small epsilon is subtracted in the test to account for floating point errors, making it harder for a point on the edge to be considered outside. + * + * @param planeDistance dot product of the plane + * @param planeNormal the normal of the plane + * @param x x coordinate of the point + * @param y y coordinate of the point + * @param z z coordinate of the point + * @return true if the point is inside the half space + */ + private static boolean pointOutsideHalfSpaceEpsilon(float planeDistance, Vector3fc planeNormal, float x, float y, float z) { + return planeNormal.dot(x, y, z) - HALF_SPACE_EPSILON > planeDistance; } public static boolean orthogonalQuadVisibleThrough(TQuad quadA, TQuad quadB) { @@ -127,12 +157,9 @@ private static boolean visibilityWithSeparator(TQuad quadA, TQuad quadB, * Checks if one quad is visible through the other quad. This accepts arbitrary * quads, even unaligned ones. * - * @param quad the quad through which the other quad is being - * tested + * @param quad the quad through which the other quad is being tested * @param other the quad being tested - * @param distancesByNormal a map of normals to sorted arrays of face plane - * distances for disproving that the quads are visible - * through each other, null to disable + * @param distancesByNormal a map of normals to sorted arrays of face plane distances for disproving that the quads are visible through each other, null to disable * @return true if the other quad is visible through the first quad */ private static boolean quadVisibleThrough(TQuad quad, TQuad other, @@ -141,11 +168,12 @@ private static boolean quadVisibleThrough(TQuad quad, TQuad other, return false; } - // aligned quads - var quadFacing = quad.useQuantizedFacing(); - var otherFacing = other.useQuantizedFacing(); - boolean result; + var quadFacing = quad.getFacing(); + var otherFacing = other.getFacing(); + boolean result = false; if (quadFacing != ModelQuadFacing.UNASSIGNED && otherFacing != ModelQuadFacing.UNASSIGNED) { + // aligned quads + // opposites never see each other if (quadFacing.getOpposite() == otherFacing) { return false; @@ -162,15 +190,45 @@ private static boolean quadVisibleThrough(TQuad quad, TQuad other, } } else { // at least one unaligned quad - // this is an approximation since our quads don't store all their vertices. - // check that other center is within the half space of quad and that quad isn't - // in the half space of other - result = pointInsideHalfSpace(quad.getDotProduct(), quad.getQuantizedNormal(), other.getCenter()) - && !pointInsideHalfSpace(other.getDotProduct(), other.getQuantizedNormal(), quad.getCenter()); + + var quadDot = quad.getAccurateDotProduct(); + var quadNormal = quad.getAccurateNormal(); + var otherVertexPositions = other.getVertexPositions(); + + // at least one of the other quad's vertexes must be inside the half space of the first quad + var otherInsideQuad = false; + for (int i = 0, itemIndex = 0; i < 4; i++) { + if (pointInsideHalfSpaceEpsilon(quadDot, quadNormal, + otherVertexPositions[itemIndex++], + otherVertexPositions[itemIndex++], + otherVertexPositions[itemIndex++])) { + otherInsideQuad = true; + break; + } + } + if (otherInsideQuad) { + var otherDot = other.getAccurateDotProduct(); + var otherNormal = other.getAccurateNormal(); + var quadVertexPositions = quad.getVertexPositions(); + + // not all the quad's vertexes must be inside the half space of the other quad + // i.e. there must be at least one vertex outside the other quad + var quadNotFullyInsideOther = false; + for (int i = 0, itemIndex = 0; i < 4; i++) { + if (pointOutsideHalfSpaceEpsilon(otherDot, otherNormal, + quadVertexPositions[itemIndex++], + quadVertexPositions[itemIndex++], + quadVertexPositions[itemIndex++])) { + quadNotFullyInsideOther = true; + break; + } + } + + result = quadNotFullyInsideOther; + } } - // if enabled and necessary, try to disprove this see-through relationship with - // a separator plane + // if enabled and necessary, try to disprove this see-through relationship with a separator plane if (result && distancesByNormal != null) { return visibilityWithSeparator(quad, other, distancesByNormal, cameraPos); } @@ -209,10 +267,7 @@ public static boolean topoGraphSort( for (int i = 0; i < allQuads.length; i++) { TQuad quad = allQuads[i]; - // NOTE: This approximation may introduce wrong sorting if the real and the - // quantized normal aren't the same. A quad may be ignored with the quantized - // normal, but it's actually visible in camera. - if (pointOutsideHalfSpace(quad.getDotProduct(), quad.getQuantizedNormal(), cameraPos)) { + if (pointOutsideHalfSpace(quad.getAccurateDotProduct(), quad.getAccurateNormal(), cameraPos)) { activeToRealIndex[quadCount] = i; quads[quadCount] = quad; quadCount++; diff --git a/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/trigger/GeometryPlanes.java b/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/trigger/GeometryPlanes.java index 8f75c2db7d..16acdf0230 100644 --- a/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/trigger/GeometryPlanes.java +++ b/common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/translucent_sorting/trigger/GeometryPlanes.java @@ -92,9 +92,9 @@ public void addUnalignedPlane(SectionPos sectionPos, Vector3fc normal, float dis public void addQuadPlane(SectionPos sectionPos, TQuad quad) { var facing = quad.useQuantizedFacing(); if (facing.isAligned()) { - this.addAlignedPlane(sectionPos, facing.ordinal(), quad.getDotProduct()); + this.addAlignedPlane(sectionPos, facing.ordinal(), quad.getQuantizedDotProduct()); } else { - this.addUnalignedPlane(sectionPos, quad.getQuantizedNormal(), quad.getDotProduct()); + this.addUnalignedPlane(sectionPos, quad.getQuantizedNormal(), quad.getQuantizedDotProduct()); } }