Upsteam updates

coredex-source · coredex-source · commit b8c90d1d9377 · 2026-06-17T16:27:00.000+05:30
- SurfaceRule optimizations are pending. - Fixes #40
diff --git a/gradle.properties b/gradle.properties
@@ -4,7 +4,7 @@ org.gradle.jvmargs=-Xmx2G
 
 # Mod properties
 mod_id=modernfix
-version=5.27.7-build.1
+version=5.27.17-build.1
 
 # Minecraft/Fabric
 minecraft_version=26.1.2
diff --git a/src/main/java/org/embeddedt/modernfix/ModernFix.java b/src/main/java/org/embeddedt/modernfix/ModernFix.java
@@ -15,6 +15,7 @@
 import org.embeddedt.modernfix.util.ClassInfoManager;
 import org.spongepowered.asm.mixin.MixinEnvironment;
 
+import net.minecraft.client.Minecraft;
 import java.lang.management.ManagementFactory;
 
 // The value here should match an entry in the META-INF/mods.toml file
@@ -51,6 +52,8 @@ public static void runAuditIfRequested() {
         if (auditAndExit || Boolean.getBoolean("modernfix.auditMixinsAtStart")) {
             MixinEnvironment.getCurrentEnvironment().audit();
             if (auditAndExit) {
+                // Prevents Crash Assistant from treating mixin audit as a crash
+                Minecraft.getInstance().stop();
                 System.exit(0);
             }
         }
diff --git a/src/main/java/org/embeddedt/modernfix/common/mixin/perf/attribute_supplier_dedup/AttributeSupplierMixin.java b/src/main/java/org/embeddedt/modernfix/common/mixin/perf/attribute_supplier_dedup/AttributeSupplierMixin.java
@@ -1,6 +1,6 @@
 package org.embeddedt.modernfix.common.mixin.perf.attribute_supplier_dedup;
 
-import net.minecraft.core.Holder;
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
 import net.minecraft.world.entity.ai.attributes.Attribute;
 import net.minecraft.world.entity.ai.attributes.AttributeInstance;
 import net.minecraft.world.entity.ai.attributes.AttributeSupplier;
@@ -19,15 +19,15 @@ public class AttributeSupplierMixin {
     @Shadow
     @Final
     @Mutable
-    private Map<Holder<Attribute>, AttributeInstance> instances;
+    private Map<Attribute, AttributeInstance> instances;
 
     /**
      * @author embeddedt
-     * @reason Java 9's Map.of() implementation is significantly more compact than ImmutableMap, and we do not
+     * @reason more compact than ImmutableMap due to less wrapper objects, and we do not
      * care about insertion order in this context
      */
     @Inject(method = "<init>", at = @At("RETURN"))
-    private void useCompactJavaMap(Map<Holder<Attribute>, AttributeInstance> instances, CallbackInfo ci) {
-        this.instances = Map.copyOf(this.instances);
+    private void useCompactJavaMap(Map<Attribute, AttributeInstance> instances, CallbackInfo ci) {
+        this.instances = new Object2ObjectOpenHashMap<>(this.instances);
     }
 }
diff --git a/src/main/java/org/embeddedt/modernfix/common/mixin/perf/dynamic_languages/ClientLanguageMixin.java b/src/main/java/org/embeddedt/modernfix/common/mixin/perf/dynamic_languages/ClientLanguageMixin.java
@@ -28,26 +28,28 @@ public class ClientLanguageMixin {
      * @reason collect the list of all known language resources
      */
     @WrapOperation(method = "loadFrom", at = @At(value = "INVOKE",
-            target = "Lnet/minecraft/client/resources/language/ClientLanguage;appendFrom(Ljava/lang/String;Ljava/util/List;Ljava/util/Map;)V"))
+            target = "Lnet/minecraft/client/resources/language/ClientLanguage;appendFrom(Ljava/lang/String;Ljava/util/List;Ljava/util/Map;Ljava/util/Map;)V"))
     private static void collectResources(String languageName, List<Resource> resources,
-                                              Map<String, String> destinationMap, Operation<Void> original,
+                                              Map<String, String> destinationMap,
+                                              Map<String, net.minecraft.network.chat.Component> componentMap,
+                                              Operation<Void> original,
                                               @Share("usedResources") LocalRef<List<Resource>> usedResources) {
         List<Resource> collected = usedResources.get();
         if (collected == null) {
             collected = new ArrayList<>();
             usedResources.set(collected);
         }
         collected.addAll(resources);
-        original.call(languageName, resources, destinationMap);
+        original.call(languageName, resources, destinationMap, componentMap);
     }
 
     /**
      * @author embeddedt
      * @reason figure out which keys are dynamically loaded and which are injected by mixins
      */
-    @ModifyArg(method = "loadFrom", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/resources/language/ClientLanguage;<init>(Ljava/util/Map;Z)V"), index = 0)
+    @ModifyArg(method = "loadFrom", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/resources/language/ClientLanguage;<init>(Ljava/util/Map;ZLjava/util/Map;)V"), index = 0)
     private static Map<String, String> modifyLanguageMap(Map<String, String> storage, @Share("usedResources") LocalRef<List<Resource>> usedResources) {
         List<Resource> collected = Objects.requireNonNullElse(usedResources.get(), List.of());
         return DynamicLanguageMap.forVanillaData(storage, collected);
     }
-}
+}
diff --git a/src/main/java/org/embeddedt/modernfix/common/mixin/perf/dynamic_resources/MixinModelManager.java b/src/main/java/org/embeddedt/modernfix/common/mixin/perf/dynamic_resources/MixinModelManager.java
@@ -22,6 +22,7 @@
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
 import java.util.Map;
+import java.util.Objects;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
 import java.util.function.Function;
@@ -67,6 +68,7 @@ private static Object2IntMap<BlockState> buildModelGroups(BlockColors blockColor
     @Overwrite
     private static Map<BlockState, BlockStateModel> createBlockStateToModelDispatch(Map<BlockState, BlockStateModel> blockStateModels, BlockStateModel missingModel) {
         BlockStateModelMap.resetCache();
+        Objects.requireNonNull(missingModel);
         return new BlockStateModelMap(blockStateModels, missingModel);
     }
 }
diff --git a/src/main/java/org/embeddedt/modernfix/core/config/ModernFixEarlyConfig.java b/src/main/java/org/embeddedt/modernfix/core/config/ModernFixEarlyConfig.java
@@ -235,7 +235,7 @@ private ModernFixEarlyConfig(File file) {
         disableIfModPresent("mixin.bugfix.paper_chunk_patches", "c2me");
         disableIfModPresent("mixin.bugfix.preserve_early_window_pos", "better_loading_screen");
         disableIfModPresent("mixin.perf.dynamic_dfu", "litematica");
-        disableIfModPresent("mixin.perf.cache_strongholds", "littletiles", "c2me");
+        disableIfModPresent("mixin.perf.cache_strongholds", "littletiles", "c2me", "flashback");
         // content overlap
         disableIfModPresent("mixin.perf.deduplicate_wall_shapes", "dashloader");
         disableIfModPresent("mixin.perf.nbt_memory_usage", "c2me");
diff --git a/src/main/java/org/embeddedt/modernfix/dynresources/BlockStateModelMap.java b/src/main/java/org/embeddedt/modernfix/dynresources/BlockStateModelMap.java
@@ -9,6 +9,7 @@
 
 import java.util.Collection;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 
 /**
@@ -18,6 +19,10 @@
 public record BlockStateModelMap(Map<BlockState, BlockStateModel> modelMap,
                                  BlockStateModel fallbackModel) implements Map<BlockState, BlockStateModel> {
 
+    public BlockStateModelMap {
+        Objects.requireNonNull(fallbackModel);
+    }
+
     @Override
     public int size() {
         return Block.BLOCK_STATE_REGISTRY.size();
@@ -55,6 +60,12 @@ public BlockStateModel get(Object o) {
         }
     }
 
+    @Override
+    public BlockStateModel getOrDefault(Object key, BlockStateModel defaultValue) {
+        var value = get(key);
+        return value != fallbackModel ? value : defaultValue;
+    }
+
     @Override
     public @Nullable BlockStateModel put(BlockState blockState, BlockStateModel blockStateModel) {
         var oldModel = modelMap.put(blockState, blockStateModel);
@@ -102,4 +113,4 @@ public static void resetCache() {
             ((IModelHoldingBlockState) state).mfix$setModel(null);
         }
     }
-}
+}
diff --git a/src/main/java/org/embeddedt/modernfix/dynresources/DynamicModelSystem.java b/src/main/java/org/embeddedt/modernfix/dynresources/DynamicModelSystem.java
@@ -4,27 +4,24 @@
 import com.google.common.cache.CacheLoader;
 import com.google.common.cache.LoadingCache;
 import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
 import it.unimi.dsi.fastutil.objects.AbstractObject2IntMap;
 import it.unimi.dsi.fastutil.objects.Object2IntMap;
 import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
 import it.unimi.dsi.fastutil.objects.ObjectSet;
 import it.unimi.dsi.fastutil.objects.ObjectSets;
-import it.unimi.dsi.fastutil.objects.ReferenceSets;
 import net.fabricmc.fabric.impl.client.model.loading.UnbakedModelDeserializerRegistry;
 import net.minecraft.client.color.block.BlockColors;
 import net.minecraft.client.renderer.item.ClientItem;
-import net.minecraft.client.renderer.block.dispatch.BlockStateModel;
-import net.minecraft.client.resources.model.cuboid.ItemModelGenerator;
 import net.minecraft.client.resources.model.BlockStateModelLoader;
 import net.minecraft.client.resources.model.ClientItemInfoLoader;
-import net.minecraft.client.resources.model.cuboid.MissingCuboidModel;
 import net.minecraft.client.resources.model.ModelDiscovery;
 import net.minecraft.client.resources.model.ModelManager;
 import net.minecraft.client.resources.model.ResolvedModel;
 import net.minecraft.client.resources.model.UnbakedModel;
-import net.minecraft.resources.FileToIdConverter;
+import net.minecraft.client.resources.model.cuboid.ItemModelGenerator;
+import net.minecraft.client.resources.model.cuboid.MissingCuboidModel;
 import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.resources.FileToIdConverter;
 import net.minecraft.resources.Identifier;
 import net.minecraft.server.packs.resources.Resource;
 import net.minecraft.world.level.block.Block;
@@ -40,6 +37,8 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
 import java.util.Set;
 import java.util.function.BiFunction;
 import java.util.function.Function;
@@ -51,46 +50,77 @@ public class DynamicModelSystem {
     private static final FileToIdConverter ITEM_LISTER = FileToIdConverter.json("items");
 
     public static final boolean DEBUG_DYNAMIC_MODEL_LOADING = Boolean.getBoolean("modernfix.debugDynamicModelLoading");
-    
-    public static Map<Identifier, UnbakedModel> createDynamicUnbakedModelMap(Map<Identifier, Resource> resourceMap) {
-        LoadingCache<Identifier, UnbakedModel> unbakedModelCache = CacheBuilder.newBuilder().softValues().maximumSize(1000).build(new CacheLoader<>() {
+
+    private interface ResultLoader<RESOURCE, RESULT> {
+        RESULT load(Identifier file, @Nullable RESOURCE resource) throws Exception;
+    }
+
+    private static <RESOURCE, RESULT> Map<Identifier, RESULT> createCachedResourceBackedMap(Map<Identifier, RESOURCE> resourceMap,
+            FileToIdConverter converter,
+            String debugName,
+            ResultLoader<RESOURCE, RESULT> loader) {
+        LoadingCache<Identifier, Optional<RESULT>> resultCache = CacheBuilder.newBuilder().softValues().maximumSize(1000).build(new CacheLoader<>() {
             @Override
-            public UnbakedModel load(Identifier key) throws Exception {
-                var resource = resourceMap.get(MODEL_LISTER.idToFile(key));
+            public Optional<RESULT> load(Identifier id) throws Exception {
+                var file = converter.idToFile(id);
+                var resource = resourceMap.get(file);
                 if (resource == null) {
-                    throw new IllegalArgumentException("Model " + key + " does not exist in map");
+                    return Optional.empty();
                 }
                 if (DEBUG_DYNAMIC_MODEL_LOADING) {
-                    ModernFix.LOGGER.info("Loading unbaked model {}", key);
-                }
-                try (Reader reader = resource.openAsReader()) {
-                    return UnbakedModelDeserializerRegistry.deserialize(reader);
+                    ModernFix.LOGGER.info("Loading {} {}", debugName, id);
                 }
+                return Optional.of(loader.load(file, resource));
+            }
+        });
+        Set<Identifier> idSet = resourceMap.keySet().stream().map(converter::fileToId).collect(Collectors.toUnmodifiableSet());
+        return new DynamicRegistryMap<>(idSet, key -> {
+            if (key == null) {
+                return null;
+            }
+            try {
+                return resultCache.getUnchecked(key).orElse(null);
+            } catch (RuntimeException e) {
+                ModernFix.LOGGER.error("Error loading {} {} from cache", debugName, key);
+                throw e;
+            }
+        });
+    }
+
+    public static Map<Identifier, UnbakedModel> createDynamicUnbakedModelMap(Map<Identifier, Resource> resourceMap) {
+        return createCachedResourceBackedMap(resourceMap, MODEL_LISTER, "unbaked model", (id, resource) -> {
+            Objects.requireNonNull(resource, "unbaked model not present");
+            try (Reader reader = resource.openAsReader()) {
+                return UnbakedModelDeserializerRegistry.deserialize(reader);
             }
         });
-        Set<Identifier> unbakedIdSet = resourceMap.keySet().stream().map(MODEL_LISTER::fileToId).collect(Collectors.toUnmodifiableSet());
-        return Maps.asMap(unbakedIdSet, key -> key != null ? unbakedModelCache.getUnchecked(key) : null);
     }
 
     public interface SingleBlockStateEntryLoader {
         BlockStateModelLoader.LoadedModels loadEntry(Identifier identifier, List<Resource> blockstateResources);
     }
 
-    private static Set<BlockState> getAllBlockStates() {
-        return ((IdMapperAccessor<BlockState>) Block.BLOCK_STATE_REGISTRY).getReferenceMap().keySet();
-    }
-    public static BlockStateModelLoader.LoadedModels createDynamicBlockStateLoadedModels(Map<Identifier, List<Resource>> resourceMap, SingleBlockStateEntryLoader entryLoader) {
-        LoadingCache<Identifier, BlockStateModelLoader.LoadedModels> definitionCache = CacheBuilder.newBuilder().softValues().maximumSize(1000).build(new CacheLoader<>() {
+    public static Set<BlockState> getAllBlockStates() {
+        var blockStateSet = ((IdMapperAccessor<BlockState>) Block.BLOCK_STATE_REGISTRY).getReferenceMap().keySet();
+        return new AbstractSet<>() {
             @Override
-            public BlockStateModelLoader.LoadedModels load(Identifier key) throws Exception {
-                if (DEBUG_DYNAMIC_MODEL_LOADING) {
-                    ModernFix.LOGGER.info("Loading blockstate definition for {}", key);
-                }
-                var file = BLOCKSTATE_LISTER.idToFile(key);
-                var resources = resourceMap.getOrDefault(file, List.of());
-                return entryLoader.loadEntry(file, resources);
+            public Iterator<BlockState> iterator() {
+                // We explicitly override iterator() and handle it differently so that mods iterating the maps
+                // are likely to work with the same block many times in a row, which hits our caches better
+                return BuiltInRegistries.BLOCK.stream().flatMap(b -> b.getStateDefinition().getPossibleStates().stream()).iterator();
             }
-        });
+            @Override
+            public boolean contains(Object o) {
+                return blockStateSet.contains(o);
+            }
+            @Override
+            public int size() {
+                return blockStateSet.size();
+            }
+        };
+    }
+    public static BlockStateModelLoader.LoadedModels createDynamicBlockStateLoadedModels(Map<Identifier, List<Resource>> resourceMap, SingleBlockStateEntryLoader entryLoader) {
+        var blockStateDefinitions = createCachedResourceBackedMap(resourceMap, BLOCKSTATE_LISTER, "blockstate definition", entryLoader::loadEntry);
         var staticDefinitions = BlockStateDefinitionsAccessor.getStaticDefinitions();
         var staticIdentifiers = staticDefinitions.entrySet()
                 .stream()
@@ -102,8 +132,12 @@ public BlockStateModelLoader.LoadedModels load(Identifier key) throws Exception
             if (identifier == null) {
                 identifier = BuiltInRegistries.BLOCK.getKey(state.getBlock());
             }
-            var loadedModels = definitionCache.getUnchecked(identifier);
-            return loadedModels.models().get(state);
+            var loadedModels = blockStateDefinitions.get(identifier);
+            if (loadedModels != null) {
+                return loadedModels.models().get(state);
+            } else {
+                return null;
+            }
         }));
     }
 
@@ -112,34 +146,8 @@ public interface SingleClientItemEntryLoader {
     }
 
     public static ClientItemInfoLoader.LoadedClientInfos createDynamicClientInfos(Map<Identifier, Resource> resourceMap, SingleClientItemEntryLoader entryLoader) {
-        Set<Identifier> itemIdSet = resourceMap.keySet().stream().map(ITEM_LISTER::fileToId).collect(Collectors.toUnmodifiableSet());
-        LoadingCache<Identifier, Object> clientItemCache = CacheBuilder.newBuilder().softValues().maximumSize(1000).build(new CacheLoader<>() {
-            @Override
-            public Object load(Identifier key) {
-                Identifier fileId = ITEM_LISTER.idToFile(key);
-                Resource resource = resourceMap.get(fileId);
-                if (resource == null) {
-                    return NULL_SENTINEL;
-                }
-                if (DEBUG_DYNAMIC_MODEL_LOADING) {
-                    ModernFix.LOGGER.info("Loading client item info {}", key);
-                }
-                try {
-                    ClientItem result = entryLoader.loadEntry(fileId, resource);
-                    return result != null ? result : NULL_SENTINEL;
-                } catch (RuntimeException e) {
-                    ModernFix.LOGGER.warn("Failed to build dynamic client item info for {}", key, e);
-                    return NULL_SENTINEL;
-                }
-            }
-        });
-        return new ClientItemInfoLoader.LoadedClientInfos(Maps.asMap(itemIdSet, key -> {
-            if (key == null) {
-                return null;
-            }
-            Object value = clientItemCache.getUnchecked(key);
-            return value == NULL_SENTINEL ? null : (ClientItem) value;
-        }));
+        var clientItems = createCachedResourceBackedMap(resourceMap, ITEM_LISTER, "client item info", entryLoader::loadEntry);
+        return new ClientItemInfoLoader.LoadedClientInfos(clientItems);
     }
 
     public record DynamicResolver(Map<Identifier, UnbakedModel> inputModels,
@@ -205,28 +213,32 @@ public int getInt(Object key) {
         }
     }
 
-    private static final Object NULL_SENTINEL = new Object();
+    private static final Object NULL_BAKED = new Object();
 
     public static <K, U, V> Map<K, V> createDynamicBakedRegistry(Map<K, U> input, BiFunction<K, U, V> baker) {
         // TODO: support persistence of overrides
         LoadingCache<K, Object> bakedCache = CacheBuilder.newBuilder().softValues().maximumSize(1000).build(new CacheLoader<>() {
             @Override
             public Object load(K key) throws Exception {
                 var unbaked = input.get(key);
-                if (unbaked != null) {
-                    if (DEBUG_DYNAMIC_MODEL_LOADING) {
-                        ModernFix.LOGGER.info("Baking {}", key);
-                    }
-                    return baker.apply(key, unbaked);
-                } else {
-                    return NULL_SENTINEL;
+                if (unbaked == null) {
+                    return NULL_BAKED;
+                }
+                if (DEBUG_DYNAMIC_MODEL_LOADING) {
+                    ModernFix.LOGGER.info("Baking {}", key);
+                }
+                var bakerResult = baker.apply(key, unbaked);
+                if (bakerResult == null) {
+                    ModernFix.LOGGER.warn("Baker has returned null for {}", key);
+                    return NULL_BAKED;
                 }
+                return bakerResult;
             }
         });
         return new DynamicRegistryMap<>(input.keySet(), k -> {
             if (k != null) {
                 Object value = bakedCache.getUnchecked(k);
-                if (value == NULL_SENTINEL) {
+                if (value == NULL_BAKED) {
                     value = null;
                 }
                 return (V) value;
@@ -235,4 +247,4 @@ public Object load(K key) throws Exception {
             }
         });
     }
-}
+}
diff --git a/src/main/java/org/embeddedt/modernfix/dynresources/DynamicRegistryMap.java b/src/main/java/org/embeddedt/modernfix/dynresources/DynamicRegistryMap.java

Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@`
`15`	`15`	`import org.embeddedt.modernfix.util.ClassInfoManager;`
`16`	`16`	`import org.spongepowered.asm.mixin.MixinEnvironment;`
`17`	`17`
	`18`	`+import net.minecraft.client.Minecraft;`
`18`	`19`	`import java.lang.management.ManagementFactory;`
`19`	`20`
`20`	`21`	`// The value here should match an entry in the META-INF/mods.toml file`
`@@ -51,6 +52,8 @@ public static void runAuditIfRequested() {`
`51`	`52`	`if (auditAndExit \|\| Boolean.getBoolean("modernfix.auditMixinsAtStart")) {`
`52`	`53`	`MixinEnvironment.getCurrentEnvironment().audit();`
`53`	`54`	`if (auditAndExit) {`
	`55`	`+ // Prevents Crash Assistant from treating mixin audit as a crash`
	`56`	`+ Minecraft.getInstance().stop();`
`54`	`57`	`System.exit(0);`
`55`	`58`	`}`
`56`	`59`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@`
`22`	`22`	`import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;`
`23`	`23`
`24`	`24`	`import java.util.Map;`
	`25`	`+import java.util.Objects;`
`25`	`26`	`import java.util.concurrent.CompletableFuture;`
`26`	`27`	`import java.util.concurrent.CompletionStage;`
`27`	`28`	`import java.util.function.Function;`
`@@ -67,6 +68,7 @@ private static Object2IntMap<BlockState> buildModelGroups(BlockColors blockColor`
`67`	`68`	`@Overwrite`
`68`	`69`	`private static Map<BlockState, BlockStateModel> createBlockStateToModelDispatch(Map<BlockState, BlockStateModel> blockStateModels, BlockStateModel missingModel) {`
`69`	`70`	`BlockStateModelMap.resetCache();`
	`71`	`+ Objects.requireNonNull(missingModel);`
`70`	`72`	`return new BlockStateModelMap(blockStateModels, missingModel);`
`71`	`73`	`}`
`72`	`74`	`}`