Merge remote-tracking branch 'origin/1.19.4' into 1.20

Author: embeddedt

common/build.gradle

@@ -25,6 +25,9 @@ dependencies {
     modCompileOnly("me.shedaniel:RoughlyEnoughItems-fabric:${rei_version}") {
         transitive = false
     }
+
+    modCompileOnly("curse.maven:diagonal-fences-458048:${diagonal_fences_version}")
+
     // compile against the JEI API but do not include it at runtime
     modCompileOnly("mezz.jei:jei-${jei_minecraft_version}-common:${jei_version}")
     modCompileOnly("mezz.jei:jei-${jei_minecraft_version}-gui:${jei_version}")

common/src/main/java/org/embeddedt/modernfix/ModernFix.java

@@ -1,5 +1,6 @@
 package org.embeddedt.modernfix;
 
+import net.minecraft.SharedConstants;
 import net.minecraft.Util;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.level.ChunkMap;
@@ -11,6 +12,7 @@
 import org.embeddedt.modernfix.platform.ModernFixPlatformHooks;
 import org.embeddedt.modernfix.resources.ReloadExecutor;
 import org.embeddedt.modernfix.util.ClassInfoManager;
+import org.embeddedt.modernfix.world.IntegratedWatchdog;
 
 import java.lang.management.ManagementFactory;
 import java.util.concurrent.ExecutorService;
@@ -23,6 +25,8 @@ public class ModernFix {
 
     public static final String MODID = "modernfix";
 
+    public static String NAME = "ModernFix";
+
     public static ModernFix INSTANCE;
 
     // Used to skip computing the blockstate caches twice
@@ -45,7 +49,22 @@ public static ExecutorService resourceReloadExecutor() {
 
     public ModernFix() {
         INSTANCE = this;
+        if(ModernFixMixinPlugin.instance.isOptionEnabled("feature.snapshot_easter_egg.NameChange") && !SharedConstants.getCurrentVersion().isStable())
+            NAME = "PreemptiveFix";
         ModernFixPlatformHooks.onServerCommandRegister(ModernFixCommands::register);
+        if(ModernFixMixinPlugin.instance.isOptionEnabled("feature.spam_thread_dump.ThreadDumper")) {
+            Thread t = new Thread() {
+                public void run() {
+                    while(true) {
+                        LOGGER.error("------ DEBUG THREAD DUMP (occurs every 60 seconds) ------");
+                        LOGGER.error(IntegratedWatchdog.obtainThreadDump());
+                        try { Thread.sleep(60000); } catch(InterruptedException e) {}
+                    }
+                }
+            };
+            t.setDaemon(true);
+            t.start();
+        }
     }
 
     public void onServerStarted() {

common/src/main/java/org/embeddedt/modernfix/ModernFixClient.java

@@ -11,6 +11,8 @@
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.util.MemoryReserve;
 import net.minecraft.world.entity.Entity;
+import org.embeddedt.modernfix.api.constants.IntegrationConstants;
+import org.embeddedt.modernfix.api.entrypoint.ModernFixClientIntegration;
 import org.embeddedt.modernfix.core.ModernFixMixinPlugin;
 import org.embeddedt.modernfix.packet.EntityIDSyncPacket;
 import org.embeddedt.modernfix.platform.ModernFixPlatformHooks;
@@ -22,6 +24,7 @@
 import java.lang.management.ManagementFactory;
 import java.lang.reflect.Field;
 import java.util.*;
+import java.util.concurrent.CopyOnWriteArrayList;
 
 public class ModernFixClient {
     public static long worldLoadStartTime;
@@ -33,14 +36,26 @@ public class ModernFixClient {
 
     public String brandingString = null;
 
+    /**
+     * The list of loaded client integrations.
+     */
+    public static List<ModernFixClientIntegration> CLIENT_INTEGRATIONS = new CopyOnWriteArrayList<>();
+
     public ModernFixClient() {
         // clear reserve as it's not needed
         MemoryReserve.release();
         if(ModernFixMixinPlugin.instance.isOptionEnabled("feature.branding.F3Screen")) {
-            brandingString = "ModernFix " + ModernFixPlatformHooks.getVersionString();
+            brandingString = ModernFix.NAME + " " + ModernFixPlatformHooks.getVersionString();
         }
         SearchTreeProviderRegistry.register(JEIBackedSearchTree.PROVIDER);
         SearchTreeProviderRegistry.register(REIBackedSearchTree.PROVIDER);
+        for(String className : ModernFixPlatformHooks.getCustomModOptions().get(IntegrationConstants.CLIENT_INTEGRATION_CLASS)) {
+            try {
+                CLIENT_INTEGRATIONS.add((ModernFixClientIntegration)Class.forName(className).getDeclaredConstructor().newInstance());
+            } catch(ReflectiveOperationException | ClassCastException e) {
+                ModernFix.LOGGER.error("Could not instantiate integration {}", className, e);
+            }
+        }
     }
 
     public void resetWorldLoadStateMachine() {

common/src/main/java/org/embeddedt/modernfix/api/constants/IntegrationConstants.java

@@ -0,0 +1,8 @@
+package org.embeddedt.modernfix.api.constants;
+
+public class IntegrationConstants {
+    public static final String INTEGRATIONS_KEY = "modernfix:integration";
+
+    public static final String CLIENT_INTEGRATION_CLASS = "client_entrypoint";
+    public static final String INTEGRATION_CLASS = "entrypoint";
+}

common/src/main/java/org/embeddedt/modernfix/api/entrypoint/ModernFixClientIntegration.java

@@ -0,0 +1,62 @@
+package org.embeddedt.modernfix.api.entrypoint;
+
+import net.minecraft.client.resources.model.BakedModel;
+import net.minecraft.client.resources.model.ModelBakery;
+import net.minecraft.client.resources.model.ModelState;
+import net.minecraft.client.resources.model.UnbakedModel;
+import net.minecraft.resources.ResourceLocation;
+
+
+/**
+ * Implement this interface in a mod class and add it to "modernfix:integration_v1" in your mod metadata file
+ * to integrate with ModernFix's features.
+ */
+public interface ModernFixClientIntegration {
+    /**
+     * Called when the dynamic resources status has changed during a model reload so mods know whether to run their
+     * normal codepath or the dynamic version.
+     *
+     * @param enabled whether dynamic resources is enabled
+     */
+    default void onDynamicResourcesStatusChange(boolean enabled) {
+    }
+
+    /**
+     * Called to allow mods to observe the loading of an unbaked model and either make changes to it or wrap it with their
+     * own instance.
+     * @param location the ResourceLocation of the model (this may be a ModelResourceLocation)
+     * @param originalModel the original model
+     * @param bakery the model bakery - do not touch internal fields as they probably don't behave the way you expect
+     * with dynamic resources on
+     * @return the model which should actually be loaded for this resource location
+     */
+    default UnbakedModel onUnbakedModelLoad(ResourceLocation location, UnbakedModel originalModel, ModelBakery bakery) {
+        return originalModel;
+    }
+
+    /**
+     * Called to allow mods to observe the use of an unbaked model at bake time and either make changes to it or wrap it with their
+     * own instance.
+     * @param location the ResourceLocation of the model (this may be a ModelResourceLocation)
+     * @param originalModel the original model
+     * @param bakery the model bakery - do not touch internal fields as they probably don't behave the way you expect
+     * with dynamic resources on
+     * @return the model which should actually be loaded for this resource location
+     */
+    default UnbakedModel onUnbakedModelPreBake(ResourceLocation location, UnbakedModel originalModel, ModelBakery bakery) {
+        return originalModel;
+    }
+
+    /**
+     * Called to allow mods to observe the loading of a baked model and either make changes to it or wrap it with their
+     * own instance.
+     * @param location the ResourceLocation of the model (this may be a ModelResourceLocation)
+     * @param originalModel the original model
+     * @param bakery the model bakery - do not touch internal fields as they probably don't behave the way you expect
+     * with dynamic resources on
+     * @return the model which should actually be loaded for this resource location
+     */
+    default BakedModel onBakedModelLoad(ResourceLocation location, UnbakedModel baseModel, BakedModel originalModel, ModelState state, ModelBakery bakery) {
+        return originalModel;
+    }
+}

common/src/main/java/org/embeddedt/modernfix/api/helpers/ModelHelpers.java

@@ -0,0 +1,74 @@
+package org.embeddedt.modernfix.api.helpers;
+
+import com.google.common.collect.ImmutableList;
+import net.minecraft.client.resources.model.*;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.StateDefinition;
+import org.embeddedt.modernfix.duck.IExtendedModelBakery;
+import org.embeddedt.modernfix.dynamicresources.ModelBakeryHelpers;
+import org.embeddedt.modernfix.util.DynamicMap;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.BiFunction;
+
+@SuppressWarnings("unused")
+public final class ModelHelpers {
+    /**
+     * Allows converting a ModelResourceLocation back into the corresponding BlockState(s). Try to avoid calling this
+     * multiple times if possible.
+     * @param location the location of the model
+     * @return a list of all blockstates related to the model
+     */
+    public static ImmutableList<BlockState> getBlockStateForLocation(ModelResourceLocation location) {
+        Optional<Block> blockOpt = BuiltInRegistries.BLOCK.getOptional(new ResourceLocation(location.getNamespace(), location.getPath()));
+        if(blockOpt.isPresent())
+            return ModelBakeryHelpers.getBlockStatesForMRL(blockOpt.get().getStateDefinition(), location);
+        else
+            return ImmutableList.of();
+    }
+
+    /**
+     * Allows converting a ModelResourceLocation back into the corresponding BlockState(s). Faster version of its
+     * companion function if and only if you know the corresponding Block already for some reason.
+     * @param definition the state definition for the Block
+     * @param location the location of the model
+     * @return a list of all blockstates related to the model
+     */
+    public static ImmutableList<BlockState> getBlockStateForLocation(StateDefinition<Block, BlockState> definition, ModelResourceLocation location) {
+        return ModelBakeryHelpers.getBlockStatesForMRL(definition, location);
+    }
+
+    /**
+     * Compatibility helper for mods to use to get a map-like view of the model bakery.
+     * @param modelGetter the model getter function supplied by the integration class
+     * @return a fake map of the top-level models
+     */
+    public static Map<ResourceLocation, BakedModel> createFakeTopLevelMap(BiFunction<ResourceLocation, ModelState, BakedModel> modelGetter) {
+        return new DynamicMap<>(location -> modelGetter.apply(location, BlockModelRotation.X0_Y0));
+    }
+
+    /**
+     * Provides a ModelBaker for mods to use.
+     * @param bakery the ModelBakery supplied to your integration
+     * @return an appropriate ModelBaker
+     */
+    public static ModelBaker adaptBakery(ModelBakery bakery) {
+        return new ModelBaker() {
+            @Override
+            public UnbakedModel getModel(ResourceLocation resourceLocation) {
+                return bakery.getModel(resourceLocation);
+            }
+
+            @Nullable
+            @Override
+            public BakedModel bake(ResourceLocation resourceLocation, ModelState modelState) {
+                return ((IExtendedModelBakery)bakery).bakeDefault(resourceLocation, modelState);
+            }
+        };
+    }
+}

common/src/main/java/org/embeddedt/modernfix/common/mixin/bugfix/edge_chunk_not_saved/ChunkManagerMixin.java

@@ -1,5 +1,6 @@
 package org.embeddedt.modernfix.common.mixin.perf.blast_search_trees;
 
+import net.minecraft.client.KeyMapping;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.searchtree.SearchRegistry;
 import net.minecraft.world.item.ItemStack;
@@ -8,6 +9,8 @@
 import org.embeddedt.modernfix.platform.ModernFixPlatformHooks;
 import org.embeddedt.modernfix.searchtree.DummySearchTree;
 import org.embeddedt.modernfix.searchtree.SearchTreeProviderRegistry;
+import org.lwjgl.glfw.GLFW;
+import org.lwjgl.glfw.GLFWErrorCallback;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -36,6 +39,14 @@ private void replaceSearchTrees(CallbackInfo ci) {
         this.searchRegistry.register(SearchRegistry.CREATIVE_TAGS, tagSupplier);
         this.searchRegistry.register(SearchRegistry.RECIPE_COLLECTIONS, list -> new DummySearchTree<>());
         ModernFixPlatformHooks.registerCreativeSearchTrees(this.searchRegistry, nameSupplier, tagSupplier, this::populateSearchTree);
+        // grab components for all key mappings in order to prevent them from being loaded off-thread later
+        // this populates the LazyLoadedValues
+        // we also need to suppress GLFW errors to prevent crashes if a key is missing
+        GLFWErrorCallback oldCb = GLFW.glfwSetErrorCallback(null);
+        for(KeyMapping mapping : KeyMapping.ALL.values()) {
+            mapping.getTranslatedKeyMessage();
+        }
+        GLFW.glfwSetErrorCallback(oldCb);
         ci.cancel();
     }
 }

common/src/main/java/org/embeddedt/modernfix/common/mixin/bugfix/packet_leak/ClientPlayNetHandlerMixin.java

@@ -3,6 +3,7 @@
 import net.minecraft.client.renderer.block.BlockModelShaper;
 import net.minecraft.client.resources.model.BakedModel;
 import net.minecraft.client.resources.model.ModelManager;
+import net.minecraft.client.resources.model.ModelResourceLocation;
 import net.minecraft.world.level.block.state.BlockState;
 import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
 import org.embeddedt.modernfix.dynamicresources.ModelLocationCache;
@@ -29,9 +30,14 @@ private void replaceModelMap(CallbackInfo ci) {
         this.modelByStateCache = new DynamicOverridableMap<>(state -> modelManager.getModel(ModelLocationCache.get(state)));
     }
 
+    /**
+     * @author embeddedt
+     * @reason get the model from the dynamic model provider
+     */
     @Overwrite
     public BakedModel getBlockModel(BlockState state) {
-        BakedModel model = modelManager.getModel(ModelLocationCache.get(state));
+        ModelResourceLocation mrl = ModelLocationCache.get(state);
+        BakedModel model = mrl == null ? null : modelManager.getModel(mrl);
         if (model == null) {
             model = modelManager.getMissingModel();
         }