Instantiate entity renderers as needed to save memory

src/main/java/org/embeddedt/modernfix/core/config/ModernFixEarlyConfig.java

@@ -49,6 +49,7 @@ public class ModernFixEarlyConfig {
         this.addMixinRule("perf.reduce_blockstate_cache_rebuilds", true);
         this.addMixinRule("perf.model_optimizations", true);
         this.addMixinRule("perf.dynamic_resources", false);
+        this.addMixinRule("perf.dynamic_entity_renderers", true);
         this.addMixinRule("perf.dedicated_reload_executor", true);
         /* Use a simpler ArrayMap if FerriteCore is using the map intelligently anyway */
         this.addMixinRule("perf.state_definition_construct", modPresent("ferritecore"));

src/main/java/org/embeddedt/modernfix/entity/ErroredEntityRenderer.java

@@ -0,0 +1,30 @@
+package org.embeddedt.modernfix.entity;
+
+import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.renderer.culling.Frustum;
+import net.minecraft.client.renderer.entity.EntityRenderer;
+import net.minecraft.client.renderer.entity.EntityRendererProvider;
+import net.minecraft.client.renderer.texture.TextureAtlas;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.Entity;
+
+public class ErroredEntityRenderer<T extends Entity> extends EntityRenderer<T> {
+    public ErroredEntityRenderer(EntityRendererProvider.Context arg) {
+        super(arg);
+    }
+
+    @Override
+    public ResourceLocation getTextureLocation(T entity) {
+        return TextureAtlas.LOCATION_BLOCKS;
+    }
+
+    @Override
+    public boolean shouldRender(T livingEntity, Frustum camera, double camX, double camY, double camZ) {
+        return false;
+    }
+
+    @Override
+    public void render(T entity, float entityYaw, float partialTick, PoseStack poseStack, MultiBufferSource buffer, int packedLight) {
+    }
+}

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

@@ -0,0 +1,128 @@
+package org.embeddedt.modernfix.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.entity.ErroredEntityRenderer;
+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;
+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)
+public class EntityRenderersMixin {
+    @Shadow @Final private static Map<EntityType<?>, EntityRendererProvider<?>> PROVIDERS;
+
+    @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;
+        LoadingCache<EntityType<?>, EntityRenderer<?>> rendererMap = CacheBuilder.newBuilder()
+                .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();
+            }
+        });
+    }
+}

src/main/resources/modernfix.mixins.json

@@ -58,6 +58,7 @@
     "perf.dynamic_resources.ctm.TextureMetadataHandlerMixin",
     "perf.dynamic_resources.ctm.CTMPackReloadListenerMixin",
     "perf.dynamic_resources.supermartijncore.ClientRegistrationHandlerMixin",
+    "perf.dynamic_entity_renderers.EntityRenderersMixin",
     "perf.model_optimizations.OBJLoaderMixin",
     "perf.model_optimizations.SelectorMixin",
     "perf.model_optimizations.TransformationMatrixMixin",