Stupid splash thread (#1973)

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/GLStateManager.java

@@ -1051,6 +1051,7 @@ public class GLStateManager {
             case GL11.GL_SHADE_MODEL -> shadeModelState.getValue();
             // GL_TEXTURE_2D makes no sense here, but some mod still queries it...
             case GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_BINDING_2D -> getBoundTextureForServerState();
+            case GL13.GL_ACTIVE_TEXTURE -> GL13.GL_TEXTURE0 + getActiveTextureUnitForServerState();
             case GL11.GL_COLOR_MATERIAL_FACE -> colorMaterialFace.getValue();
             case GL11.GL_COLOR_MATERIAL_PARAMETER -> colorMaterialParameter.getValue();
             case GL11.GL_MODELVIEW_STACK_DEPTH -> getMatrixStackDepth(modelViewMatrix);
@@ -1059,15 +1060,18 @@ public class GLStateManager {
             case GL12.GL_LIGHT_MODEL_COLOR_CONTROL -> lightModel.colorControl;
 
             case GL14.GL_BLEND_DST_ALPHA -> blendState.getDstAlpha();
-            case GL14.GL_BLEND_DST_RGB -> blendState.getDstRgb();
+            case GL11.GL_BLEND_DST, GL14.GL_BLEND_DST_RGB -> blendState.getDstRgb();
             case GL14.GL_BLEND_SRC_ALPHA -> blendState.getSrcAlpha();
-            case GL14.GL_BLEND_SRC_RGB -> blendState.getSrcRgb();
+            case GL11.GL_BLEND_SRC, GL14.GL_BLEND_SRC_RGB -> blendState.getSrcRgb();
             case GL14.GL_BLEND_EQUATION -> blendState.getEquationRgb();
             case GL20.GL_BLEND_EQUATION_ALPHA -> blendState.getEquationAlpha();
 
             case GL11.GL_LOGIC_OP_MODE -> logicOpMode.getValue();
             case GL11.GL_DRAW_BUFFER -> drawBuffer.getValue();
 
+            case GL11.GL_CULL_FACE_MODE -> polygonState.getCullFaceMode();
+            case GL11.GL_FRONT_FACE -> polygonState.getFrontFace();
+
             case GL11.GL_STENCIL_FUNC -> stencilState.getFuncFront();
             case GL11.GL_STENCIL_REF -> stencilState.getRefFront();
             case GL11.GL_STENCIL_VALUE_MASK -> stencilState.getValueMaskFront();
@@ -1106,6 +1110,10 @@ public class GLStateManager {
 
         switch (pname) {
             case GL11.GL_VIEWPORT -> viewportState.get(params);
+            case GL11.GL_POLYGON_MODE -> {
+                params.put(0, polygonState.getFrontMode());
+                params.put(1, polygonState.getBackMode());
+            }
             default -> {
                 if (!HAS_MULTIPLE_SET.contains(pname)) {
                     params.put(0, glGetInteger(pname));
@@ -5214,30 +5222,36 @@ public class GLStateManager {
 
     private static void invalidateDeletedBuffer(int buffer) {
         if (buffer == 0) return;
-        if (boundVBO == buffer) glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
-        if (VAOManager.boundEBO == buffer) glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);
-        if (boundPixelUnpackBuffer == buffer) glBindBuffer(GL21.GL_PIXEL_UNPACK_BUFFER, 0);
-        if (boundPixelPackBuffer == buffer) glBindBuffer(GL21.GL_PIXEL_PACK_BUFFER, 0);
+        final boolean locked = acquireDrawLock();
+        try {
+            if (boundVBO == buffer) glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
+            if (VAOManager.boundEBO == buffer) glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);
+            if (boundPixelUnpackBuffer == buffer) glBindBuffer(GL21.GL_PIXEL_UNPACK_BUFFER, 0);
+            if (boundPixelPackBuffer == buffer) glBindBuffer(GL21.GL_PIXEL_PACK_BUFFER, 0);
 
-        // Sweep all VAOs: an unbound VAO may later rebind with a dangling EBO id.
-        for (VAOManager.VAOData data : VAOManager.vaoMap.values()) {
-            if (data.ebo == buffer) data.ebo = 0;
+            VAOManager.onDeleteBuffer(buffer);
+        } finally {
+            if (locked) releaseDrawLock();
         }
-
     }
 
     public static void glBindBuffer(int target, int buffer) {
-        if (target == GL15.GL_ARRAY_BUFFER) {
-            // if (boundVBO == buffer) return; TODO figure out why this breaks switching async occlusion mode
-            boundVBO = buffer;
-        } else if (target == GL15.GL_ELEMENT_ARRAY_BUFFER) {
-            VAOManager.onBindEBO(buffer);
-        } else if (target == GL21.GL_PIXEL_UNPACK_BUFFER) {
-            boundPixelUnpackBuffer = buffer;
-        } else if (target == GL21.GL_PIXEL_PACK_BUFFER) {
-            boundPixelPackBuffer = buffer;
+        final boolean locked = acquireDrawLock();
+        try {
+            if (target == GL15.GL_ARRAY_BUFFER) {
+                // if (boundVBO == buffer) return; TODO figure out why this breaks switching async occlusion mode
+                boundVBO = buffer;
+            } else if (target == GL15.GL_ELEMENT_ARRAY_BUFFER) {
+                VAOManager.onBindEBO(buffer);
+            } else if (target == GL21.GL_PIXEL_UNPACK_BUFFER) {
+                boundPixelUnpackBuffer = buffer;
+            } else if (target == GL21.GL_PIXEL_PACK_BUFFER) {
+                boundPixelPackBuffer = buffer;
+            }
+            RENDER_BACKEND.bindBuffer(target, buffer);
+        } finally {
+            if (locked) releaseDrawLock();
         }
-        RENDER_BACKEND.bindBuffer(target, buffer);
     }
 
     public static void forcePixelUnpackState(PixelUnpackState target) {
@@ -5572,22 +5586,32 @@ public class GLStateManager {
         if (array == 0) {
             array = defaultVAO;
         }
-        if (boundVAO != array) {
-            boundVAO = array;
-            VAOManager.onBindVertexArrayPre(array);
-            RENDER_BACKEND.bindVertexArray(array);
+        final boolean locked = acquireDrawLock();
+        try {
+            if (boundVAO != array) {
+                boundVAO = array;
+                VAOManager.onBindVertexArrayPre(array);
+                RENDER_BACKEND.bindVertexArray(array);
+            }
+        } finally {
+            if (locked) releaseDrawLock();
         }
     }
 
     public static void glDeleteVertexArrays(int array) {
-        VAOManager.onDeleteVertexArray(array);
-        if (array == boundVAO) {
-            // Deleting the bound VAO implicitly unbinds it. Rebind the default VAO.
-            boundVAO = defaultVAO;
-            VAOManager.onBindVertexArrayPre(defaultVAO);
-            RENDER_BACKEND.bindVertexArray(defaultVAO);
+        final boolean locked = acquireDrawLock();
+        try {
+            VAOManager.onDeleteVertexArray(array);
+            if (array == boundVAO) {
+                // Deleting the bound VAO implicitly unbinds it. Rebind the default VAO.
+                boundVAO = defaultVAO;
+                VAOManager.onBindVertexArrayPre(defaultVAO);
+                RENDER_BACKEND.bindVertexArray(defaultVAO);
+            }
+            RENDER_BACKEND.deleteVertexArrays(array);
+        } finally {
+            if (locked) releaseDrawLock();
         }
-        RENDER_BACKEND.deleteVertexArrays(array);
     }
 
     public static int glGenVertexArrays() {

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/ffp/VAOManager.java

@@ -15,6 +15,8 @@ public final class VAOManager {
 
     public static final Int2ObjectOpenHashMap<VAOData> vaoMap = new Int2ObjectOpenHashMap<>();
 
+    static final Int2ObjectOpenHashMap<VAOData> eboOwners = new Int2ObjectOpenHashMap<>();
+
     private static VAOData current = null;
     private static int currentVertexFlags = 0;
     private static Attrib[] currentAttribs = null;
@@ -38,7 +40,11 @@ public final class VAOManager {
         // Save old VAO data
         if (current != null) {
             current.vertexFlags = currentVertexFlags;
-            current.ebo = boundEBO;
+            if (current.ebo != boundEBO) {
+                removeEboOwner(current.ebo, current);
+                current.ebo = boundEBO;
+                addEboOwner(current.ebo, current);
+            }
             current.attribs = currentAttribs;
             current.clientSideEnabledCount = clientSideEnabledCount;
         }
@@ -56,7 +62,46 @@ public final class VAOManager {
     }
 
     public static void onDeleteVertexArray(int vaoId) {
-        vaoMap.remove(vaoId);
+        final VAOData data = vaoMap.remove(vaoId);
+        if (data == null) return;
+        removeEboOwner(data.ebo, data);
+        if (data == current) current = null;
+    }
+
+    public static void onDeleteBuffer(int buffer) {
+        if (buffer == 0) return;
+        VAOData owner = eboOwners.remove(buffer);
+        while (owner != null) {
+            final VAOData next = owner.nextEboOwner;
+            owner.nextEboOwner = null;
+            owner.ebo = 0;
+            owner = next;
+        }
+    }
+
+    private static void addEboOwner(int ebo, VAOData data) {
+        if (ebo == 0) return;
+        data.nextEboOwner = eboOwners.put(ebo, data);
+    }
+
+    private static void removeEboOwner(int ebo, VAOData data) {
+        if (ebo == 0) return;
+        VAOData node = eboOwners.get(ebo);
+        if (node == data) {
+            final VAOData next = data.nextEboOwner;
+            if (next == null) eboOwners.remove(ebo); else eboOwners.put(ebo, next);
+            data.nextEboOwner = null;
+            return;
+        }
+        while (node != null) {
+            final VAOData next = node.nextEboOwner;
+            if (next == data) {
+                node.nextEboOwner = data.nextEboOwner;
+                data.nextEboOwner = null;
+                return;
+            }
+            node = next;
+        }
     }
 
     public static void enableClientVertexFlag(int flag) { currentVertexFlags |= flag; }
@@ -69,6 +114,7 @@ public final class VAOManager {
         public int vertexFlags;
         public int ebo;
         public int clientSideEnabledCount;
+        private VAOData nextEboOwner;
 
         public VAOData() {
             attribs = new Attrib[MAX_ATTRIBS];

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/recording/DisplayListVBO.java

@@ -62,11 +62,14 @@ public final class DisplayListVBO {
         }
 
         public void render() {
-            vao.bind();
-            vao.draw(drawMode, start, count);
-            vao.unbind();
+        if (vao == null) return;
+        vao.bind();
+        if (count <= 0) { vao.unbind(); return; }
+        vao.draw(drawMode, start, count);
+        vao.unbind();
         }
 
+
         public IVertexArrayObject getVAO() {
             return vao;
         }

glsm/src/test/java/com/gtnewhorizons/angelica/glsm/GLSM_PushPop_UnitTest.java

@@ -1131,4 +1131,52 @@ class GLSM_PushPop_UnitTest {
         GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
         GLStateManager.glDisable(GL11.GL_TEXTURE_2D);
     }
+
+    @Test
+    void testBlendFuncGL11AliasesMatchGL14() {
+        GLStateManager.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+
+        verifyState(GL11.GL_BLEND_SRC, GL11.GL_SRC_ALPHA, "Blend Source");
+        verifyState(GL14.GL_BLEND_SRC_RGB, GL11.GL_SRC_ALPHA, "Blend Source RGB");
+        verifyState(GL11.GL_BLEND_DST, GL11.GL_ONE_MINUS_SRC_ALPHA, "Blend Destination");
+        verifyState(GL14.GL_BLEND_DST_RGB, GL11.GL_ONE_MINUS_SRC_ALPHA, "Blend Destination RGB");
+
+        GLStateManager.glBlendFunc(GL11.GL_ONE, GL11.GL_ZERO);
+    }
+
+    @Test
+    void testBlendFuncSeparateGL11AliasesTrackRgb() {
+        GLStateManager.glBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
+
+        verifyState(GL11.GL_BLEND_SRC, GL11.GL_SRC_ALPHA, "Blend Source");
+        verifyState(GL11.GL_BLEND_DST, GL11.GL_ONE_MINUS_SRC_ALPHA, "Blend Destination");
+        verifyState(GL14.GL_BLEND_SRC_ALPHA, GL11.GL_ONE, "Blend Source Alpha");
+        verifyState(GL14.GL_BLEND_DST_ALPHA, GL11.GL_ZERO, "Blend Destination Alpha");
+
+        GLStateManager.glBlendFunc(GL11.GL_ONE, GL11.GL_ZERO);
+    }
+
+    @Test
+    void testPolygonStateReadBack() {
+        GLStateManager.glCullFace(GL11.GL_FRONT);
+        GLStateManager.glFrontFace(GL11.GL_CW);
+        GLStateManager.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_LINE);
+
+        verifyState(GL11.GL_CULL_FACE_MODE, GL11.GL_FRONT, "Cull Face Mode");
+        verifyState(GL11.GL_FRONT_FACE, GL11.GL_CW, "Front Face");
+        verifyState(GL11.GL_POLYGON_MODE, new int[] { GL11.GL_LINE, GL11.GL_LINE }, "Polygon Mode");
+
+        GLStateManager.glCullFace(GL11.GL_BACK);
+        GLStateManager.glFrontFace(GL11.GL_CCW);
+        GLStateManager.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_FILL);
+    }
+
+    @Test
+    void testActiveTextureReadBack() {
+        GLStateManager.glActiveTexture(GL13.GL_TEXTURE1);
+        verifyState(GL13.GL_ACTIVE_TEXTURE, GL13.GL_TEXTURE1, "Active Texture");
+
+        GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
+        verifyState(GL13.GL_ACTIVE_TEXTURE, GL13.GL_TEXTURE0, "Active Texture - Reset");
+    }
 }

glsm/src/test/java/com/gtnewhorizons/angelica/glsm/ffp/VAOManagerEboIndexTest.java

@@ -0,0 +1,189 @@
+package com.gtnewhorizons.angelica.glsm.ffp;
+
+import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
+import it.unimi.dsi.fastutil.ints.IntArrayList;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.Random;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class VAOManagerEboIndexTest {
+
+    private static final int DEFAULT_VAO = 0;
+    private static final int NO_VAO = -1;
+
+    private final Int2IntOpenHashMap expectedEbo = new Int2IntOpenHashMap();
+    private int currentVao;
+
+    @BeforeEach
+    void reset() {
+        drainManagerState();
+        expectedEbo.clear();
+        VAOManager.init(DEFAULT_VAO);
+        expectedEbo.put(DEFAULT_VAO, 0);
+        currentVao = DEFAULT_VAO;
+    }
+
+    @AfterEach
+    void drain() {
+        drainManagerState();
+    }
+
+    private static void drainManagerState() {
+        for (int vao : VAOManager.vaoMap.keySet().toIntArray()) {
+            VAOManager.onDeleteVertexArray(vao);
+        }
+        VAOManager.boundEBO = 0;
+        assertEquals(0, VAOManager.eboOwners.size(), "draining every VAO left entries in the index");
+    }
+
+    private void bindVao(int vao) {
+        if (currentVao != NO_VAO) expectedEbo.put(currentVao, VAOManager.boundEBO);
+        VAOManager.onBindVertexArrayPre(vao);
+        expectedEbo.putIfAbsent(vao, 0);
+        currentVao = vao;
+    }
+
+    private void bindEbo(int ebo) {
+        VAOManager.onBindEBO(ebo);
+    }
+
+    private int countOwners(int buffer) {
+        int owners = 0;
+        for (int vao : expectedEbo.keySet().toIntArray()) {
+            if (expectedEbo.get(vao) == buffer) owners++;
+        }
+        return owners;
+    }
+
+    private void deleteBuffer(int buffer) {
+        VAOManager.onDeleteBuffer(buffer);
+        for (int vao : expectedEbo.keySet().toIntArray()) {
+            if (expectedEbo.get(vao) == buffer) expectedEbo.put(vao, 0);
+        }
+    }
+
+    private void deleteVao(int vao) {
+        VAOManager.onDeleteVertexArray(vao);
+        expectedEbo.remove(vao);
+        if (vao == currentVao) currentVao = NO_VAO;
+    }
+
+    private void assertExpectedEbos(int op) {
+        for (var entry : VAOManager.vaoMap.int2ObjectEntrySet()) {
+            final int vao = entry.getIntKey();
+            if (vao == currentVao) continue;
+            assertEquals(expectedEbo.get(vao), entry.getValue().ebo, () -> "op " + op + ": vao " + vao + " ebo mismatch");
+        }
+    }
+
+    @Test
+    void everyVaoKeepsItsExpectedEboUnderRandomOps() {
+        final Random random = new Random(0xC0FFEE);
+        final IntArrayList liveVaos = new IntArrayList();
+        final IntArrayList liveBuffers = new IntArrayList();
+        int nextVao = 1;
+        int nextBuffer = 1;
+        int sharedEboDeletes = 0;
+
+        for (int op = 0; op < 200_000; op++) {
+            switch (random.nextInt(5)) {
+                case 0 -> {
+                    final int vao = nextVao++;
+                    liveVaos.add(vao);
+                    bindVao(vao);
+                }
+                case 1 -> {
+                    if (liveVaos.isEmpty()) break;
+                    bindVao(liveVaos.getInt(random.nextInt(liveVaos.size())));
+                }
+                case 2 -> {
+                    if (currentVao == NO_VAO) break;
+                    final int buffer = (random.nextBoolean() && nextBuffer > 8) ? 1 + random.nextInt(nextBuffer - 1) : nextBuffer++;
+                    liveBuffers.add(buffer);
+                    bindEbo(buffer);
+                }
+                case 3 -> {
+                    if (liveBuffers.isEmpty()) break;
+                    final int buffer = liveBuffers.removeInt(random.nextInt(liveBuffers.size()));
+                    if (countOwners(buffer) > 1) sharedEboDeletes++;
+                    deleteBuffer(buffer);
+                }
+                case 4 -> {
+                    if (liveVaos.isEmpty()) break;
+                    final int vao = liveVaos.removeInt(random.nextInt(liveVaos.size()));
+                    final boolean wasBound = vao == currentVao;
+                    deleteVao(vao);
+                    if (wasBound) bindVao(DEFAULT_VAO);
+                }
+            }
+            assertExpectedEbos(op);
+        }
+        assertTrue(sharedEboDeletes > 20, "op stream never freed a multi-owner EBO (hits: " + sharedEboDeletes + ")");
+    }
+
+    @Test
+    void sharedEboClearsEveryOwner() {
+        final int ebo = 77;
+        bindVao(1);
+        bindEbo(ebo);
+        bindVao(2);
+        bindEbo(ebo);
+        bindVao(3);
+        bindEbo(ebo);
+        bindVao(DEFAULT_VAO);
+
+        deleteBuffer(ebo);
+
+        assertEquals(0, VAOManager.vaoMap.get(1).ebo, "vao 1 kept a freed shared EBO");
+        assertEquals(0, VAOManager.vaoMap.get(2).ebo, "vao 2 kept a freed shared EBO");
+        assertEquals(0, VAOManager.vaoMap.get(3).ebo, "vao 3 kept a freed shared EBO");
+        assertFalse(VAOManager.eboOwners.containsKey(ebo), "index kept owners for a freed EBO");
+    }
+
+    @Test
+    void sharedEboEntryDropsOnlyAfterItsLastOwnerGoes() {
+        final int ebo = 88;
+        bindVao(1);
+        bindEbo(ebo);
+        bindVao(2);
+        bindEbo(ebo);
+        bindVao(DEFAULT_VAO);
+
+        deleteVao(1);
+        assertTrue(VAOManager.eboOwners.containsKey(ebo), "index dropped a still-live owner");
+        deleteVao(2);
+        assertFalse(VAOManager.eboOwners.containsKey(ebo), "index kept an entry after its last owner went away");
+    }
+
+    @Test
+    void deletingTheBoundVaoDoesNotOrphanAnIndexEntry() {
+        final int ebo = 99;
+        bindVao(1);
+        bindEbo(ebo);
+
+        deleteVao(1);
+        bindVao(DEFAULT_VAO);
+
+        assertFalse(VAOManager.eboOwners.containsKey(ebo), "deleting the bound VAO left an unreachable owner in the index");
+        assertEquals(0, VAOManager.eboOwners.size(), "index leaked an entry for a deleted VAO");
+    }
+
+    @Test
+    void indexEmptiesOutWhenEverythingIsDeleted() {
+        for (int vao = 1; vao <= 64; vao++) {
+            bindVao(vao);
+            bindEbo(1000 + vao);
+        }
+        bindVao(DEFAULT_VAO);
+        for (int vao = 1; vao <= 64; vao++) {
+            deleteVao(vao);
+        }
+        assertEquals(0, VAOManager.eboOwners.size(), "index leaked entries after every VAO was deleted");
+    }
+}

src/main/java/com/gtnewhorizons/angelica/proxy/ClientProxy.java

@@ -296,7 +296,7 @@ public final class ClientProxy extends CommonProxy {
                     event.left.set(i + 4, String.format(
                         "lc: %d b: %s bl: %d sl: %d rl: %d",
                         chunk.getTopFilledSegment() + 15,
-                        this.mc.theWorld.getBiomeGenForCoords(bX & 15, bZ & 15).biomeName,
+                        this.mc.theWorld.getBiomeGenForCoords(bX, bZ).biomeName,
                         chunk.getSavedLightValue(EnumSkyBlock.Block, bX & 15, CompatMathHelper.clampHeight(bY), bZ & 15),
                         chunk.getSavedLightValue(EnumSkyBlock.Sky, bX & 15, CompatMathHelper.clampHeight(bY), bZ & 15),
                         chunk.getBlockLightValue(bX & 15, CompatMathHelper.clampHeight(bY), bZ & 15, 0)));

src/main/java/com/gtnewhorizons/angelica/utils/MipmapStrategies.java

@@ -8,8 +8,10 @@ import net.minecraft.block.BlockLeaves;
 import net.minecraft.block.BlockMushroom;
 import net.minecraft.block.BlockRedstoneWire;
 
+import java.util.Deque;
 import java.util.LinkedList;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * Fallback {@link MipmapStrategy} assignments for sprites that carry no metadata.
@@ -17,8 +19,8 @@ import java.util.Map;
 public final class MipmapStrategies {
 
     private static final Map<Class<?>, MipmapStrategy> CLASS_RULES = new Object2ObjectOpenHashMap<>();
-    private static final Map<String, MipmapStrategy> SPRITE_RULES = new Object2ObjectOpenHashMap<>();
-    private static final LinkedList<MipmapStrategy> STRATEGY_STACK = new LinkedList<>();
+    private static final Map<String, MipmapStrategy> SPRITE_RULES = new ConcurrentHashMap<>();
+    private static final ThreadLocal<Deque<MipmapStrategy>> STRATEGY_STACK = ThreadLocal.withInitial(LinkedList::new);
 
     static {
         CLASS_RULES.put(BlockLeaves.class, MipmapStrategy.DARK_CUTOUT);
@@ -33,16 +35,17 @@ public final class MipmapStrategies {
 
     public static void reset() {
         SPRITE_RULES.clear();
-        STRATEGY_STACK.clear();
+        STRATEGY_STACK.remove();
     }
 
     public static void beginBlock(Block block) {
-        STRATEGY_STACK.push(resolve(block.getClass()));
+        STRATEGY_STACK.get().push(resolve(block.getClass()));
     }
 
     public static void endBlock() {
-        if (!STRATEGY_STACK.isEmpty()) {
-            STRATEGY_STACK.pop();
+        final Deque<MipmapStrategy> stack = STRATEGY_STACK.get();
+        if (!stack.isEmpty()) {
+            stack.pop();
         }
     }
 
@@ -51,7 +54,7 @@ public final class MipmapStrategies {
             return;
         }
 
-        MipmapStrategy strategy = STRATEGY_STACK.peek();
+        MipmapStrategy strategy = STRATEGY_STACK.get().peek();
         if (strategy == null && textureType == 0 && iconName.contains("leaves")) {
             strategy = MipmapStrategy.DARK_CUTOUT;
         }
@@ -59,10 +62,8 @@ public final class MipmapStrategies {
             return;
         }
 
-        final MipmapStrategy existing = SPRITE_RULES.get(iconName);
-        if (existing == null || strategy.conflictPrecedence() > existing.conflictPrecedence()) {
-            SPRITE_RULES.put(iconName, strategy);
-        }
+        SPRITE_RULES.merge(iconName, strategy,
+            (existing, incoming) -> incoming.conflictPrecedence() > existing.conflictPrecedence() ? incoming : existing);
     }
 
     public static MipmapStrategy inheritedFor(int textureType, String iconName) {

src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/features/textures/MixinTextureMap.java

@@ -6,6 +6,8 @@ import com.gtnewhorizons.angelica.rendering.celeritas.TextureMapExtension;
 import com.gtnewhorizons.angelica.utils.MipmapStrategies;
 import com.gtnewhorizons.angelica.utils.MipmapStrategy;
 import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import com.llamalad7.mixinextras.sugar.Local;
 import me.jellysquid.mods.sodium.client.gui.SodiumGameOptions;
 import net.minecraft.block.Block;
@@ -27,7 +29,6 @@ import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.ModifyArg;
-import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
@@ -74,15 +75,15 @@ public class MixinTextureMap implements TextureMapExtension {
     /**
      * Brackets each block's icon registration so the sprites it registers can be attributed to it.
      */
-    @Redirect(
+    @WrapOperation(
         method = "registerIcons",
         at = @At(
             value = "INVOKE",
             target = "Lnet/minecraft/block/Block;registerBlockIcons(Lnet/minecraft/client/renderer/texture/IIconRegister;)V"))
-    private void angelica$trackBlockIcons(Block block, IIconRegister reg) {
+    private void angelica$trackBlockIcons(Block block, IIconRegister reg, Operation<Void> original) {
         MipmapStrategies.beginBlock(block);
         try {
-            block.registerBlockIcons(reg);
+            original.call(block, reg);
         } finally {
             MipmapStrategies.endBlock();
         }