From 702c210a7ae70a5d8e26601dcb241fbe08dc2106 Mon Sep 17 00:00:00 2001 From: grondag Date: Thu, 30 May 2019 06:00:16 -0700 Subject: [PATCH] Classify quads outside block bounds as full-bounds Also improves configurability --- .../main/java/net/fabricmc/indigo/Indigo.java | 6 ++ .../indigo/renderer/aocalc/AoCalculator.java | 63 +++++++------------ .../renderer/helper/GeometryHelper.java | 44 +++++++------ 3 files changed, 53 insertions(+), 60 deletions(-) diff --git a/fabric-renderer-indigo/src/main/java/net/fabricmc/indigo/Indigo.java b/fabric-renderer-indigo/src/main/java/net/fabricmc/indigo/Indigo.java index 225911cc7..fab4f76dc 100644 --- a/fabric-renderer-indigo/src/main/java/net/fabricmc/indigo/Indigo.java +++ b/fabric-renderer-indigo/src/main/java/net/fabricmc/indigo/Indigo.java @@ -35,6 +35,10 @@ import java.util.Properties; public class Indigo implements ClientModInitializer { public static final boolean ALWAYS_TESSELATE_INDIGO; public static final AoConfig AMBIENT_OCCLUSION_MODE; + /** Set true in dev env to confirm results match vanilla when they should */ + public static final boolean DEBUG_COMPARE_LIGHTING; + public static final boolean FIX_SMOOTH_LIGHTING_OFFSET; + private static final Logger LOGGER = LogManager.getLogger(); private static boolean asBoolean(String property, boolean defValue) { @@ -99,6 +103,8 @@ public class Indigo implements ClientModInitializer { ALWAYS_TESSELATE_INDIGO = asBoolean((String) properties.computeIfAbsent("always-tesselate-blocks", (a) -> "auto"), true); AMBIENT_OCCLUSION_MODE = asEnum((String) properties.computeIfAbsent("ambient-occlusion-mode", (a) -> "enhanced"), AoConfig.ENHANCED); + DEBUG_COMPARE_LIGHTING = asBoolean((String) properties.computeIfAbsent("debug-compare-lighting", (a) -> "auto"), false); + FIX_SMOOTH_LIGHTING_OFFSET = asBoolean((String) properties.computeIfAbsent("fix-smooth-lighting-offset", (a) -> "auto"), true); try (FileOutputStream stream = new FileOutputStream(configFile)) { properties.store(stream, "Indigo properties file"); diff --git a/fabric-renderer-indigo/src/main/java/net/fabricmc/indigo/renderer/aocalc/AoCalculator.java b/fabric-renderer-indigo/src/main/java/net/fabricmc/indigo/renderer/aocalc/AoCalculator.java index 22ee0db2d..cd5dba3d9 100644 --- a/fabric-renderer-indigo/src/main/java/net/fabricmc/indigo/renderer/aocalc/AoCalculator.java +++ b/fabric-renderer-indigo/src/main/java/net/fabricmc/indigo/renderer/aocalc/AoCalculator.java @@ -74,8 +74,6 @@ public class AoCalculator { } private static final Logger LOGGER = LogManager.getLogger(); - // TODO: make this actually configurable? - private static final boolean fixSmoothLighting = true; private final VanillaAoCalc vanillaCalc; private final BlockPos.Mutable lightPos = new BlockPos.Mutable(); @@ -112,12 +110,8 @@ public class AoCalculator { completionFlags = 0; } - /** Set true in dev env to confirm results match vanilla when they should */ - private static final boolean DEBUG = Boolean.valueOf(System.getProperty("fabric.debugAoLighting", "false")); - public void compute(MutableQuadViewImpl quad, boolean isVanilla) { final AoConfig config = Indigo.AMBIENT_OCCLUSION_MODE; - boolean shouldMatch = false; switch(config) { @@ -127,7 +121,7 @@ public class AoCalculator { case EMULATE: calcFastVanilla(quad); - shouldMatch = DEBUG && isVanilla; + shouldMatch = Indigo.DEBUG_COMPARE_LIGHTING && isVanilla; break; case HYBRID: @@ -164,7 +158,7 @@ public class AoCalculator { } } } - + private void calcVanilla(MutableQuadViewImpl quad) { vanillaCalc.compute(blockInfo, quad, ao, light); } @@ -173,28 +167,15 @@ public class AoCalculator { int flags = quad.geometryFlags(); // force to block face if shape is full cube - matches vanilla logic - if(((flags & LIGHT_FACE_FLAG) == 0) && Block.isShapeFullCube(blockInfo.blockState.getCollisionShape(blockInfo.blockView, blockInfo.blockPos))) { + if((flags & LIGHT_FACE_FLAG) == 0 && (flags & AXIS_ALIGNED_FLAG) == AXIS_ALIGNED_FLAG && Block.isShapeFullCube(blockInfo.blockState.getCollisionShape(blockInfo.blockView, blockInfo.blockPos))) { flags |= LIGHT_FACE_FLAG; } - - switch(flags) { - case AXIS_ALIGNED_FLAG | CUBIC_FLAG | LIGHT_FACE_FLAG: - vanillaFullFace(quad, true); - break; - - case AXIS_ALIGNED_FLAG | LIGHT_FACE_FLAG: - vanillaPartialFace(quad, true); - break; - - case AXIS_ALIGNED_FLAG | CUBIC_FLAG: - vanillaFullFace(quad, false); - break; - - default: - case AXIS_ALIGNED_FLAG: - vanillaPartialFace(quad, false); - break; - } + + if((flags & CUBIC_FLAG) == 0) { + vanillaPartialFace(quad, (flags & LIGHT_FACE_FLAG) != 0); + } else { + vanillaFullFace(quad, (flags & LIGHT_FACE_FLAG) != 0); + } } /** returns true if should match vanilla results */ @@ -202,11 +183,11 @@ public class AoCalculator { switch(quad.geometryFlags()) { case AXIS_ALIGNED_FLAG | CUBIC_FLAG | LIGHT_FACE_FLAG: vanillaFullFace(quad, true); - return DEBUG; + return Indigo.DEBUG_COMPARE_LIGHTING; case AXIS_ALIGNED_FLAG | LIGHT_FACE_FLAG: vanillaPartialFace(quad, true); - return DEBUG; + return Indigo.DEBUG_COMPARE_LIGHTING; case AXIS_ALIGNED_FLAG | CUBIC_FLAG: blendedFullFace(quad); @@ -222,12 +203,12 @@ public class AoCalculator { } } - private void vanillaFullFace(MutableQuadViewImpl quad, boolean isOnLightFace) { + private void vanillaFullFace(QuadViewImpl quad, boolean isOnLightFace) { final Direction lightFace = quad.lightFace(); computeFace(lightFace, isOnLightFace).toArray(ao, light, VERTEX_MAP[lightFace.getId()]); } - private void vanillaPartialFace(MutableQuadViewImpl quad, boolean isOnLightFace) { + private void vanillaPartialFace(QuadViewImpl quad, boolean isOnLightFace) { final Direction lightFace = quad.lightFace(); AoFaceData faceData = computeFace(lightFace, isOnLightFace); final WeightFunction wFunc = AoFace.get(lightFace).weightFunc; @@ -239,7 +220,7 @@ public class AoCalculator { } } - /** used in {@link #blendedInsetFace(VertexEditorImpl, Direction)} as return variable to avoid new allocation */ + /** used in {@link #blendedInsetFace(QuadViewImpl quad, int vertexIndex, Direction lightFace)} as return variable to avoid new allocation */ AoFaceData tmpFace = new AoFaceData(); /** Returns linearly interpolated blend of outer and inner face based on depth of vertex in face */ @@ -250,7 +231,7 @@ public class AoCalculator { } /** - * Like {@link #blendedInsetFace(VertexEditorImpl, Direction)} but optimizes if depth is 0 or 1. + * Like {@link #blendedInsetFace(QuadViewImpl quad, int vertexIndex, Direction lightFace)} but optimizes if depth is 0 or 1. * Used for irregular faces when depth varies by vertex to avoid unneeded interpolation. */ private AoFaceData gatherInsetFace(QuadViewImpl quad, int vertexIndex, Direction lightFace) { @@ -265,12 +246,12 @@ public class AoCalculator { } } - private void blendedFullFace(MutableQuadViewImpl quad) { + private void blendedFullFace(QuadViewImpl quad) { final Direction lightFace = quad.lightFace(); blendedInsetFace(quad, 0, lightFace).toArray(ao, light, VERTEX_MAP[lightFace.getId()]); } - private void blendedPartialFace(MutableQuadViewImpl quad) { + private void blendedPartialFace(QuadViewImpl quad) { final Direction lightFace = quad.lightFace(); AoFaceData faceData = blendedInsetFace(quad, 0, lightFace); final WeightFunction wFunc = AoFace.get(lightFace).weightFunc; @@ -383,16 +364,16 @@ public class AoCalculator { // vanilla was further offsetting these in the direction of the light face // but it was actually mis-sampling and causing visible artifacts in certain situation searchPos.set(lightPos).setOffset(aoFace.neighbors[0]);//.setOffset(lightFace); - if(!fixSmoothLighting) searchPos.setOffset(lightFace); + if(!Indigo.FIX_SMOOTH_LIGHTING_OFFSET) searchPos.setOffset(lightFace); final boolean isClear0 = world.getBlockState(searchPos).getLightSubtracted(world, searchPos) == 0; searchPos.set(lightPos).setOffset(aoFace.neighbors[1]);//.setOffset(lightFace); - if(!fixSmoothLighting) searchPos.setOffset(lightFace); + if(!Indigo.FIX_SMOOTH_LIGHTING_OFFSET) searchPos.setOffset(lightFace); final boolean isClear1 = world.getBlockState(searchPos).getLightSubtracted(world, searchPos) == 0; searchPos.set(lightPos).setOffset(aoFace.neighbors[2]);//.setOffset(lightFace); - if(!fixSmoothLighting) searchPos.setOffset(lightFace); + if(!Indigo.FIX_SMOOTH_LIGHTING_OFFSET) searchPos.setOffset(lightFace); final boolean isClear2 = world.getBlockState(searchPos).getLightSubtracted(world, searchPos) == 0; searchPos.set(lightPos).setOffset(aoFace.neighbors[3]);//.setOffset(lightFace); - if(!fixSmoothLighting) searchPos.setOffset(lightFace); + if(!Indigo.FIX_SMOOTH_LIGHTING_OFFSET) searchPos.setOffset(lightFace); final boolean isClear3 = world.getBlockState(searchPos).getLightSubtracted(world, searchPos) == 0; // c = corner - values at corners of face @@ -469,7 +450,7 @@ public class AoCalculator { * value from all four samples. */ private static int meanBrightness(int a, int b, int c, int d) { - if(fixSmoothLighting) { + if(Indigo.FIX_SMOOTH_LIGHTING_OFFSET) { return a == 0 || b == 0 || c == 0 || d == 0 ? meanEdgeBrightness(a, b, c, d) : meanInnerBrightness(a, b, c, d); } else { return vanillaMeanBrightness(a, b, c, d); diff --git a/fabric-renderer-indigo/src/main/java/net/fabricmc/indigo/renderer/helper/GeometryHelper.java b/fabric-renderer-indigo/src/main/java/net/fabricmc/indigo/renderer/helper/GeometryHelper.java index 527d60db6..b10536d0e 100644 --- a/fabric-renderer-indigo/src/main/java/net/fabricmc/indigo/renderer/helper/GeometryHelper.java +++ b/fabric-renderer-indigo/src/main/java/net/fabricmc/indigo/renderer/helper/GeometryHelper.java @@ -39,7 +39,10 @@ public abstract class GeometryHelper { /** set when a quad is coplanar with its light face. Implies {@link #AXIS_ALIGNED_FLAG} */ public static final int LIGHT_FACE_FLAG = AXIS_ALIGNED_FLAG << 1; - + + private static final float EPS_MIN = 0.0001f; + private static final float EPS_MAX = 1.0f - EPS_MIN; + private GeometryHelper() {} /** @@ -56,10 +59,10 @@ public abstract class GeometryHelper { if(isParallelQuadOnFace(lightFace, quad)) { bits |= LIGHT_FACE_FLAG; } - if(isQuadCubic(lightFace, quad)) { - bits |= CUBIC_FLAG; - } } + if(isQuadCubic(lightFace, quad)) { + bits |= CUBIC_FLAG; + } return bits; } @@ -80,17 +83,17 @@ public abstract class GeometryHelper { } /** - * True if quad - already known to be parallel to a face - is actually coplanar with it.

+ * True if quad - already known to be parallel to a face - is actually coplanar with it. + * For compatibility with vanilla resource packs, also true if quad is outside the face.

* - * Test will be unreliable if not already parallel, use {@link #isQuadParallel(Direction, QuadView)} + * Test will be unreliable if not already parallel, use {@link #isQuadParallelToFace(Direction, QuadView)} * for that purpose. Expects convex quads with all points co-planar.

*/ public static boolean isParallelQuadOnFace(Direction lightFace, QuadView quad) { if(lightFace == null) return false; - final int coordinateIndex = lightFace.getAxis().ordinal(); - final float expectedValue = lightFace.getDirection() == AxisDirection.POSITIVE ? 1 : 0; - return equalsApproximate(quad.posByIndex(0, coordinateIndex), expectedValue); + final float x = quad.posByIndex(0, lightFace.getAxis().ordinal()); + return lightFace.getDirection() == AxisDirection.POSITIVE ? x >= EPS_MAX : x <= EPS_MIN; } /** @@ -101,7 +104,7 @@ public abstract class GeometryHelper { * quad vertices are coplanar with each other.

* * Expects convex quads with all points co-planar.

- * + * * @param lightFace MUST be non-null. */ public static boolean isQuadCubic(Direction lightFace, QuadView quad) { @@ -134,10 +137,13 @@ public abstract class GeometryHelper { return confirmSquareCorners(a, b, quad); } - + /** - * Used by {@link #isQuadCubic(Direction, int[], int, QuadSerializer)}. - * True if quad touches all four corners of unit square. + * Used by {@link #isQuadCubic(Direction, QuadView)}. + * True if quad touches all four corners of unit square.

+ * + * For compatibility with resource packs that contain models with quads exceeding + * block boundaries, considers corners outside the block to be at the corners. */ private static boolean confirmSquareCorners(int aCoordinate, int bCoordinate, QuadView quad) { int flags = 0; @@ -146,18 +152,18 @@ public abstract class GeometryHelper { final float a = quad.posByIndex(i, aCoordinate); final float b = quad.posByIndex(i, bCoordinate); - if(equalsApproximate(a, 0)) { - if(equalsApproximate(b, 0)) { + if(a <= EPS_MIN) { + if(b <= EPS_MIN) { flags |= 1; - } else if(equalsApproximate(b, 1)) { + } else if(b >= EPS_MAX) { flags |= 2; } else { return false; } - } else if(equalsApproximate(a, 1)) { - if(equalsApproximate(b, 0)) { + } else if(a >= EPS_MAX) { + if(b <= EPS_MIN) { flags |= 4; - } else if(equalsApproximate(b, 1)) { + } else if(b >= EPS_MAX) { flags |= 8; } else { return false;