Anyone can now use the seapony skin variant

src/main/java/com/minelittlepony/api/pony/PonyPosture.java

@@ -2,7 +2,7 @@ package com.minelittlepony.api.pony;
 
 import com.minelittlepony.api.pony.meta.Race;
 import com.minelittlepony.client.SkinsProxy;
-import com.minelittlepony.client.render.entity.PlayerSeaponyRenderer;
+import com.minelittlepony.client.render.entity.AquaticPlayerPonyRenderer;
 
 import java.util.Optional;
 
@@ -88,10 +88,14 @@ public final class PonyPosture {
     }
 
     public static boolean isSeaponyModifier(LivingEntity entity) {
+        return hasSeaponyForm(entity) && isPartiallySubmerged(entity);
+    }
+
+    public static boolean hasSeaponyForm(LivingEntity entity) {
         return IPony.getManager().getPony(entity).filter(pony -> {
             return (pony.race() == Race.SEAPONY
-                    || (entity instanceof AbstractClientPlayerEntity player && SkinsProxy.instance.getSkin(PlayerSeaponyRenderer.SKIN_TYPE_ID, player).isPresent())
+                    || (entity instanceof AbstractClientPlayerEntity player && SkinsProxy.instance.getSkin(AquaticPlayerPonyRenderer.SKIN_TYPE_ID, player).isPresent())
-            ) && PonyPosture.isPartiallySubmerged(entity);
+            );
         }).isPresent();
     }
 }

src/main/java/com/minelittlepony/client/hdskins/MineLPHDSkins.java

@@ -29,7 +29,7 @@ import net.minecraft.item.Items;
 import net.minecraft.util.Identifier;
 
 import com.minelittlepony.client.pony.PonyManager;
-import com.minelittlepony.client.render.entity.PlayerSeaponyRenderer;
+import com.minelittlepony.client.render.entity.AquaticPlayerPonyRenderer;
 
 /**
  * All the interactions with HD Skins.
@@ -44,7 +44,7 @@ public class MineLPHDSkins extends SkinsProxy implements ClientModInitializer {
     public void onInitializeClient() {
         SkinsProxy.instance = this;
 
-        seaponySkinType = SkinType.register(PlayerSeaponyRenderer.SKIN_TYPE_ID, Items.COD_BUCKET.getDefaultStack());
+        seaponySkinType = SkinType.register(AquaticPlayerPonyRenderer.SKIN_TYPE_ID, Items.COD_BUCKET.getDefaultStack());
         Wearable.VALUES.forEach(wearable -> {
             if (wearable != Wearable.NONE) {
                 wearableTypes.put(SkinType.register(wearable.getId(), Items.BUNDLE.getDefaultStack()), wearable);

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

@@ -16,8 +16,6 @@ import com.minelittlepony.client.model.armour.PonyArmourModel;
 import com.minelittlepony.client.model.entity.*;
 import com.minelittlepony.client.model.entity.race.*;
 import com.minelittlepony.client.model.gear.*;
-import com.minelittlepony.client.render.entity.PlayerPonyRenderer;
-import com.minelittlepony.client.render.entity.PlayerSeaponyRenderer;
 import com.minelittlepony.mson.api.ModelKey;
 import com.minelittlepony.mson.api.Mson;
 import com.minelittlepony.mson.api.MsonModel;
@@ -71,13 +69,9 @@ public final class ModelType {
     public static final PlayerModelKey<LivingEntity, KirinModel<?>> KIRIN = registerPlayer("kirin", Race.KIRIN, KirinModel::new);
     public static final PlayerModelKey<LivingEntity, PegasusModel<?>> PEGASUS = registerPlayer("pegasus", Race.PEGASUS, PegasusModel::new);
     public static final PlayerModelKey<LivingEntity, PegasusModel<?>> GRYPHON = registerPlayer("gryphon", Race.GRYPHON, PegasusModel::new);
-    public static final PlayerModelKey<LivingEntity, PegasusModel<?>> HIPPOGRIFF = registerPlayer("hippogriff", Race.HIPPOGRIFF, PegasusModel::new, PonyArmourModel::new, (ctx, slim, dry) -> {
+    public static final PlayerModelKey<LivingEntity, PegasusModel<?>> HIPPOGRIFF = registerPlayer("hippogriff", Race.HIPPOGRIFF, PegasusModel::new, PonyArmourModel::new);
-        return new PlayerSeaponyRenderer(ctx, slim, getPlayerModel(Race.SEAPONY), dry);
-    });
     public static final PlayerModelKey<LivingEntity, EarthPonyModel<?>> EARTH_PONY = registerPlayer("earth_pony", Race.EARTH, EarthPonyModel::new);
-    public static final PlayerModelKey<LivingEntity, SeaponyModel<?>> SEA_PONY = registerPlayer("sea_pony", Race.SEAPONY, SeaponyModel::new, SeaponyModel.Armour::new, (ctx, slim, wet) -> {
+    public static final PlayerModelKey<LivingEntity, SeaponyModel<?>> SEA_PONY = registerPlayer("sea_pony", Race.SEAPONY, SeaponyModel::new, SeaponyModel.Armour::new);
-        return new PlayerSeaponyRenderer(ctx, slim, wet, getPlayerModel(Race.UNICORN));
-    });
     public static final PlayerModelKey<LivingEntity, PegasusModel<?>> BAT_PONY = registerPlayer("bat_pony", Race.BATPONY, PegasusModel::new);
     public static final PlayerModelKey<LivingEntity, ChangelingModel<?>> CHANGELING = registerPlayer("changeling", Race.CHANGELING, ChangelingModel::new);
     public static final PlayerModelKey<LivingEntity, ChangelingModel<?>> CHANGEDLING = registerPlayer("reformed_changeling", Race.CHANGEDLING, ChangelingModel::new);
@@ -85,23 +79,14 @@ public final class ModelType {
 
     static <E extends LivingEntity, T extends Model & MsonModel & IModel> PlayerModelKey<E, T> registerPlayer(String name, Race race,
             BiFunction<ModelPart, Boolean, T> constructor) {
-        return registerPlayer(name, race, constructor, PlayerPonyRenderer::new);
+        return registerPlayer(name, race, constructor, PonyArmourModel::new);
-    }
-
-    static <E extends LivingEntity, T extends Model & MsonModel & IModel> PlayerModelKey<E, T> registerPlayer(String name, Race race,
-            BiFunction<ModelPart, Boolean, T> constructor,
-            PlayerModelKey.RendererFactory rendererFactory) {
-        return registerPlayer(name, race, constructor, PonyArmourModel::new, rendererFactory);
     }
 
     @SuppressWarnings("unchecked")
     static <E extends LivingEntity, T extends Model & MsonModel & IModel> PlayerModelKey<E, T> registerPlayer(String name, Race race,
             BiFunction<ModelPart, Boolean, T> constructor,
-            MsonModel.Factory<PonyArmourModel<E>> armorFactory,
+            MsonModel.Factory<PonyArmourModel<E>> armorFactory) {
-            PlayerModelKey.RendererFactory rendererFactory) {
+        return (PlayerModelKey<E, T>)PLAYER_MODELS.computeIfAbsent(race, r -> new PlayerModelKey<>(name, constructor, armorFactory));
-        return (PlayerModelKey<E, T>)PLAYER_MODELS.computeIfAbsent(race, r -> {
-            return new PlayerModelKey<>(name, constructor, rendererFactory, armorFactory);
-        });
     }
 
     @SuppressWarnings("unchecked")

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

@@ -2,9 +2,6 @@ package com.minelittlepony.client.model;
 
 import net.minecraft.client.model.Model;
 import net.minecraft.client.model.ModelPart;
-import net.minecraft.client.network.AbstractClientPlayerEntity;
-import net.minecraft.client.render.entity.EntityRendererFactory;
-import net.minecraft.client.render.entity.PlayerEntityRenderer;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.util.Identifier;
 
@@ -19,14 +16,12 @@ import java.util.function.*;
 public record PlayerModelKey<T extends LivingEntity, M extends Model & MsonModel & IModel> (
         ModelKey<M> steveKey,
         ModelKey<M> alexKey,
-        RendererFactory factory,
         MsonModel.Factory<PonyArmourModel<T>> armorFactory
 ) {
-    PlayerModelKey(String name, BiFunction<ModelPart, Boolean, M> modelFactory, RendererFactory rendererFactory, MsonModel.Factory<PonyArmourModel<T>> armorFactory) {
+    PlayerModelKey(String name, BiFunction<ModelPart, Boolean, M> modelFactory, MsonModel.Factory<PonyArmourModel<T>> armorFactory) {
         this(
             new ModelKeyImpl<>(new Identifier("minelittlepony", "races/steve/" + name), tree -> modelFactory.apply(tree, false)),
             new ModelKeyImpl<>(new Identifier("minelittlepony", "races/alex/" + name), tree -> modelFactory.apply(tree, true)),
-            rendererFactory,
             armorFactory
         );
     }
@@ -43,17 +38,4 @@ public record PlayerModelKey<T extends LivingEntity, M extends Model & MsonModel
     public <K extends T, N extends M> ModelWrapper<K, N> create(boolean slimArms, @Nullable Consumer<N> initializer) {
         return new ModelWrapper(this, slimArms, initializer);
     }
-
-    @SuppressWarnings("unchecked")
-    public Function<EntityRendererFactory.Context, PlayerEntityRenderer> getFactory(boolean slimArms) {
-        return d -> factory.create(d, slimArms, (PlayerModelKey<AbstractClientPlayerEntity, ClientPonyModel<AbstractClientPlayerEntity>>)this);
-    }
-
-    public interface RendererFactory {
-        PlayerEntityRenderer create(
-                EntityRendererFactory.Context context,
-                boolean slim,
-                PlayerModelKey<AbstractClientPlayerEntity, ClientPonyModel<AbstractClientPlayerEntity>> key
-        );
-    }
 }

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

@@ -24,14 +24,11 @@ import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.entity.player.PlayerEntity;
-import net.minecraft.util.Identifier;
 
 public class EquineRenderManager<T extends LivingEntity, M extends EntityModel<T> & IPonyModel<T>> {
 
     private ModelWrapper<T, M> playerModel;
 
-    private IPony pony;
-
     private final IPonyRenderContext<T, M> renderer;
 
     private final FrustrumCheck<T> frustrum = new FrustrumCheck<>(this);
@@ -44,6 +41,28 @@ public class EquineRenderManager<T extends LivingEntity, M extends EntityModel<T
         this.renderer = renderer;
     }
 
+    public IPonyRenderContext<T, M> getContext() {
+        return renderer;
+    }
+
+    public ModelWrapper<T, M> getModelWrapper() {
+        return playerModel;
+    }
+
+    public M getModel() {
+        return playerModel.body();
+    }
+
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    public ModelWrapper<T, M> setModel(ModelKey<? super M> key) {
+        return setModel(new ModelWrapper(key));
+    }
+
+    public ModelWrapper<T, M> setModel(ModelWrapper<T, M> wrapper) {
+        playerModel = wrapper;
+        return wrapper;
+    }
+
     public Frustum getFrustrum(T entity, Frustum vanilla) {
         if (RenderPass.getCurrent() == RenderPass.HUD) {
             return FrustrumCheck.ALWAYS_VISIBLE;
@@ -55,15 +74,6 @@ public class EquineRenderManager<T extends LivingEntity, M extends EntityModel<T
         return frustrum.withCamera(entity, vanilla);
     }
 
-    public void preRenderCallback(T entity, MatrixStack stack, float ticks) {
-        updateModel(entity, ModelAttributes.Mode.THIRD_PERSON);
-
-        float s = getScaleFactor();
-        stack.scale(s, s, s);
-
-        translateRider(entity, stack, ticks);
-    }
-
     public float getRenderYaw(T entity, float rotationYaw, float partialTicks) {
         if (entity.hasVehicle()) {
             Entity mount = entity.getVehicle();
@@ -75,6 +85,15 @@ public class EquineRenderManager<T extends LivingEntity, M extends EntityModel<T
         return rotationYaw;
     }
 
+    public void preRenderCallback(T entity, MatrixStack stack, float ticks) {
+        updateModel(entity, ModelAttributes.Mode.THIRD_PERSON);
+
+        float s = getScaleFactor();
+        stack.scale(s, s, s);
+
+        translateRider(entity, stack, ticks);
+    }
+
     private void translateRider(T entity, MatrixStack stack, float ticks) {
         if (entity.hasVehicle() && entity.getVehicle() instanceof LivingEntity) {
 
@@ -87,7 +106,7 @@ public class EquineRenderManager<T extends LivingEntity, M extends EntityModel<T
 
                 IPony riderPony = renderer.getEntityPony(ridingEntity);
 
-                renderer.translateRider(ridingEntity, riderPony, entity, pony, stack, ticks);
+                renderer.translateRider(ridingEntity, riderPony, entity, renderer.getEntityPony(entity), stack, ticks);
             }
         }
     }
@@ -100,31 +119,8 @@ public class EquineRenderManager<T extends LivingEntity, M extends EntityModel<T
         PonyPosture.of(getModel().getAttributes()).apply(entity, getModel(), stack, yaw, tickDelta, -1);
     }
 
-    public M getModel() {
-        return playerModel.body();
-    }
-
-    public ModelWrapper<T, M> getModelWrapper() {
-        return playerModel;
-    }
-
-    @SuppressWarnings({"rawtypes", "unchecked"})
-    public ModelWrapper<T, M> setModel(ModelKey<? super M> key) {
-        return setModel(new ModelWrapper(key));
-    }
-
-    public ModelWrapper<T, M> setModel(ModelWrapper<T, M> wrapper) {
-        playerModel = wrapper;
-        return wrapper;
-    }
-
-    public void updateMetadata(Identifier texture) {
-        pony = IPony.getManager().getPony(texture);
-        playerModel.applyMetadata(pony.metadata());
-    }
-
     public IPony updateModel(T entity, ModelAttributes.Mode mode) {
-        pony = renderer.getEntityPony(entity);
+        IPony pony = renderer.getEntityPony(entity);
         playerModel.applyMetadata(pony.metadata());
 
         if (pony.hasMetadata() && entity instanceof RegistrationHandler && ((RegistrationHandler)entity).shouldUpdateRegistration(pony)) {
@@ -144,18 +140,6 @@ public class EquineRenderManager<T extends LivingEntity, M extends EntityModel<T
         return pony;
     }
 
-    public IPony getPony(T entity) {
-        return updateModel(entity, ModelAttributes.Mode.THIRD_PERSON);
-    }
-
-    public Identifier getTexture(T entity) {
-        return getPony(entity).texture();
-    }
-
-    public float getShadowScale() {
-        return getModel().getSize().getShadowSize();
-    }
-
     public float getScaleFactor() {
         return getModel().getSize().getScaleFactor();
     }

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

@@ -34,7 +34,7 @@ public class FrustrumCheck<T extends LivingEntity> extends Frustum {
 
     @Override
     public boolean isVisible(Box bounds) {
-        return vanilla.isVisible(PonyBounds.getBoundingBox(renderer.getPony(entity), entity));
+        return vanilla.isVisible(PonyBounds.getBoundingBox(renderer.getContext().getEntityPony(entity), entity));
     }
 
     @Override

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

@@ -1,21 +1,18 @@
 package com.minelittlepony.client.render;
 
-import java.util.Locale;
 import java.util.function.Function;
-import java.util.function.Predicate;
-
 import com.minelittlepony.api.pony.IPony;
-import com.minelittlepony.api.pony.meta.Race;
+import com.minelittlepony.api.pony.PonyPosture;
 import com.minelittlepony.client.mixin.MixinEntityRenderers;
 import com.minelittlepony.client.model.IPonyModel;
-import com.minelittlepony.client.model.ModelType;
+import com.minelittlepony.client.render.entity.PlayerPonyRenderer;
+import com.minelittlepony.client.render.entity.AquaticPlayerPonyRenderer;
 
 import org.jetbrains.annotations.Nullable;
 
 import com.minelittlepony.mson.api.Mson;
 
 import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.network.AbstractClientPlayerEntity;
 import net.minecraft.client.render.entity.*;
 import net.minecraft.client.render.entity.model.EntityModel;
 import net.minecraft.client.util.SkinTextures;
@@ -38,27 +35,30 @@ public class PonyRenderDispatcher {
      * Registers all new player skin types. (currently only pony and slimpony).
      */
     public void initialise(EntityRenderDispatcher manager, boolean force) {
-        Race.REGISTRY.forEach(r -> {
+        for (SkinTextures.Model armShape : SkinTextures.Model.values()) {
-            if (!r.isHuman()) {
+            addPlayerRenderer(armShape);
-                registerPlayerSkin(manager, r);
+        }
-            }
-        });
         MobRenderers.REGISTRY.values().forEach(i -> i.apply(this, force));
     }
 
-    private void registerPlayerSkin(EntityRenderDispatcher manager, Race race) {
+    private void addPlayerRenderer(SkinTextures.Model armShape) {
-        addPlayerSkin(manager, SkinTextures.Model.SLIM, race);
-        addPlayerSkin(manager, SkinTextures.Model.WIDE, race);
-    }
-
-    private void addPlayerSkin(EntityRenderDispatcher manager, SkinTextures.Model armShape, Race race) {
         Mson.getInstance().getEntityRendererRegistry().registerPlayerRenderer(
-                new Identifier("minelittlepony", race.name().toLowerCase(Locale.ROOT) + "/" + armShape.getName()),
+                new Identifier("minelittlepony", "sea/" + armShape.getName()),
-                (Predicate<AbstractClientPlayerEntity>)(player -> {
+                player -> {
-                    return IPony.getManager().getPony(player).metadata().getRace() == race
+                    return !IPony.getManager().getPony(player).race().isHuman()
+                            && PonyPosture.hasSeaponyForm(player)
                             && player.method_52814().model() == armShape;
-                }),
+                },
-                ModelType.getPlayerModel(race).getFactory(armShape == SkinTextures.Model.SLIM)
+                context -> new AquaticPlayerPonyRenderer(context, false)
+        );
+        Mson.getInstance().getEntityRendererRegistry().registerPlayerRenderer(
+                new Identifier("minelittlepony", "land/" + armShape.getName()),
+                player -> {
+                    return !IPony.getManager().getPony(player).race().isHuman()
+                            && !PonyPosture.hasSeaponyForm(player)
+                            && player.method_52814().model() == armShape;
+                },
+                context -> new PlayerPonyRenderer(context, false)
         );
     }
 

src/main/java/com/minelittlepony/client/render/entity/AbstractPonyRenderer.java

@@ -64,7 +64,7 @@ public abstract class AbstractPonyRenderer<T extends MobEntity, M extends Entity
     @Override
     public void render(T entity, float entityYaw, float tickDelta, MatrixStack stack, VertexConsumerProvider renderContext, int lightUv) {
         super.render(entity, entityYaw, tickDelta, stack, renderContext, lightUv);
-        DebugBoundingBoxRenderer.render(manager.getPony(entity), this, entity, stack, renderContext, tickDelta);
+        DebugBoundingBoxRenderer.render(getEntityPony(entity), this, entity, stack, renderContext, tickDelta);
     }
 
     @Override
@@ -90,7 +90,7 @@ public abstract class AbstractPonyRenderer<T extends MobEntity, M extends Entity
 
     @Override
     public void scale(T entity, MatrixStack stack, float tickDelta) {
-        shadowRadius = manager.getShadowScale();
+        shadowRadius = manager.getModel().getSize().getShadowSize();
 
         if (entity.isBaby()) {
             shadowRadius *= 3; // undo vanilla shadow scaling

src/main/java/com/minelittlepony/client/render/entity/AquaticPlayerPonyRenderer.java

@@ -2,8 +2,8 @@ package com.minelittlepony.client.render.entity;
 
 import com.minelittlepony.api.pony.IPony;
 import com.minelittlepony.api.pony.PonyPosture;
+import com.minelittlepony.api.pony.meta.Race;
 import com.minelittlepony.client.SkinsProxy;
-import com.minelittlepony.client.model.*;
 import com.minelittlepony.util.MathUtil;
 
 import net.minecraft.client.network.AbstractClientPlayerEntity;
@@ -14,21 +14,13 @@ import net.minecraft.particle.ParticleTypes;
 import net.minecraft.util.Arm;
 import net.minecraft.util.Identifier;
 
-public class PlayerSeaponyRenderer extends PlayerPonyRenderer {
+public class AquaticPlayerPonyRenderer extends PlayerPonyRenderer {
     public static final Identifier SKIN_TYPE_ID = new Identifier("minelp", "seapony");
 
-    private final ModelWrapper<AbstractClientPlayerEntity, ClientPonyModel<AbstractClientPlayerEntity>> wetPony;
-    private final ModelWrapper<AbstractClientPlayerEntity, ClientPonyModel<AbstractClientPlayerEntity>> dryPony;
-
     private boolean wet;
 
-    public PlayerSeaponyRenderer(EntityRendererFactory.Context context, boolean slim,
+    public AquaticPlayerPonyRenderer(EntityRendererFactory.Context context, boolean slim) {
-            PlayerModelKey<AbstractClientPlayerEntity, ClientPonyModel<AbstractClientPlayerEntity>> wetModel,
+        super(context, slim);
-            PlayerModelKey<AbstractClientPlayerEntity, ClientPonyModel<AbstractClientPlayerEntity>> dryModel) {
-        super(context, slim, wetModel);
-
-        dryPony = dryModel.<AbstractClientPlayerEntity, ClientPonyModel<AbstractClientPlayerEntity>>create(slim);
-        wetPony = getInternalRenderer().getModelWrapper();
     }
 
     @Override
@@ -53,6 +45,11 @@ public class PlayerSeaponyRenderer extends PlayerPonyRenderer {
         }
     }
 
+    protected Race getPlayerRace(AbstractClientPlayerEntity entity, IPony pony) {
+        Race race = super.getPlayerRace(entity, pony);
+        return wet ? Race.SEAPONY : race == Race.SEAPONY ? Race.UNICORN : race;
+    }
+
     @Override
     protected void setupTransforms(AbstractClientPlayerEntity entity, MatrixStack stack, float ageInTicks, float rotationYaw, float partialTicks) {
         if (wet) {
@@ -73,7 +70,6 @@ public class PlayerSeaponyRenderer extends PlayerPonyRenderer {
     private void updateSeaponyState(AbstractClientPlayerEntity player) {
         IPony pony = getEntityPony(player);
         wet = PonyPosture.isSeaponyModifier(player);
-        model = manager.setModel(wet ? wetPony : dryPony).body();
 
         float state = wet ? 100 : 0;
         float interpolated = pony.metadata().getInterpolator(player.getUuid()).interpolate("seapony_state", state, 5);

src/main/java/com/minelittlepony/client/render/entity/PlayerPonyRenderer.java

@@ -2,6 +2,7 @@ package com.minelittlepony.client.render.entity;
 
 import com.minelittlepony.api.model.ModelAttributes;
 import com.minelittlepony.api.pony.IPony;
+import com.minelittlepony.api.pony.meta.Race;
 import com.minelittlepony.api.pony.meta.Wearable;
 import com.minelittlepony.client.SkinsProxy;
 import com.minelittlepony.client.model.*;
@@ -9,9 +10,11 @@ import com.minelittlepony.client.render.DebugBoundingBoxRenderer;
 import com.minelittlepony.client.render.IPonyRenderContext;
 import com.minelittlepony.client.render.entity.feature.*;
 import com.minelittlepony.client.util.render.RenderLayerUtil;
-import com.minelittlepony.client.render.EquineRenderManager;
 
-import java.util.List;
+import java.util.*;
+import java.util.function.Function;
+
+import com.minelittlepony.client.render.EquineRenderManager;
 
 import net.minecraft.block.BedBlock;
 import net.minecraft.client.MinecraftClient;
@@ -22,19 +25,18 @@ import net.minecraft.client.render.entity.PlayerEntityRenderer;
 import net.minecraft.client.render.entity.feature.*;
 import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.text.Text;
-import net.minecraft.util.Arm;
+import net.minecraft.util.*;
-import net.minecraft.util.Identifier;
 import net.minecraft.util.math.*;
 
 public class PlayerPonyRenderer extends PlayerEntityRenderer implements IPonyRenderContext<AbstractClientPlayerEntity, ClientPonyModel<AbstractClientPlayerEntity>> {
 
     protected final EquineRenderManager<AbstractClientPlayerEntity, ClientPonyModel<AbstractClientPlayerEntity>> manager = new EquineRenderManager<>(this);
 
-    public PlayerPonyRenderer(EntityRendererFactory.Context context, boolean slim, PlayerModelKey<AbstractClientPlayerEntity, ClientPonyModel<AbstractClientPlayerEntity>> key) {
+    private final Function<Race, ModelWrapper<AbstractClientPlayerEntity, ClientPonyModel<AbstractClientPlayerEntity>>> modelsCache;
+
+    public PlayerPonyRenderer(EntityRendererFactory.Context context, boolean slim) {
         super(context, slim);
-
+        modelsCache = Util.memoize(race -> ModelType.getPlayerModel(race).create(slim));
-        this.model = manager.setModel(key.create(slim)).body();
-
         addLayers(context);
     }
 
@@ -75,16 +77,18 @@ public class PlayerPonyRenderer extends PlayerEntityRenderer implements IPonyRen
 
     @Override
     public void render(AbstractClientPlayerEntity entity, float entityYaw, float tickDelta, MatrixStack stack, VertexConsumerProvider renderContext, int lightUv) {
-        model = manager.getModel(); // EntityModelFeatures: We have to force it to use our models otherwise EMF overrides it and breaks pony rendering
+        IPony pony = getEntityPony(entity);
-        shadowRadius = manager.getShadowScale();
+        model = manager.setModel(modelsCache.apply(getPlayerRace(entity, pony))).body();
+        // EntityModelFeatures: We have to force it to use our models otherwise EMF overrides it and breaks pony rendering
+        shadowRadius = manager.getModel().getSize().getShadowSize();
         super.render(entity, entityYaw, tickDelta, stack, renderContext, lightUv);
-        DebugBoundingBoxRenderer.render(manager.getPony(entity), this, entity, stack, renderContext, tickDelta);
+        DebugBoundingBoxRenderer.render(pony, this, entity, stack, renderContext, tickDelta);
 
         // Translate the shadow position after everything is done
         // (shadows are drawn after us)
         if (!entity.hasVehicle() && !entity.isSleeping()) {
             float yaw = MathHelper.lerpAngleDegrees(tickDelta, entity.prevBodyYaw, entity.bodyYaw);
-            float l = entity.getWidth() / 2 * manager.getPony(entity).metadata().getSize().getScaleFactor();
+            float l = entity.getWidth() / 2 * pony.metadata().getSize().getScaleFactor();
 
             stack.multiply(RotationAxis.NEGATIVE_Y.rotationDegrees(yaw));
             stack.translate(0, 0, -l);
@@ -92,6 +96,10 @@ public class PlayerPonyRenderer extends PlayerEntityRenderer implements IPonyRen
         }
     }
 
+    protected Race getPlayerRace(AbstractClientPlayerEntity entity, IPony pony) {
+        return pony.race();
+    }
+
     @Override
     protected void setupTransforms(AbstractClientPlayerEntity entity, MatrixStack stack, float ageInTicks, float rotationYaw, float partialTicks) {
         manager.preRenderCallback(entity, stack, partialTicks);
@@ -136,6 +144,8 @@ public class PlayerPonyRenderer extends PlayerEntityRenderer implements IPonyRen
     }
 
     protected void renderArm(MatrixStack stack, VertexConsumerProvider renderContext, int lightUv, AbstractClientPlayerEntity player, Arm side) {
+        IPony pony = getEntityPony(player);
+        model = manager.setModel(modelsCache.apply(getPlayerRace(player, pony))).body();
         manager.updateModel(player, ModelAttributes.Mode.FIRST_PERSON);
 
         stack.push();
@@ -165,7 +175,7 @@ public class PlayerPonyRenderer extends PlayerEntityRenderer implements IPonyRen
 
     @Override
     public Identifier getTexture(AbstractClientPlayerEntity player) {
-        return manager.getTexture(player);
+        return getEntityPony(player).texture();
     }
 
     @Override
@@ -182,7 +192,7 @@ public class PlayerPonyRenderer extends PlayerEntityRenderer implements IPonyRen
     public Identifier getDefaultTexture(AbstractClientPlayerEntity entity, Wearable wearable) {
         return SkinsProxy.instance.getSkin(wearable.getId(), entity).orElseGet(() -> {
             if (wearable.isSaddlebags() && getInternalRenderer().getModel().getMetadata().getRace().supportsLegacySaddlebags()) {
-                return manager.getTexture(entity);
+                return getTexture(entity);
             }
 
             return wearable.getDefaultTexture();