Fix armour model loading locations and clean up a little bit

src/main/java/com/minelittlepony/api/model/Models.java

@@ -4,15 +4,11 @@ import net.minecraft.item.ItemStack;
 import net.minecraft.item.equipment.EquipmentModel;
 import net.minecraft.util.Util;
 
-import org.jetbrains.annotations.Nullable;
-
 import com.minelittlepony.client.model.AbstractPonyModel;
-import com.minelittlepony.client.model.PlayerModelKey;
 import com.minelittlepony.client.model.armour.*;
 import com.minelittlepony.mson.api.ModelKey;
+import com.minelittlepony.mson.api.MsonModel;
 
-import java.util.*;
-import java.util.function.Consumer;
 import java.util.function.Function;
 
 /**
@@ -23,20 +19,15 @@ public record Models<M extends PonyModel<?>> (
         M body
     ) {
 
-    public Models(PlayerModelKey<? super M> playerModelKey, boolean slimArms, @Nullable Consumer<M> initializer) {
+    public Models(ModelKey<? super M> modelKey, MsonModel.Factory<AbstractPonyModel<?>> armorFactory) {
-        this(Util.memoize(key -> key.createModel(playerModelKey.armorFactory())), playerModelKey.getKey(slimArms).createModel());
+        this(Util.memoize(key -> key.createModel(armorFactory)), modelKey.createModel());
-        if (initializer != null) {
-            initializer.accept(body);
-        }
     }
 
-    public Models(ModelKey<M> key) {
+    public Models(ModelKey<? super M> key) {
         this(Util.memoize(k -> k.createModel()), key.createModel());
     }
 
-    public Optional<AbstractPonyModel<?>> getArmourModel(ItemStack stack, EquipmentModel.LayerType layerType, ArmourVariant variant) {
+    public AbstractPonyModel<?> getArmourModel(ItemStack stack, EquipmentModel.LayerType layerType, ArmourVariant variant) {
-        return ArmorModelRegistry.getModelKey(stack.getItem(), layerType)
+        return armor.apply(ArmorModelRegistry.getModelKey(stack.getItem(), layerType, variant));
-                .or(() -> variant.getDefaultModel(layerType))
-                .map(armor);
     }
 }

src/main/java/com/minelittlepony/client/model/PlayerModelKey.java

@@ -3,8 +3,6 @@ package com.minelittlepony.client.model;
 import net.minecraft.client.model.Model;
 import net.minecraft.client.model.ModelPart;
 
-import org.jetbrains.annotations.Nullable;
-
 import com.minelittlepony.api.model.Models;
 import com.minelittlepony.api.model.PonyModel;
 import com.minelittlepony.client.MineLittlePony;
@@ -28,15 +26,15 @@ public record PlayerModelKey<M extends Model & PonyModel<?>> (
         );
     }
 
-    public ModelKey<M> getKey(boolean slimArms) {
+    public <N extends M> Models<N>  alex() {
-        return slimArms ? alexKey : steveKey;
+        return new Models<N>(alexKey, armorFactory);
     }
 
-    public <N extends M> Models<N> create(boolean slimArms) {
+    public <N extends M> Models<N>  steve() {
-        return create(slimArms, null);
+        return new Models<N>(steveKey, armorFactory);
     }
 
-    public <N extends M> Models<N>  create(boolean slimArms, @Nullable Consumer<N> initializer) {
+    public <N extends M> Models<N>  create(boolean slimArms) {
-        return new Models<>(this, slimArms, initializer);
+        return slimArms ? alex() : steve();
     }
 }

src/main/java/com/minelittlepony/client/model/armour/ArmorModelRegistry.java

@@ -2,25 +2,35 @@ package com.minelittlepony.client.model.armour;
 
 import net.minecraft.item.Item;
 import net.minecraft.item.equipment.EquipmentModel;
-import net.minecraft.registry.Registries;
 import net.minecraft.util.Identifier;
 
 import com.minelittlepony.client.model.AbstractPonyModel;
 import com.minelittlepony.mson.api.ModelKey;
 import com.minelittlepony.mson.api.Mson;
+import com.minelittlepony.util.ResourceUtil;
 
 import java.util.*;
 
 public interface ArmorModelRegistry {
     static final Map<Identifier, Optional<ModelKey<AbstractPonyModel<?>>>> REGISTRY = new HashMap<>();
 
-    public static Optional<ModelKey<AbstractPonyModel<?>>> getModelKey(Item item, EquipmentModel.LayerType layerType) {
+    @SuppressWarnings("deprecation")
-        Identifier id = Registries.ITEM.getId(item);
+    public static ModelKey<AbstractPonyModel<?>> getModelKey(Item item, EquipmentModel.LayerType layerType, ArmourVariant variant) {
-        if (id.getNamespace().equals("minecraft")) {
+        return item.getRegistryEntry().getKey().map(key -> key.getValue()).flatMap(id -> {
-            return Optional.empty();
+            if (id.getNamespace().equals("minecraft")) {
-        }
+                return Optional.empty();
-        return REGISTRY.computeIfAbsent(id.withPath(p -> "armor/" + layerType.name().toLowerCase(Locale.ROOT) + "_" + p + ".json"), i -> {
+            }
-            return Optional.of(Mson.getInstance().registerModel(i, PonyArmourModel::new));
+            return REGISTRY.computeIfAbsent(id.withPath(p -> ResourceUtil.format("armor/%s_%s.json", layerName(layerType), p)), i -> {
-        }).filter(key -> key.getModelData().isPresent());
+                return Optional.of(Mson.getInstance().registerModel(i, PonyArmourModel::new));
+            }).filter(key -> key.getModelData().isPresent());
+        }).orElse(variant.getDefaultModel(layerType));
+    }
+
+    private static String layerName(EquipmentModel.LayerType layerType) {
+        return switch (layerType) {
+            case HUMANOID -> "outer";
+            case HUMANOID_LEGGINGS -> "inner";
+            default -> layerType.name().toLowerCase(Locale.ROOT);
+        };
     }
 }

src/main/java/com/minelittlepony/client/model/armour/ArmourVariant.java

@@ -6,22 +6,20 @@ import com.minelittlepony.client.model.AbstractPonyModel;
 import com.minelittlepony.client.model.ModelType;
 import com.minelittlepony.mson.api.ModelKey;
 
-import java.util.Optional;
-
 public enum ArmourVariant {
     NORMAL(ModelType.INNER_PONY_ARMOR, ModelType.OUTER_PONY_ARMOR),
     LEGACY(ModelType.INNER_VANILLA_ARMOR, ModelType.OUTER_VANILLA_ARMOR),
     TRIM(ModelType.INNER_VANILLA_ARMOR, ModelType.OUTER_VANILLA_ARMOR);
 
-    private final Optional<ModelKey<AbstractPonyModel<?>>> innerModel;
+    private final ModelKey<AbstractPonyModel<?>> innerModel;
-    private final Optional<ModelKey<AbstractPonyModel<?>>> outerModel;
+    private final ModelKey<AbstractPonyModel<?>> outerModel;
 
     ArmourVariant(ModelKey<AbstractPonyModel<?>> inner, ModelKey<AbstractPonyModel<?>> outer) {
-        this.innerModel = Optional.of(inner);
+        this.innerModel = inner;
-        this.outerModel = Optional.of(outer);
+        this.outerModel = outer;
     }
 
-    public Optional<ModelKey<AbstractPonyModel<?>>> getDefaultModel(EquipmentModel.LayerType layerType) {
+    public ModelKey<AbstractPonyModel<?>> getDefaultModel(EquipmentModel.LayerType layerType) {
         return layerType == EquipmentModel.LayerType.HUMANOID_LEGGINGS ? innerModel : outerModel;
     }
 }

src/main/java/com/minelittlepony/client/model/armour/PonifiedEquipmentRenderer.java

@@ -82,7 +82,7 @@ public class PonifiedEquipmentRenderer extends EquipmentRenderer {
                         VertexConsumer armorConsumer = getArmorVertexConsumer(plugin, equipmentSlot, vertices, layerTexture, layerType, hasGlint);
                         if (armorConsumer != null) {
                             ArmourVariant variant = layer.usePlayerTexture() ? ArmourVariant.LEGACY : armorTexture.variant();
-                            AbstractPonyModel<?> model = models.getArmourModel(stack, layerType, variant).orElse(null);
+                            AbstractPonyModel<?> model = models.getArmourModel(stack, layerType, variant);
                             if (model != null) {
                                 model.setAngles(entity);
                                 models.body().copyTransforms(model);

src/main/java/com/minelittlepony/client/render/EquineRenderManager.java

@@ -62,9 +62,8 @@ public class EquineRenderManager<
         context.setModel(models.body());
     }
 
-    @SuppressWarnings({"rawtypes", "unchecked"})
     public EquineRenderManager(PonyRenderContext<T, S, M> context, Transformer<? super S> transformer, ModelKey<? super M> key) {
-        this(context, transformer, new Models(key));
+        this(context, transformer, new Models<>(key));
     }
 
     public void setModelsLookup(Function<Race, Models<M>> modelsLookup) {

src/main/java/com/minelittlepony/client/render/blockentity/skull/PlayerPonySkull.java

@@ -62,7 +62,7 @@ public class PlayerPonySkull implements ISkull {
                 return false;
             }
         }
-        ponyHead = modelCache.computeIfAbsent(ModelType.getPlayerModel(race), key -> key.getKey(false).createModel());
+        ponyHead = modelCache.computeIfAbsent(ModelType.getPlayerModel(race), key -> key.steveKey().createModel());
         state.pony = pony;
         state.race = pony.race();
         state.attributes.size = pony.size();

src/main/java/com/minelittlepony/client/render/entity/feature/SkullFeature.java

@@ -28,14 +28,11 @@ public class SkullFeature<
 
     private final HeadFeatureRenderer.HeadTransformation headTransformation;
 
-    private final boolean scaleForChild;
-
     public SkullFeature(PonyRenderContext<?, S, M> context, EntityModelLoader entityModelLoader, ItemRenderer itemRenderer,
             HeadFeatureRenderer.HeadTransformation headTransformation, boolean scaleForChild) {
         super(context);
         this.itemRenderer = itemRenderer;
         this.headTransformation = headTransformation;
-        this.scaleForChild = scaleForChild;
     }
 
     @Override

src/main/java/com/minelittlepony/client/render/entity/npc/AbstractNpcRenderer.java

@@ -5,6 +5,7 @@ import net.minecraft.entity.mob.MobEntity;
 import net.minecraft.util.Identifier;
 import net.minecraft.village.*;
 
+import com.minelittlepony.api.model.Models;
 import com.minelittlepony.api.model.gear.Gear;
 import com.minelittlepony.api.pony.meta.Race;
 import com.minelittlepony.api.pony.meta.Wearable;
@@ -19,13 +20,15 @@ abstract class AbstractNpcRenderer<
     private final NpcClothingFeature<T, S, ClientPonyModel<S>, AbstractNpcRenderer<T, S>> clothing;
 
     public AbstractNpcRenderer(EntityRendererFactory.Context context, String type, TextureSupplier<T> textureSupplier, TextureSupplier<String> formatter) {
-        super(context, ModelType.getPlayerModel(Race.EARTH).getKey(false), SillyPonyTextureSupplier.create(textureSupplier, formatter));
+        super(context, ModelType.getPlayerModel(Race.EARTH).steveKey(), SillyPonyTextureSupplier.create(textureSupplier, formatter));
         clothing = new NpcClothingFeature<>(this, type);
         this.manager.setModelsLookup(race -> {
             if (race.isHuman()) {
                 race = Race.EARTH;
             }
-            return ModelType.getPlayerModel(race).create(false, this::initializeModel);
+            Models<ClientPonyModel<S>> models = ModelType.getPlayerModel(race).steve();
+            initializeModel(models.body());
+            return models;
         });
         addFeature(clothing);
     }

src/main/java/com/minelittlepony/client/render/entity/npc/TraderRenderer.java

@@ -15,7 +15,7 @@ public class TraderRenderer extends PonyRenderer<WanderingTraderEntity, PonyRend
     public static final Identifier TEXTURE = MineLittlePony.id("textures/entity/wandering_trader_pony.png");
 
     public TraderRenderer(EntityRendererFactory.Context context) {
-        super(context, ModelType.ALICORN.getKey(false), TextureSupplier.of(TEXTURE), BASE_MODEL_SCALE);
+        super(context, ModelType.ALICORN.steveKey(), TextureSupplier.of(TEXTURE), BASE_MODEL_SCALE);
     }
 
     @Override

src/main/java/com/minelittlepony/util/MathUtil.java

@@ -23,6 +23,7 @@ public interface MathUtil {
         return value;
     }
 
+    @Deprecated(forRemoval = true)
     static float interpolateDegress(float prev, float current, float partialTicks) {
         float difference = current - prev;