Merge remote-tracking branch 'origin/1.18' into 1.19.2

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/dynamic_entity_renderers/EntityRenderDispatcherMixin.java

@@ -0,0 +1,38 @@
+package org.embeddedt.modernfix.common.mixin.perf.dynamic_entity_renderers;
+
+import net.minecraft.client.renderer.entity.EntityRenderDispatcher;
+import net.minecraft.client.renderer.entity.EntityRenderer;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.EntityType;
+import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
+import org.embeddedt.modernfix.entity.EntityRendererMap;
+import org.objectweb.asm.Opcodes;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import java.util.Map;
+
+@Mixin(EntityRenderDispatcher.class)
+@ClientOnlyMixin
+public class EntityRenderDispatcherMixin {
+    @Shadow private Map<EntityType<?>, EntityRenderer<?>> renderers;
+
+    private EntityRendererMap mfix$dynamicRenderers;
+
+    @Inject(method = "getRenderer", at = @At("RETURN"), cancellable = true)
+    private <T extends Entity> void checkNullness(T entity, CallbackInfoReturnable<EntityRenderer<? super T>> cir) {
+        // apparently some mods yeet the renderers map and cause issues
+        if(cir.getReturnValue() == null)
+            cir.setReturnValue((EntityRenderer<? super T>)mfix$dynamicRenderers.get(entity.getType()));
+    }
+
+    @Redirect(method = "onResourceManagerReload", at = @At(value = "FIELD", opcode = Opcodes.PUTFIELD, target = "Lnet/minecraft/client/renderer/entity/EntityRenderDispatcher;renderers:Ljava/util/Map;"))
+    private void setRendererField(EntityRenderDispatcher instance, Map<EntityType<?>, EntityRenderer<?>> incomingMap) {
+        this.renderers = incomingMap;
+        this.mfix$dynamicRenderers = (EntityRendererMap)incomingMap;
+    }
+}

common/src/main/java/org/embeddedt/modernfix/common/mixin/perf/dynamic_entity_renderers/EntityRenderersMixin.java

@@ -1,18 +1,12 @@
 package org.embeddedt.modernfix.common.mixin.perf.dynamic_entity_renderers;
 
-import com.google.common.cache.CacheBuilder;
-import com.google.common.cache.CacheLoader;
-import com.google.common.cache.LoadingCache;
 import net.minecraft.client.renderer.entity.EntityRenderer;
 import net.minecraft.client.renderer.entity.EntityRendererProvider;
 import net.minecraft.client.renderer.entity.EntityRenderers;
-import net.minecraft.core.Registry;
 import net.minecraft.world.entity.EntityType;
 import org.embeddedt.modernfix.ModernFix;
 import org.embeddedt.modernfix.annotation.ClientOnlyMixin;
-import org.embeddedt.modernfix.entity.ErroredEntityRenderer;
+import org.embeddedt.modernfix.entity.EntityRendererMap;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -20,10 +14,7 @@ import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
-import java.util.Collection;
 import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.ExecutionException;
 
 @Mixin(EntityRenderers.class)
 @ClientOnlyMixin
@@ -32,99 +23,7 @@ public class EntityRenderersMixin {
 
     @Inject(method = "createEntityRenderers", at = @At("HEAD"), cancellable = true)
     private static void createDynamicRendererLoader(EntityRendererProvider.Context context, CallbackInfoReturnable<Map<EntityType<?>, EntityRenderer<?>>> cir) {
-        Map<EntityType<?>, EntityRendererProvider<?>> rendererProviders = PROVIDERS;
+        cir.setReturnValue(new EntityRendererMap(PROVIDERS, context));
-        LoadingCache<EntityType<?>, EntityRenderer<?>> rendererMap = CacheBuilder.newBuilder()
+        ModernFix.LOGGER.info("Dynamic entity renderer hook setup");
-                .build(new CacheLoader<>() {
-                    @Override
-                    public EntityRenderer<?> load(EntityType<?> key) throws Exception {
-                        EntityRendererProvider<?> provider = rendererProviders.get(key);
-                        synchronized(EntityRenderers.class) {
-                            EntityRenderer<?> renderer;
-                            try {
-                                if(provider == null)
-                                    throw new RuntimeException("Provider not registered");
-                                renderer = provider.create(context);
-                                ModernFix.LOGGER.info("Loaded entity {}", Registry.ENTITY_TYPE.getKey(key));
-                            } catch(RuntimeException e) {
-                                ModernFix.LOGGER.error("Failed to create entity model for " + Registry.ENTITY_TYPE.getKey(key) + ":", e);
-                                renderer = new ErroredEntityRenderer<>(context);
-                            }
-                            return renderer;
-                        }
-                    }
-                });
-        cir.setReturnValue(new Map<EntityType<?>, EntityRenderer<?>>() {
-            @Override
-            public int size() {
-                return rendererProviders.size();
-            }
-
-            @Override
-            public boolean isEmpty() {
-                return rendererProviders.isEmpty();
-            }
-
-            @Override
-            public boolean containsKey(Object o) {
-                return rendererProviders.containsKey(o);
-            }
-
-            @Override
-            public boolean containsValue(Object o) {
-                return false;
-            }
-
-            @Override
-            public EntityRenderer<?> get(Object o) {
-                try {
-                    return rendererMap.get((EntityType<?>)o);
-                } catch(ExecutionException e) {
-                    throw new RuntimeException(e);
-                }
-            }
-
-            @Nullable
-            @Override
-            public EntityRenderer<?> put(EntityType<?> entityType, EntityRenderer<?> entityRenderer) {
-                EntityRenderer<?> old = rendererMap.getIfPresent(entityType);
-                rendererMap.put(entityType, entityRenderer);
-                return old;
-            }
-
-            @Override
-            public EntityRenderer<?> remove(Object o) {
-                EntityRenderer<?> r = rendererMap.getIfPresent(o);
-                rendererMap.invalidate(o);
-                return r;
-            }
-
-            @Override
-            public void putAll(@NotNull Map<? extends EntityType<?>, ? extends EntityRenderer<?>> map) {
-                rendererMap.putAll(map);
-            }
-
-            @Override
-            public void clear() {
-                rendererMap.invalidateAll();
-            }
-
-            @NotNull
-            @Override
-            public Set<EntityType<?>> keySet() {
-                return rendererProviders.keySet();
-            }
-
-            @NotNull
-            @Override
-            public Collection<EntityRenderer<?>> values() {
-                return rendererMap.asMap().values();
-            }
-
-            @NotNull
-            @Override
-            public Set<Entry<EntityType<?>, EntityRenderer<?>>> entrySet() {
-                return rendererMap.asMap().entrySet();
-            }
-        });
     }
 }

common/src/main/java/org/embeddedt/modernfix/entity/EntityRendererMap.java

@@ -0,0 +1,125 @@
+package org.embeddedt.modernfix.entity;
+
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+import net.minecraft.client.renderer.entity.EntityRenderer;
+import net.minecraft.client.renderer.entity.EntityRendererProvider;
+import net.minecraft.client.renderer.entity.EntityRenderers;
+import net.minecraft.core.Registry;
+import net.minecraft.world.entity.EntityType;
+import org.embeddedt.modernfix.ModernFix;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+
+public class EntityRendererMap implements Map<EntityType<?>, EntityRenderer<?>> {
+    private final Map<EntityType<?>, EntityRendererProvider<?>> rendererProviders;
+    private final LoadingCache<EntityType<?>, EntityRenderer<?>> rendererMap;
+    private final EntityRendererProvider.Context context;
+
+    public EntityRendererMap(Map<EntityType<?>, EntityRendererProvider<?>> rendererProviders, EntityRendererProvider.Context context) {
+        this.rendererProviders = rendererProviders;
+        this.context = context;
+        this.rendererMap = CacheBuilder.newBuilder().build(new RenderConstructor());
+    }
+
+    class RenderConstructor extends CacheLoader<EntityType<?>, EntityRenderer<?>> {
+        @Override
+        public EntityRenderer<?> load(EntityType<?> key) throws Exception {
+            EntityRendererProvider<?> provider = rendererProviders.get(key);
+            synchronized(EntityRenderers.class) {
+                EntityRenderer<?> renderer;
+                try {
+                    if(provider == null)
+                        throw new RuntimeException("Provider not registered");
+                    renderer = provider.create(context);
+                    ModernFix.LOGGER.info("Loaded entity {}", Registry.ENTITY_TYPE.getKey(key));
+                } catch(RuntimeException e) {
+                    ModernFix.LOGGER.error("Failed to create entity model for " + Registry.ENTITY_TYPE.getKey(key) + ":", e);
+                    renderer = new ErroredEntityRenderer<>(context);
+                }
+                return renderer;
+            }
+        }
+    }
+
+    @Override
+    public int size() {
+        return rendererProviders.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return rendererProviders.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object o) {
+        return rendererProviders.containsKey(o);
+    }
+
+    @Override
+    public boolean containsValue(Object o) {
+        return false;
+    }
+
+    @Override
+    public EntityRenderer<?> get(Object o) {
+        try {
+            EntityRenderer<?> renderer = rendererMap.get((EntityType<?>)o);
+            if(renderer == null)
+                throw new AssertionError("Returned entity renderer should never be null");
+            return renderer;
+        } catch(ExecutionException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Nullable
+    @Override
+    public EntityRenderer<?> put(EntityType<?> entityType, EntityRenderer<?> entityRenderer) {
+        EntityRenderer<?> old = rendererMap.getIfPresent(entityType);
+        rendererMap.put(entityType, entityRenderer);
+        return old;
+    }
+
+    @Override
+    public EntityRenderer<?> remove(Object o) {
+        EntityRenderer<?> r = rendererMap.getIfPresent(o);
+        rendererMap.invalidate(o);
+        return r;
+    }
+
+    @Override
+    public void putAll(@NotNull Map<? extends EntityType<?>, ? extends EntityRenderer<?>> map) {
+        rendererMap.putAll(map);
+    }
+
+    @Override
+    public void clear() {
+        rendererMap.invalidateAll();
+    }
+
+    @NotNull
+    @Override
+    public Set<EntityType<?>> keySet() {
+        return rendererProviders.keySet();
+    }
+
+    @NotNull
+    @Override
+    public Collection<EntityRenderer<?>> values() {
+        return rendererMap.asMap().values();
+    }
+
+    @NotNull
+    @Override
+    public Set<Map.Entry<EntityType<?>, EntityRenderer<?>>> entrySet() {
+        return rendererMap.asMap().entrySet();
+    }
+}

forge/src/main/java/org/embeddedt/modernfix/forge/mixin/perf/resourcepacks/ModFileResourcePackMixin.java

@@ -55,6 +55,7 @@ public abstract class ModFileResourcePackMixin {
 
     @Inject(method = "hasResource(Ljava/lang/String;)Z", at = @At(value = "HEAD"), cancellable = true)
     private void useCacheForExistence(String path, CallbackInfoReturnable<Boolean> cir) {
+        this.generateResourceCache();
         if(cacheEngine != null)
             cir.setReturnValue(this.cacheEngine.hasResource(path));
     }