Updating to 1.15-pre1 part 1

src/main/java/com/minelittlepony/client/MineLittlePony.java

@@ -27,12 +27,7 @@ import net.minecraft.client.gui.screen.TitleScreen;
 import net.minecraft.client.options.KeyBinding;
 import net.minecraft.client.util.InputUtil;
 import net.minecraft.resource.ResourceType;
-import net.minecraft.text.LiteralText;
-import net.minecraft.text.Style;
-import net.minecraft.text.TranslatableText;
-import net.minecraft.util.Formatting;
 import net.minecraft.util.Identifier;
-import net.minecraft.util.Util;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.lwjgl.glfw.GLFW;
@@ -46,9 +41,6 @@ public class MineLittlePony implements ClientModInitializer {
 
     public static final Logger logger = LogManager.getLogger("MineLittlePony");
 
-    private int modelUpdateCounter = 0;
-    private boolean reloadingModels = false;
-
     private final PonyRenderManager renderManager = PonyRenderManager.getInstance();
 
     private ClientPonyConfig config;
@@ -115,26 +107,6 @@ public class MineLittlePony implements ClientModInitializer {
 
         if ((mainMenu || inGame) && keyBinding.isPressed()) {
             client.openScreen(new GuiPonySettings(client.currentScreen));
-        } else if (inGame) {
-            long handle = client.window.getHandle();
-
-            if ((Util.getMeasuringTimeMs() % 10) == 0) {
-                if (InputUtil.isKeyPressed(handle, GLFW.GLFW_KEY_F3) && InputUtil.isKeyPressed(handle, GLFW.GLFW_KEY_M)) {
-                    if (!reloadingModels) {
-                        client.inGameHud.getChatHud().addMessage(
-                                new LiteralText("").append(
-                                new TranslatableText("debug.prefix")
-                                    .setStyle(new Style().setColor(Formatting.YELLOW).setBold(true)))
-                                .append(" ")
-                                .append(new TranslatableText("minelp.debug.reload_models.message")));
-
-                        reloadingModels = true;
-                        modelUpdateCounter++;
-                    }
-                } else {
-                    reloadingModels = false;
-                }
-            }
         }
     }
 
@@ -170,9 +142,5 @@ public class MineLittlePony implements ClientModInitializer {
     public IPonyManager getManager() {
         return ponyManager;
     }
-
-    public int getModelRevision() {
-        return modelUpdateCounter;
-    }
 }
 

src/main/java/com/minelittlepony/client/PonyRenderManager.java

@@ -13,13 +13,15 @@ import com.minelittlepony.client.render.entities.player.RenderPonyPlayer;
 import javax.annotation.Nullable;
 
 import com.minelittlepony.common.mixin.MixinEntityRenderDispatcher;
-import net.fabricmc.fabric.api.client.render.EntityRendererRegistry;
+
+import net.fabricmc.fabric.api.client.rendereregistry.v1.EntityRendererRegistry;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.render.entity.EntityRenderDispatcher;
 import net.minecraft.client.render.entity.EntityRenderer;
 import net.minecraft.client.render.entity.PlayerEntityRenderer;
 import net.minecraft.client.render.entity.model.EntityModel;
 import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityType;
 import net.minecraft.entity.LivingEntity;
 
 /**
@@ -77,7 +79,7 @@ public class PonyRenderManager {
      * @param factory The replacement value
      * @param <T> The entity type
      */
-    public <T extends Entity, V extends T> void switchRenderer(boolean state, Class<V> type, EntityRendererRegistry.Factory factory) {
+    public <T extends Entity, V extends T> void switchRenderer(boolean state, EntityType<V> type, EntityRendererRegistry.Factory factory) {
         if (state) {
             if (!renderMap.containsKey(type)) {
                 renderMap.put(type, MinecraftClient.getInstance().getEntityRenderManager().getRenderer(type));
@@ -101,7 +103,7 @@ public class PonyRenderManager {
             return null;
         }
 
-        EntityRenderer<T> renderer = MinecraftClient.getInstance().getEntityRenderManager().getRenderer(entity);
+        EntityRenderer<T> renderer = (EntityRenderer<T>)MinecraftClient.getInstance().getEntityRenderManager().getRenderer(entity);
 
         if (renderer instanceof IPonyRender) {
             return (IPonyRender<T, M>) renderer;

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

@@ -2,12 +2,13 @@ package com.minelittlepony.client.hdskins;
 
 import com.minelittlepony.client.MineLittlePony;
 import com.minelittlepony.client.SkinsProxy;
-import com.minelittlepony.client.hdskins.gui.DummyPony;
 import com.minelittlepony.client.hdskins.gui.GuiSkinsMineLP;
 import com.minelittlepony.client.hdskins.gui.DummyPonyRenderer;
 import com.minelittlepony.common.event.ClientReadyCallback;
 import com.minelittlepony.hdskins.SkinCacheClearCallback;
-import net.fabricmc.fabric.api.client.render.EntityRendererRegistry;
+import com.minelittlepony.hdskins.dummy.DummyPlayer;
+
+import net.fabricmc.fabric.api.client.rendereregistry.v1.EntityRendererRegistry;
 import net.minecraft.client.MinecraftClient;
 
 import com.minelittlepony.client.pony.PonyManager;
@@ -24,7 +25,7 @@ class MineLPHDSkins {
         ClientReadyCallback.EVENT.register(this::postInit);
 
         // Preview on the select skin gui
-        EntityRendererRegistry.INSTANCE.register(DummyPony.class, DummyPonyRenderer::new);
+        EntityRendererRegistry.INSTANCE.register(DummyPlayer.TYPE, DummyPonyRenderer::new);
     }
 
     private void postInit(MinecraftClient minecraft) {

src/main/java/com/minelittlepony/client/hdskins/gui/DummyPonyRenderer.java

@@ -14,11 +14,11 @@ import com.minelittlepony.hdskins.dummy.DummyPlayerRenderer;
 import com.minelittlepony.hdskins.profile.SkinType;
 import com.minelittlepony.pony.IPony;
 import com.minelittlepony.pony.meta.Race;
-import com.mojang.blaze3d.platform.GlStateManager;
 
-import net.fabricmc.fabric.api.client.render.EntityRendererRegistry;
+import net.fabricmc.fabric.api.client.rendereregistry.v1.EntityRendererRegistry;
 import net.minecraft.client.render.entity.EntityRenderDispatcher;
 import net.minecraft.client.render.entity.feature.FeatureRenderer;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.util.Identifier;
 
 /**
@@ -48,8 +48,8 @@ public class DummyPonyRenderer extends DummyPlayerRenderer<DummyPony, ClientPony
     }
 
     @Override
-    protected void scale(DummyPony entity, float ticks) {
+    protected void scale(DummyPony entity, MatrixStack stack, float ticks) {
-        renderPony.preRenderCallback(entity, ticks);
+        renderPony.preRenderCallback(entity, stack, ticks);
 
         if (entity.isSwimming()) {
             if (entity.getVelocity().x < 100) {
@@ -62,7 +62,7 @@ public class DummyPonyRenderer extends DummyPlayerRenderer<DummyPony, ClientPony
         }
 
         if (entity.hasVehicle()) {
-            GlStateManager.translated(0, entity.getHeightOffset(), 0);
+            stack.translate(0, entity.getHeightOffset(), 0);
         }
     }
 

src/main/java/com/minelittlepony/client/hdskins/gui/PonyPreview.java

@@ -23,13 +23,13 @@ class PonyPreview extends PlayerPreview {
     }
 
     @Override
-    public Identifier getBlankSkin(SkinType type) {
+    public Identifier getBlankSteveSkin(SkinType type) {
         if (type == SkinType.SKIN) {
             // Initialization order means this method might be called before class members have been initialized.
             // This is something that needs to be fixed in HDSkins
             return localPony != null && localPony.wet ? NO_SKIN_SEAPONY : NO_SKIN_PONY;
         }
-        return super.getBlankSkin(type);
+        return super.getBlankSteveSkin(type);
     }
 
     protected DummyPlayer ponify(DummyPlayer human, DummyPlayer pony) {

src/main/java/com/minelittlepony/client/mixin/MixinFirstPersonRenderer.java

@@ -6,11 +6,16 @@ import org.spongepowered.asm.mixin.injection.Redirect;
 
 import com.minelittlepony.client.PonyRenderManager;
 
+import javax.annotation.Nullable;
+
 import net.minecraft.client.network.AbstractClientPlayerEntity;
 import net.minecraft.client.render.FirstPersonRenderer;
+import net.minecraft.client.render.VertexConsumerProvider;
 import net.minecraft.client.render.model.json.ModelTransformation;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
 
 @Mixin(FirstPersonRenderer.class)
 public class MixinFirstPersonRenderer {
@@ -20,11 +25,19 @@ public class MixinFirstPersonRenderer {
                 + "Lnet/minecraft/util/Hand;F"
                 + "Lnet/minecraft/item/ItemStack;F)V",
              at = @At(value = "INVOKE",
-                      target = "Lnet/minecraft/client/render/FirstPersonRenderer;renderItemFromSide("
+                      target = "Lnet/minecraft/client/render/item/ItemRenderer;method_23177("
                                   + "Lnet/minecraft/entity/LivingEntity;"
                                   + "Lnet/minecraft/item/ItemStack;"
-                                  + "Lnet/minecraft/client/render/model/json/ModelTransformation$Type;Z)V"))
+                                  + "Lnet/minecraft/client/render/model/json/ModelTransformation$Type;"
-    private void redirectRenderItemSide(FirstPersonRenderer self, LivingEntity entity, ItemStack stack, ModelTransformation.Type transform, boolean left) {
+                                  + "Z"
-        PonyRenderManager.getInstance().getMagicRenderer().renderItemInFirstPerson(self, (AbstractClientPlayerEntity)entity, stack, transform, left);
+                                  + "Lnet/minecraft/client/util/math/MatrixStack;"
+                                  + "Lnet/minecraft/client/render/VertexConsumerProvider;"
+                                  + "Lnet/minecraft/world/World;"
+                                  + "I"
+                                  + "I)V"))
+    private void redirectRenderItemSide(FirstPersonRenderer self,
+            @Nullable LivingEntity entity, ItemStack item, ModelTransformation.Type transform, boolean left,
+            MatrixStack stack, VertexConsumerProvider renderContext, @Nullable World world, int lightUv, int overlayUv) {
+        PonyRenderManager.getInstance().getMagicRenderer().renderItemInFirstPerson(self, (AbstractClientPlayerEntity)entity, item, transform, left, stack, renderContext, world, lightUv);
     }
 }

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

@@ -2,33 +2,31 @@ package com.minelittlepony.client.model;
 
 import com.minelittlepony.client.model.armour.ModelPonyArmour;
 import com.minelittlepony.client.model.armour.ArmourWrapper;
-import com.minelittlepony.client.model.components.PonyEars;
 import com.minelittlepony.client.model.components.PonySnout;
-import com.minelittlepony.client.model.components.PonyTail;
 import com.minelittlepony.client.transform.PonyTransformation;
-import com.minelittlepony.client.util.render.Part;
 import com.minelittlepony.model.BodyPart;
 import com.minelittlepony.model.IPart;
 import com.minelittlepony.model.armour.IEquestrianArmour;
+import com.minelittlepony.mson.api.model.MsonPart;
+
 import net.minecraft.client.model.ModelPart;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.client.util.math.Vector3f;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.util.Arm;
 import net.minecraft.util.math.MathHelper;
 
-import java.util.function.Consumer;
-
-import static com.mojang.blaze3d.platform.GlStateManager.*;
-
 /**
  * Foundation class for all types of ponies.
  */
 public abstract class AbstractPonyModel<T extends LivingEntity> extends ClientPonyModel<T> {
 
-    protected Part upperTorso;
+    protected ModelPart upperTorso;
-    protected Part upperTorsoOverlay;
+    protected ModelPart upperTorsoOverlay;
 
-    protected Part neck;
+    protected ModelPart neck;
 
     protected IPart tail;
     protected PonySnout snout;
@@ -59,10 +57,10 @@ public abstract class AbstractPonyModel<T extends LivingEntity> extends ClientPo
      * @param entity    The entity we're being called for.
      */
     @Override
-    public void setAngles(T entity, float move, float swing, float ticks, float headYaw, float headPitch, float scale) {
+    public void setAngles(T entity, float move, float swing, float ticks, float headYaw, float headPitch) {
         attributes.checkRainboom(entity, swing, canFly());
 
-        super.setAngles(entity, move, swing, ticks, headYaw, headPitch, scale);
+        super.setAngles(entity, move, swing, ticks, headYaw, headPitch);
 
         updateHeadRotation(headYaw, headPitch);
         shakeBody(move, swing, getWobbleAmount(), ticks);
@@ -126,10 +124,10 @@ public abstract class AbstractPonyModel<T extends LivingEntity> extends ClientPo
 
         head.setPivot(1, 2, isSneaking ? -1 : 1);
 
-        Part.shiftRotationPoint(rightArm, 0, 2,  6);
+        ((MsonPart)rightArm).shift(0, 2,  6);
-        Part.shiftRotationPoint(leftArm,  0, 2,  6);
+        ((MsonPart)leftArm).shift(0, 2,  6);
-        Part.shiftRotationPoint(rightLeg, 0, 2, -8);
+        ((MsonPart)rightLeg).shift(0, 2, -8);
-        Part.shiftRotationPoint(leftLeg,  0, 2, -8);
+        ((MsonPart)leftLeg).shift(0, 2, -8);
     }
 
     protected void ponyRide() {
@@ -542,159 +540,6 @@ public abstract class AbstractPonyModel<T extends LivingEntity> extends ClientPo
         neck.setPivot(NECK_ROT_X + rotateAngleX, rotationPointY, rotationPointZ);
     }
 
-    @Override
-    public void init(float yOffset, float stretch) {
-        cuboidList.clear();
-
-        initHead(yOffset, stretch);
-        initBody(yOffset, stretch);
-        initLegs(yOffset, stretch);
-        initTail(yOffset, stretch);
-    }
-
-    protected void initHead(float yOffset, float stretch) {
-        head = new Part(this, 0, 0)
-                                 .offset(HEAD_CENTRE_X, HEAD_CENTRE_Y, HEAD_CENTRE_Z)
-                                 .around(HEAD_RP_X, HEAD_RP_Y + yOffset, HEAD_RP_Z - 2)
-                                 .box(-4, -4, -4, 8, 8, 8, stretch);
-        initEars(((Part)head), yOffset, stretch);
-
-        helmet = new Part(this, 32, 0)
-                                     .offset(HEAD_CENTRE_X, HEAD_CENTRE_Y, HEAD_CENTRE_Z)
-                                     .around(HEAD_RP_X, HEAD_RP_Y + yOffset, HEAD_RP_Z - 2)
-                                     .box(-4, -4, -4, 8, 8, 8, stretch + 0.5F);
-
-        snout = new PonySnout(this);
-        snout.init(yOffset, stretch);
-    }
-
-    protected void initEars(Part head, float yOffset, float stretch) {
-        ears = new PonyEars(head, false);
-        ears.init(yOffset, stretch);
-    }
-
-    protected void initTail(float yOffset, float stretch) {
-        tail = new PonyTail(this);
-        tail.init(yOffset, stretch);
-    }
-
-    /**
-     * Creates the main torso and neck.
-     */
-    protected void initBody(float yOffset, float stretch) {
-        if (textureHeight == 64) {
-            jacket.cuboids.clear();
-            cuboidList.add(jacket);
-        }
-
-        torso = new Part(this, 16, 16)
-                    .around(HEAD_RP_X, HEAD_RP_Y + yOffset, HEAD_RP_Z)
-                    .box(-4, 4, -2, 8, 8, 4, stretch);
-
-        upperTorso = new Part(this, 24, 0);
-        upperTorso.offset(BODY_CENTRE_X, BODY_CENTRE_Y, BODY_CENTRE_Z)
-                  .around(HEAD_RP_X, HEAD_RP_Y + yOffset, HEAD_RP_Z)
-                    .tex(24, 0)  .east( 4, -4, -4, 8,  8, stretch)  // body sides
-                    .tex(4,  0)  .east( 4, -4,  4, 8,  4, stretch)  // qt mark
-                    .tex(56, 0).bottom(-4,  4, -4, 8,  8, stretch)  // stomach
-                    .tex(36, 16).south(-4, -4,  8, 8,  4, stretch)  // bottom b
-                                .south(-4,  0,  8, 8,  4, stretch)  // bottom b
-                               .bottom(-4,  4,  4, 8,  4, stretch)  // bottom b
-              .flipZ().tex(32, 20).top(-4, -4, -4, 8, 12, stretch) // t body (back)
-                      .tex(24, 0).west(-4, -4, -4, 8,  8, stretch)  // body sides
-                      .tex(4, 0) .west(-4, -4,  4, 8,  4, stretch)  // qt mark
-                // Tail stub
-              .child(0)
-                .tex(32, 0).top(-1, 2, 2, 2, 6, stretch)
-                        .bottom(-1, 4, 2, 2, 6, stretch)
-                          .east( 1, 2, 2, 2, 6, stretch)
-                         .south(-1, 2, 8, 2, 2, stretch)
-                  .flipZ().west(-1, 2, 2, 2, 6, stretch)
-                  .rotate(0.5F, 0, 0);
-
-        neck = new Part(this, 0, 16)
-            .at(NECK_CENTRE_X, NECK_CENTRE_Y, NECK_CENTRE_Z)
-            .rotate(NECK_ROT_X, 0, 0).around(HEAD_RP_X, HEAD_RP_Y + yOffset, HEAD_RP_Z)
-            .north(0, 0, 0, 4, 4, stretch)
-            .south(0, 0, 4, 4, 4, stretch)
-             .east(4, 0, 0, 4, 4, stretch)
-             .west(0, 0, 0, 4, 4, stretch);
-
-        stretch += 0.25F;
-
-        jacket.addCuboid(-4, 4, -2, 8, 8, 4, stretch);
-        jacket.setPivot(HEAD_RP_X, HEAD_RP_Y + yOffset, HEAD_RP_Z);
-
-        upperTorsoOverlay = new Part(this, 24, 0);
-        upperTorsoOverlay.offset(BODY_CENTRE_X, BODY_CENTRE_Y, BODY_CENTRE_Z)
-                         .around(HEAD_RP_X, HEAD_RP_Y + yOffset, HEAD_RP_Z)
-                          .tex(12, 32)  .east( 4, -4, -4, 4,  8, stretch) // body sides a
-                          .tex(12, 48)  .east( 4,  0, -4, 4,  8, stretch) // body sides b
-                          .tex(0, 32)   .east( 4, -4,  4, 4,  4, stretch) // qt mark a
-                          .tex(0, 48)   .east( 4,  0,  4, 4,  4, stretch) // qt mark b
-                          .tex(28, 48).bottom(-4,  4, -4, 8,  4, stretch) // stomach a
-                          .tex(44, 48).bottom(-4,  4,  0, 8,  4, stretch) // stomach b
-                          .tex(36, 32) .south(-4, -4,  8, 8,  4, stretch) // bottom b
-                                       .south(-4,  0,  8, 8,  4, stretch) // bottom b
-                          .tex(36, 32).bottom(-4,  4,  4, 8,  4, stretch) // bottom b
-                     .flipZ().tex(32, 36).top(-4, -4, -4, 8, 12, stretch) // t body (back)
-                            .tex(12, 32).west(-4, -4, -4, 4,  8, stretch) // body sides a
-                            .tex(12, 48).west(-4,  0, -4, 4,  8, stretch) // body sides b
-                             .tex(0, 32).west(-4, -4,  4, 4,  4, stretch) // qt mark a
-                             .tex(0, 48).west(-4,  0,  4, 4,  4, stretch);// qt mark b
-    }
-
-    protected void preInitLegs() {
-        leftArm = new ModelPart(this, 32, 48);
-        rightArm = new ModelPart(this, 40, 16);
-
-        leftLeg = new ModelPart(this, 16, 48);
-        rightLeg = new ModelPart(this, 0, 16);
-    }
-
-    protected void preInitLegwear() {
-        leftSleeve.cuboids.clear();
-        rightSleeve.cuboids.clear();
-        leftPantLeg.cuboids.clear();
-        rightPantLeg.cuboids.clear();
-    }
-
-    protected void initLegs(float yOffset, float stretch) {
-        preInitLegs();
-        preInitLegwear();
-
-        int armLength = attributes.armLength;
-        int armWidth = attributes.armWidth;
-        int armDepth = attributes.armDepth;
-
-        float rarmX = attributes.armRotationX;
-        float rarmY = attributes.armRotationY;
-
-        float armX = THIRDP_ARM_CENTRE_X;
-        float armY = THIRDP_ARM_CENTRE_Y;
-        float armZ = BODY_CENTRE_Z / 2 - 1 - armDepth;
-
-        leftArm        .setPivot( rarmX, yOffset + rarmY, 0);
-        rightArm       .setPivot(-rarmX, yOffset + rarmY, 0);
-        leftSleeve .setPivot( rarmX, yOffset + rarmY, 0);
-        rightSleeve.setPivot(-rarmX, yOffset + rarmY, 0);
-
-        leftLeg        .setPivot( rarmX, yOffset, 0);
-        rightLeg       .setPivot(-rarmX, yOffset, 0);
-        leftPantLeg .setPivot( rarmX, yOffset, 0);
-        rightPantLeg.setPivot(-rarmX, yOffset, 0);
-
-        leftArm        .addCuboid(armX,            armY, armZ, armWidth, armLength, armDepth, stretch);
-        rightArm       .addCuboid(armX - armWidth, armY, armZ, armWidth, armLength, armDepth, stretch);
-        leftSleeve .addCuboid(armX,            armY, armZ, armWidth, armLength, armDepth, stretch + 0.25f);
-        rightSleeve.addCuboid(armX - armWidth, armY, armZ, armWidth, armLength, armDepth, stretch + 0.25f);
-
-        leftLeg        .addCuboid(armX,            armY, armZ, armWidth, armLength, armDepth, stretch);
-        rightLeg       .addCuboid(armX - armWidth, armY, armZ, armWidth, armLength, armDepth, stretch);
-        leftPantLeg .addCuboid(armX,            armY, armZ, armWidth, armLength, armDepth, stretch + 0.25f);
-        rightPantLeg.addCuboid(armX - armWidth, armY, armZ, armWidth, armLength, armDepth, stretch + 0.25f);
-    }
-
     @Override
     public float getRiderYOffset() {
 
@@ -711,82 +556,69 @@ public abstract class AbstractPonyModel<T extends LivingEntity> extends ClientPo
         }
     }
 
-    /**
-     * Sets the model's various rotation angles.
-     *
-     * @param entity    The entity we're being called for.
-     * @param move      Entity motion parameter - i.e. velocity in no specific direction used in bipeds to calculate step amount.
-     * @param swing     Degree to which each 'limb' swings.
-     * @param ticks       Total whole and partial ticks since the entity's existance. Used in animations together with {@code swing} and {@code move}.
-     * @param headYaw   Horizontal head motion in radians.
-     * @param headPitch Vertical head motion in radians.
-     * @param scale     Scaling factor used to render this model. Determined by the return value of {@link RenderLivingBase.prepareScale}. Usually {@code 0.0625F}.
-     */
     @Override
-    public void render(T entity, float move, float swing, float ticks, float headYaw, float headPitch, float scale) {
+    public void render(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha) {
-        renderStage(BodyPart.BODY, scale, this::renderBody);
+        renderStage(BodyPart.BODY, stack, vertices, overlayUv, lightUv, red, green, blue, alpha, this::renderBody);
-        renderStage(BodyPart.NECK, scale, this::renderNeck);
+        renderStage(BodyPart.NECK, stack, vertices, overlayUv, lightUv, red, green, blue, alpha, this::renderNeck);
-        renderStage(BodyPart.HEAD, scale, this::renderHead);
+        renderStage(BodyPart.HEAD, stack, vertices, overlayUv, lightUv, red, green, blue, alpha, this::renderHead);
-        renderStage(BodyPart.LEGS, scale, this::renderLegs);
+        renderStage(BodyPart.LEGS, stack, vertices, overlayUv, lightUv, red, green, blue, alpha, this::renderLegs);
 
         if (textureHeight == 64) {
-            renderStage(BodyPart.LEGS, scale, this::renderSleeves);
+            renderStage(BodyPart.LEGS, stack, vertices, overlayUv, lightUv, red, green, blue, alpha, this::renderSleeves);
-            renderStage(BodyPart.BODY, scale, this::renderVest);
+            renderStage(BodyPart.BODY, stack, vertices, overlayUv, lightUv, red, green, blue, alpha, this::renderVest);
         }
 
-        renderStage(BodyPart.HEAD, scale, this::renderHelmet);
+        renderStage(BodyPart.HEAD, stack, vertices, overlayUv, lightUv, red, green, blue, alpha, this::renderHelmet);
     }
 
-    protected void renderStage(BodyPart part, float scale, Consumer<Float> action) {
+    protected void renderStage(BodyPart part, MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha, RenderStage action) {
-        pushMatrix();
+        stack.push();
-        transform(part);
+        transform(part, stack);
-        action.accept(scale);
+        action.accept(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-        popMatrix();
+        stack.pop();
     }
 
-    protected void renderHead(float scale) {
+    protected void renderHead(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha) {
-        head.render(scale);
+        head.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
     }
 
-    protected void renderHelmet(float scale) {
+    protected void renderHelmet(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha) {
-        helmet.render(scale);
+        helmet.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
     }
 
-    protected void renderNeck(float scale) {
+    protected void renderNeck(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha) {
-        scalef(0.9F, 0.9F, 0.9F);
+        stack.scale(0.9F, 0.9F, 0.9F);
-        neck.render(scale);
+        neck.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
     }
 
-    protected void renderBody(float scale) {
+    protected void renderBody(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha) {
-        torso.render(scale);
+        torso.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-        upperTorso.render(scale);
+        upperTorso.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-        torso.applyTransform(scale);
+        torso.rotate(stack);
-        tail.renderPart(scale, attributes.interpolatorId);
+        tail.renderPart(stack, vertices, overlayUv, lightUv, red, green, blue, alpha, attributes.interpolatorId);
     }
 
-    protected void renderVest(float scale) {
+    protected void renderVest(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha) {
-        jacket.render(scale);
+        jacket.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-        if (jacket.visible) {
+        upperTorsoOverlay.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-            upperTorsoOverlay.render(scale);
-        }
     }
 
-    protected void renderLegs(float scale) {
+    protected void renderLegs(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha) {
         if (!isSneaking) {
-            torso.applyTransform(scale);
+            torso.rotate(stack);
         }
 
-        leftArm.render(scale);
+        leftArm.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-        rightArm.render(scale);
+        rightArm.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-        leftLeg.render(scale);
+        leftLeg.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-        rightLeg.render(scale);
+        rightLeg.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
     }
 
-    protected void renderSleeves(float scale) {
+    protected void renderSleeves(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha) {
-        leftSleeve.render(scale);
+        leftSleeve.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-        rightSleeve.render(scale);
+        rightSleeve.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-        leftPantLeg.render(scale);
+        leftPantLeg.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-        rightPantLeg.render(scale);
+        rightPantLeg.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
     }
 
     @Override
@@ -802,16 +634,20 @@ public abstract class AbstractPonyModel<T extends LivingEntity> extends ClientPo
     }
 
     @Override
-    public void transform(BodyPart part) {
+    public void transform(BodyPart part, MatrixStack stack) {
         if (attributes.isSleeping) {
-            rotatef(90, 1, 0, 0);
+            stack.multiply(Vector3f.POSITIVE_X.getDegreesQuaternion(90));
-            rotatef(180, 0, 1, 0);
+            stack.multiply(Vector3f.POSITIVE_Y.getDegreesQuaternion(180));
         }
 
         if (part == BodyPart.HEAD) {
-           rotatef(attributes.motionPitch, 1, 0, 0);
+           stack.multiply(Vector3f.POSITIVE_X.getDegreesQuaternion(attributes.motionPitch));
         }
 
         PonyTransformation.forSize(getSize()).transform(this, part);
     }
+
+    interface RenderStage {
+        void accept(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha);
+    }
 }

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

@@ -12,8 +12,6 @@ import com.minelittlepony.pony.IPony;
 import com.minelittlepony.pony.IPonyData;
 import com.minelittlepony.pony.meta.Size;
 
-import java.util.Random;
-
 /**
  * The raw pony model without any implementations.
  * Will act effectively the same as a normal player model without any hints
@@ -44,6 +42,12 @@ public abstract class ClientPonyModel<T extends LivingEntity> extends PlayerEnti
         attributes.updateLivingState(entity, pony);
     }
 
+    // Broken bridge
+    @Override
+    public void setAngles(T entity, float move, float swing, float ticks, float headYaw, float headPitch) {
+        super.method_17087(entity, move, swing, ticks, headYaw, headPitch);
+    }
+
     @Override
     public ModelAttributes<?> getAttributes() {
         return attributes;
@@ -102,7 +106,7 @@ public abstract class ClientPonyModel<T extends LivingEntity> extends PlayerEnti
         }
     }
 
-    @Override
+    /*@Override
     public ModelPart getRandomCuboid(Random rand) {
         // grab one at random, but cycle through the list until you find one that's filled.
         // Return if you find one, or if you get back to where you started in which case there isn't any.
@@ -127,5 +131,5 @@ public abstract class ClientPonyModel<T extends LivingEntity> extends PlayerEnti
         }
 
         return result;
-    }
+    }*/
 }

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

@@ -1,6 +1,7 @@
 package com.minelittlepony.client.model;
 
 import net.minecraft.client.model.ModelPart;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.util.Arm;
 
@@ -22,13 +23,8 @@ public interface IPonyMixinModel<T extends LivingEntity, M extends IPonyModel<T>
     }
 
     @Override
-    default void init(float yOffset, float stretch) {
+    default void transform(BodyPart part, MatrixStack stack) {
-        mixin().init(yOffset, stretch);
+        mixin().transform(part, stack);
-    }
-
-    @Override
-    default void transform(BodyPart part) {
-        mixin().transform(part);
     }
 
     @Override
@@ -77,8 +73,8 @@ public interface IPonyMixinModel<T extends LivingEntity, M extends IPonyModel<T>
     }
 
     @Override
-    default void setArmAngle(float angle, Arm side) {
+    default void setArmAngle(Arm arm, MatrixStack stack) {
-        mixin().setArmAngle(angle, side);
+        mixin().setArmAngle(arm, stack);
     }
 
     @Override

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

@@ -2,7 +2,6 @@ package com.minelittlepony.client.model;
 
 import net.minecraft.entity.LivingEntity;
 
-import com.minelittlepony.client.MineLittlePony;
 import com.minelittlepony.model.IModel;
 import com.minelittlepony.model.armour.IArmour;
 import com.minelittlepony.model.armour.IEquestrianArmour;
@@ -18,8 +17,6 @@ public class ModelWrapper<T extends LivingEntity, M extends IModel> implements I
 
     private final IEquestrianArmour<?> armor;
 
-    private int lastModelUpdate = 0;
-
     /**
      * Creates a new model wrapper to contain the given pony.
      */
@@ -27,12 +24,6 @@ public class ModelWrapper<T extends LivingEntity, M extends IModel> implements I
         body = model;
         armor = model.createArmour();
         armor.apply(model.getMetadata());
-
-        try {
-            init();
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
     }
 
     public M getBody() {
@@ -49,20 +40,7 @@ public class ModelWrapper<T extends LivingEntity, M extends IModel> implements I
 
     @Override
     public void apply(IPonyData meta) {
-        int modelRevision = MineLittlePony.getInstance().getModelRevision();
-
-        if (modelRevision != lastModelUpdate) {
-            lastModelUpdate = modelRevision;
-            init();
-        }
-
         body.apply(meta);
         armor.apply(meta);
     }
-
-    @Override
-    public void init() {
-        body.init(0, 0);
-        armor.init();
-    }
 }

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

@@ -24,12 +24,6 @@ public class ArmourWrapper<T extends LivingEntity> implements IEquestrianArmour<
         innerLayer.apply(meta);
     }
 
-    @Override
-    public void init() {
-        outerLayer.init(0, 1.05F);
-        innerLayer.init(0, 0.5F);
-    }
-
     @Override
     public ModelPonyArmour<T> getArmorForLayer(ArmourLayer layer) {
 

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

@@ -1,21 +1,23 @@
 package com.minelittlepony.client.model.armour;
 
 import net.minecraft.client.model.ModelPart;
+import net.minecraft.client.render.VertexConsumer;
 import net.minecraft.client.render.entity.model.BipedEntityModel;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.LivingEntity;
 
 import com.minelittlepony.client.model.AbstractPonyModel;
-import com.minelittlepony.client.util.render.Part;
 import com.minelittlepony.model.IModel;
 import com.minelittlepony.model.armour.ArmourVariant;
 import com.minelittlepony.model.armour.IArmour;
+import com.minelittlepony.mson.api.model.MsonPart;
 
 public class ModelPonyArmour<T extends LivingEntity> extends AbstractPonyModel<T> implements IArmour {
 
-    public Part chestPiece;
+    private ModelPart chestPiece;
 
-    public ModelPart steveRightLeg;
+    private ModelPart steveRightLeg;
-    public ModelPart steveLeftLeg;
+    private ModelPart steveLeftLeg;
 
     private ArmourVariant variant = ArmourVariant.NORMAL;
 
@@ -34,20 +36,20 @@ public class ModelPonyArmour<T extends LivingEntity> extends AbstractPonyModel<T
     }
 
     @Override
-    protected void renderBody(float scale) {
+    protected void renderBody(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float limbDistance, float limbAngle, float tickDelta, float alpha) {
         if (variant == ArmourVariant.LEGACY) {
-            torso.render(scale);
+            torso.render(stack, vertices, overlayUv, lightUv, limbDistance, limbAngle, tickDelta, alpha);
-            upperTorso.render(scale);
+            upperTorso.render(stack, vertices, overlayUv, lightUv, limbDistance, limbAngle, tickDelta, alpha);
         } else {
-            chestPiece.render(scale);
+            chestPiece.render(stack, vertices, overlayUv, lightUv, limbDistance, limbAngle, tickDelta, alpha);
         }
     }
 
     @Override
-    protected void renderLegs(float scale) {
+    protected void renderLegs(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha) {
-        super.renderLegs(scale);
+        super.renderLegs(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-        steveLeftLeg.render(scale);
+        steveLeftLeg.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-        steveRightLeg.render(scale);
+        steveRightLeg.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
     }
 
     @Override
@@ -72,24 +74,24 @@ public class ModelPonyArmour<T extends LivingEntity> extends AbstractPonyModel<T
         }
     }
 
-    @Override
+    @Deprecated
-    protected void initEars(Part head, float yOffset, float stretch) {
+    protected void initEars(ModelPart head, float yOffset, float stretch) {
         stretch /= 2;
         head.tex(0, 0).box(-4, -6, 1, 2, 2, 2, stretch)  // right ear
             .tex(0, 4).box( 2, -6, 1, 2, 2, 2, stretch); // left ear
     }
 
-    @Override
+    @Deprecated
     protected void initBody(float yOffset, float stretch) {
         super.initBody(yOffset, stretch);
 
-        chestPiece = new Part(this, 16, 8)
+        chestPiece = new com.minelittlepony.client.util.render.Part(this, 16, 8)
                 .around(HEAD_RP_X, HEAD_RP_Y + yOffset, HEAD_RP_Z)
                  .box(-4, 4, -2, 8, 8, 16, stretch);
 
         // fits the legacy player's torso to our pony bod.
-        upperTorso = new Part(this, 24, 0);
+        upperTorso = new com.minelittlepony.client.util.render.Part(this, 24, 0);
-        upperTorso.offset(BODY_CENTRE_X, BODY_CENTRE_Y, BODY_CENTRE_Z)
+        ((MsonPart)upperTorso).offset(BODY_CENTRE_X, BODY_CENTRE_Y, BODY_CENTRE_Z)
                   .around(HEAD_RP_X, HEAD_RP_Y + yOffset, HEAD_RP_Z)
                   .tex(32, 23).east( 4, -4, -4, 8, 8, stretch)
                               .west(-4, -4, -4, 8, 8, stretch)
@@ -98,19 +100,19 @@ public class ModelPonyArmour<T extends LivingEntity> extends AbstractPonyModel<T
         // it's a little short, so the butt tends to show. :/
     }
 
-    @Override
+    @Deprecated
     protected void preInitLegs() {
-        leftArm = new Part(this, 0, 16).flip();
+        leftArm = (ModelPart)new com.minelittlepony.client.util.render.Part(this, 0, 16).mirror(true, false, false);
-        rightArm = new Part(this, 0, 16);
+        rightArm = new com.minelittlepony.client.util.render.Part(this, 0, 16);
 
-        leftLeg = new Part(this, 48, 8).flip();
+        leftLeg = (ModelPart)new com.minelittlepony.client.util.render.Part(this, 48, 8).mirror(true, false, false);
-        rightLeg = new Part(this, 48, 8);
+        rightLeg = new com.minelittlepony.client.util.render.Part(this, 48, 8);
 
-        steveLeftLeg = new Part(this, 0, 16).flip();
+        steveLeftLeg = (ModelPart)new com.minelittlepony.client.util.render.Part(this, 0, 16).mirror(true, false, false);
-        steveRightLeg = new Part(this, 0, 16);
+        steveRightLeg = new com.minelittlepony.client.util.render.Part(this, 0, 16);
     }
 
-    @Override
+    @Deprecated
     protected void initLegs(float yOffset, float stretch) {
         super.initLegs(yOffset, stretch);
 

src/main/java/com/minelittlepony/client/model/components/BatWings.java

@@ -1,8 +1,9 @@
 package com.minelittlepony.client.model.components;
 
 import net.minecraft.client.model.Model;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.util.math.MatrixStack;
 
-import com.minelittlepony.client.util.render.Part;
 import com.minelittlepony.model.IPegasus;
 
 import com.mojang.blaze3d.platform.GlStateManager;
@@ -15,7 +16,7 @@ public class BatWings<T extends Model & IPegasus> extends PegasusWings<T> {
         super(model, yOffset, stretch);
     }
 
-    @Override
+    @Deprecated
     public void init(float yOffset, float stretch) {
         leftWing = new Wing(pegasus, false, false, yOffset, stretch, 16);
         rightWing = new Wing(pegasus, true, false, yOffset, stretch, 16);
@@ -23,22 +24,22 @@ public class BatWings<T extends Model & IPegasus> extends PegasusWings<T> {
     }
 
     @Override
-    public void renderPart(float scale, UUID interpolatorId) {
+    public void renderPart(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha, UUID interpolatorId) {
-        GlStateManager.pushMatrix();
+        stack.push();
-        GlStateManager.scalef(1.3F, 1.3F, 1.3F);
+        stack.scale(1.3F, 1.3F, 1.3F);
 
-        super.renderPart(scale, interpolatorId);
+        super.renderPart(stack, vertices, overlayUv, lightUv, red, green, blue, alpha, interpolatorId);
 
-        GlStateManager.popMatrix();
+        stack.pop();
     }
 
-    public class Wing extends PegasusWings<T>.Wing {
+    public class Wing extends PegasusWings.Wing {
 
         public Wing(T pegasus, boolean right, boolean legacy, float y, float scale, int texY) {
             super(pegasus, right, legacy, y, scale, texY);
         }
 
-        @Override
+        @Deprecated
         protected void addClosedWing(boolean right, float y, float scale) {
             float x = right ? -3.5F : 3.5F;
 
@@ -51,7 +52,7 @@ public class BatWings<T extends Model & IPegasus> extends PegasusWings<T> {
                   .pitch = ROTATE_90;
         }
 
-        @Override
+        @Deprecated
         protected void addFeathers(boolean right, boolean l, float rotationPointY, float scale) {
             float r = right ? -1 : 1;
 

src/main/java/com/minelittlepony/client/model/components/BugWings.java

@@ -5,31 +5,27 @@ import net.minecraft.client.model.Model;
 import com.minelittlepony.client.util.render.Part;
 import com.minelittlepony.model.IPegasus;
 
+@Deprecated
 public class BugWings<T extends Model & IPegasus> extends PegasusWings<T> {
 
     public BugWings(T model, float yOffset, float stretch) {
         super(model, yOffset, stretch);
     }
 
-    @Override
+    @Deprecated
     public void init(float yOffset, float stretch) {
         leftWing = new Wing(pegasus, false, false, yOffset, stretch, 16);
         rightWing = new Wing(pegasus, true, false, yOffset, stretch, 16);
         legacyWing = rightWing;
     }
 
-    public class Wing extends PegasusWings<T>.Wing {
+    public class Wing extends PegasusWings.Wing {
 
         public Wing(T pegasus, boolean right, boolean legacy, float y, float scale, int texY) {
             super(pegasus, right, legacy, y, scale, texY);
         }
 
-        @Override
+        @Deprecated
-        protected void addClosedWing(boolean right, float y, float scale) {
-
-        }
-
-        @Override
         protected void addFeathers(boolean right, boolean l, float rotationPointY, float scale) {
             float r = right ? -1 : 1;
 
@@ -50,10 +46,5 @@ public class BugWings<T extends Model & IPegasus> extends PegasusWings<T> {
             extended.child(primary);
             extended.child(secondary);
         }
-
-        @Override
-        public void render(float scale) {
-            extended.render(scale);
-        }
     }
 }

src/main/java/com/minelittlepony/client/model/components/ModelDeadMau5Ears.java

@@ -2,16 +2,18 @@ package com.minelittlepony.client.model.components;
 
 import net.minecraft.client.render.entity.model.SkullEntityModel;
 
+import com.minelittlepony.mson.api.model.BoxBuilder;
+
 public class ModelDeadMau5Ears extends SkullEntityModel {
 
     public ModelDeadMau5Ears() {
         super(24, 0, 64, 64);
-        skull.cuboids.clear();
+        ((BoxBuilder.ContentAccessor)skull).cubes().clear();
         skull.addCuboid(-9, -13, -1, 6, 6, 1, 0);
         skull.addCuboid(3, -13, -1, 6, 6, 1, 0);
     }
 
     public void setVisible(boolean show) {
-        skull.field_3664 = !show;
+        skull.visible = show;
     }
 }

src/main/java/com/minelittlepony/client/model/components/PegasusWings.java

@@ -1,13 +1,14 @@
 package com.minelittlepony.client.model.components;
 
 import net.minecraft.client.model.Model;
+import net.minecraft.client.model.ModelPart;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.util.math.MathHelper;
 
-import com.minelittlepony.client.util.render.Part;
 import com.minelittlepony.model.IPart;
 import com.minelittlepony.model.IPegasus;
 import com.minelittlepony.pony.meta.Wearable;
-import com.mojang.blaze3d.platform.GlStateManager;
 
 import java.util.UUID;
 
@@ -22,16 +23,6 @@ public class PegasusWings<T extends Model & IPegasus> implements IPart {
 
     public PegasusWings(T model, float yOffset, float stretch) {
         pegasus = model;
-
-        init(yOffset, stretch);
-    }
-
-    @Override
-    public void init(float yOffset, float stretch) {
-        leftWing = new Wing(pegasus, false, false, yOffset, stretch, 32);
-        rightWing = new Wing(pegasus, true, false, yOffset, stretch, 16);
-
-        legacyWing = new Wing(pegasus, true, true, yOffset, stretch, 32);
     }
 
     public Wing getLeft() {
@@ -80,53 +71,20 @@ public class PegasusWings<T extends Model & IPegasus> implements IPart {
     }
 
     @Override
-    public void renderPart(float scale, UUID interpolatorId) {
+    public void renderPart(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha, UUID interpolatorId) {
-        getLeft().render(scale);
+        getLeft().render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-        getRight().render(scale);
+        getRight().render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
     }
 
-    public class Wing {
+    public static class Wing {
 
-        protected final T pegasus;
+        private IPegasus pegasus;
 
-        protected final Part extended;
+        private ModelPart extended;
-        protected final Part folded;
+        private ModelPart folded;
 
-        public Wing(T pegasus, boolean right, boolean legacy, float y, float scale, int texY) {
+        public Wing(IPegasus pegasus) {
             this.pegasus = pegasus;
-
-            folded = new Part(pegasus, 56, texY).mirror(legacy);
-            extended = new Part(pegasus, 56 + ((!right || legacy) ? 1 : 0), texY + 3);
-
-            addClosedWing(right, y, scale);
-            addFeathers(right, legacy, y, scale);
-        }
-
-        protected void addClosedWing(boolean right, float y, float scale) {
-            float x = right ? -6 : 4;
-
-            folded.around(HEAD_RP_X, WING_FOLDED_RP_Y + y, WING_FOLDED_RP_Z)
-                  .box(x, 5, 2, 2, 6, 2, scale)
-                  .box(x, 5, 4, 2, 8, 2, scale)
-                  .box(x, 5, 6, 2, 6, 2, scale)
-                  .pitch = ROTATE_90;
-        }
-
-        protected void addFeathers(boolean right, boolean l, float rotationPointY, float scale) {
-            float r = right ? -1 : 1;
-
-            extended.around(r * EXT_WING_RP_X, EXT_WING_RP_Y + rotationPointY, EXT_WING_RP_Z)
-                    .yaw = r * 3;
-            addFeather(0, l,  6,     0,    9, scale + 0.1F);
-            addFeather(1, l, -1,    -0.3F, 8, scale + 0.1F) .pitch = -0.85F;
-            addFeather(2, l,  1.8F,  1.3F, 8, scale - 0.1F) .pitch = -0.75F;
-            addFeather(3, l,  5,     2,    8, scale)        .pitch = -0.5F;
-            addFeather(4, l,  0,   -0.2F,  6, scale + 0.3F);
-            addFeather(5, l,  0,     0,    3, scale + 0.19F).pitch = -0.85F;
-        }
-
-        private Part addFeather(int i, boolean l, float y, float z, int h, float scale) {
-            return extended.child(i).around(0, 0, 0).mirror(l).box(-0.5F, y, z, 1, h, 2, scale);
         }
 
         public void rotateWalking(float swing) {
@@ -137,18 +95,18 @@ public class PegasusWings<T extends Model & IPegasus> implements IPart {
             extended.roll = angle;
         }
 
-        public void render(float scale) {
+        public void render(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha) {
             if (pegasus.wingsAreOpen()) {
-                extended.render(scale);
+                extended.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
             } else {
                 boolean bags = pegasus.isWearing(Wearable.SADDLE_BAGS);
                 if (bags) {
-                    GlStateManager.pushMatrix();
+                    stack.push();
-                    GlStateManager.translatef(0, 0, 0.198F);
+                    stack.translate(0, 0, 0.198F);
                 }
-                folded.render(scale);
+                folded.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
                 if (bags) {
-                    GlStateManager.popMatrix();
+                    stack.pop();
                 }
             }
         }

src/main/java/com/minelittlepony/client/model/components/PonyEars.java

@@ -2,6 +2,9 @@ package com.minelittlepony.client.model.components;
 
 import net.minecraft.client.model.Model;
 import net.minecraft.client.model.ModelPart;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.util.math.MatrixStack;
+
 import com.minelittlepony.client.util.render.Part;
 import com.minelittlepony.model.ICapitated;
 import com.minelittlepony.model.IPart;
@@ -39,7 +42,7 @@ public class PonyEars implements IPart {
     }
 
     @Override
-    public void renderPart(float scale, UUID interpolatorId) {
+    public void renderPart(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha, UUID interpolatorId) {
     }
 
     @Override

src/main/java/com/minelittlepony/client/model/components/PonyElytra.java

@@ -1,20 +1,23 @@
 package com.minelittlepony.client.model.components;
 
+import net.minecraft.client.model.ModelPart;
 import net.minecraft.client.network.AbstractClientPlayerEntity;
-import net.minecraft.client.render.entity.model.EntityModel;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.render.entity.model.AnimalModel;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.util.math.Vec3d;
 
+import com.google.common.collect.ImmutableList;
 import com.minelittlepony.client.model.AbstractPonyModel;
 import com.minelittlepony.client.util.render.Part;
-import com.mojang.blaze3d.platform.GlStateManager;
 
 import static com.minelittlepony.model.PonyModelConstants.*;
 
 /**
  * Modified from ModelElytra.
  */
-public class PonyElytra<T extends LivingEntity> extends EntityModel<T> {
+public class PonyElytra<T extends LivingEntity> extends AnimalModel<T> {
 
     public boolean isSneaking;
 
@@ -26,17 +29,25 @@ public class PonyElytra<T extends LivingEntity> extends EntityModel<T> {
         rightWing.flip().box( 0,  0, 0, 10, 20, 2, 1);
     }
 
-    /**
-     * Sets the model's various rotation angles.
-     *
-     * See {@link AbstractPonyModel.render} for an explanation of the various parameters.
-     */
     @Override
-    public void render(T entity, float move, float swing, float ticks, float headYaw, float headPitch, float scale) {
+    protected Iterable<ModelPart> getHeadParts() {
-        GlStateManager.disableRescaleNormal();
+        return ImmutableList.of();
-        GlStateManager.disableCull();
+    }
-        leftWing.render(scale);
+
-        rightWing.render(scale);
+    @Override
+    protected Iterable<ModelPart> getBodyParts() {
+        return ImmutableList.of(leftWing, rightWing);
+    }
+
+    // broken bridge
+    @Override
+    public void accept(ModelPart t) {
+        super.method_22696(t);
+    }
+
+    @Override
+    public void render(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float limbDistance, float limbAngle, float tickDelta, float alpha) {
+        super.render(stack, vertices, overlayUv, lightUv, limbDistance, limbAngle, tickDelta, alpha);
     }
 
     /**
@@ -45,9 +56,7 @@ public class PonyElytra<T extends LivingEntity> extends EntityModel<T> {
      * See {@link AbstractPonyModel.setRotationAngles} for an explanation of the various parameters.
      */
     @Override
-    public void setAngles(T entity, float move, float swing, float ticks, float headYaw, float headPitch, float scale) {
+    public void setAngles(T entity, float limbDistance, float limbAngle, float age, float headYaw, float headPitch) {
-        super.setAngles(entity, move, swing, ticks, headYaw, headPitch, scale);
-
         float rotateX = PI / 2;
         float rotateY = PI / 8;
         float rotateZ = PI / 12;
@@ -96,5 +105,4 @@ public class PonyElytra<T extends LivingEntity> extends EntityModel<T> {
         rightWing.yaw = -leftWing.yaw;
         rightWing.roll = -leftWing.roll;
     }
-
 }

src/main/java/com/minelittlepony/client/model/components/PonySnout.java

@@ -2,10 +2,14 @@ package com.minelittlepony.client.model.components;
 
 import net.minecraft.client.model.Model;
 import net.minecraft.client.model.ModelPart;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.util.math.MatrixStack;
+
 import com.minelittlepony.client.MineLittlePony;
 import com.minelittlepony.client.util.render.Part;
 import com.minelittlepony.model.ICapitated;
 import com.minelittlepony.model.IPart;
+import com.minelittlepony.mson.api.model.MsonPart;
 import com.minelittlepony.pony.meta.Gender;
 
 import java.util.UUID;
@@ -14,8 +18,8 @@ public class PonySnout implements IPart {
 
     public boolean isHidden = false;
 
-    private Part mare;
+    private ModelPart mare;
-    private Part stallion;
+    private ModelPart stallion;
 
     private final ICapitated<ModelPart> head;
 
@@ -34,8 +38,8 @@ public class PonySnout implements IPart {
     }
 
     public void rotate(float x, float y, float z) {
-        mare.rotate(x, y, z);
+        ((MsonPart)mare).rotate(x, y, z);
-        stallion.rotate(x, y, z);
+        ((MsonPart)stallion).rotate(x, y, z);
     }
 
     @Override
@@ -60,13 +64,13 @@ public class PonySnout implements IPart {
     }
 
     @Override
-    public void renderPart(float scale, UUID interpolatorId) {
+    public void renderPart(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha, UUID interpolatorId) {
     }
 
     public void setGender(Gender gender) {
         boolean show = !head.hasHeadGear() && !isHidden && MineLittlePony.getInstance().getConfig().snuzzles.get();
 
-        mare.field_3664 = !(show && gender.isMare());
+        mare.visible = (show && gender.isMare());
-        stallion.field_3664 = !(show && gender.isStallion());
+        stallion.visible = (show && gender.isStallion());
     }
 }

src/main/java/com/minelittlepony/client/model/components/PonyTail.java

@@ -1,6 +1,8 @@
 package com.minelittlepony.client.model.components;
 
 import net.minecraft.client.model.Model;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.util.math.MathHelper;
 
 import com.minelittlepony.client.model.AbstractPonyModel;
@@ -72,12 +74,12 @@ public class PonyTail extends Part implements IPart {
 
     @Override
     public void setVisible(boolean visible) {
-        field_3664 = !visible;
+        this.visible = visible;
     }
 
     @Override
-    public void renderPart(float scale, UUID interpolatorId) {
+    public void renderPart(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha, UUID interpolatorId) {
-        render(scale);
+        render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
     }
 
     private class TailSegment extends Part {

src/main/java/com/minelittlepony/client/model/components/SeaponyTail.java

@@ -8,6 +8,8 @@ import com.mojang.blaze3d.platform.GlStateManager;
 
 import java.util.UUID;
 
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.util.math.MathHelper;
 
 import org.lwjgl.opengl.GL11;
@@ -60,10 +62,10 @@ public class SeaponyTail implements IPart {
     }
 
     @Override
-    public void renderPart(float scale, UUID interpolatorId) {
+    public void renderPart(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha, UUID interpolatorId) {
         GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS);
         GlStateManager.enableBlend();
-        tailBase.render(scale);
+        tailBase.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
         GlStateManager.disableBlend();
         GL11.glPopAttrib();
     }

src/main/java/com/minelittlepony/client/model/components/UnicornHorn.java

@@ -3,6 +3,12 @@ package com.minelittlepony.client.model.components;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.model.Model;
 import net.minecraft.client.model.ModelPart;
+import net.minecraft.client.render.OverlayTexture;
+import net.minecraft.client.render.RenderLayer;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.render.VertexConsumerProvider;
+import net.minecraft.client.util.math.MatrixStack;
+
 import com.minelittlepony.client.util.render.Color;
 import com.minelittlepony.client.util.render.Part;
 import com.minelittlepony.model.ICapitated;
@@ -43,33 +49,18 @@ public class UnicornHorn implements IPart {
     }
 
     @Override
-    public void renderPart(float scale, @Nullable UUID interpolatorId) {
+    public void renderPart(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha, @Nullable UUID interpolatorId) {
         if (isVisible) {
-            horn.render(scale);
+            horn.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
         }
     }
 
-    public void renderMagic(int tint, float scale) {
+    public void renderMagic(MatrixStack stack, int tint) {
         if (isVisible) {
-            glPushAttrib(24577);
+            horn.rotate(stack);
-            disableTexture();
-            disableLighting();
-            enableBlend();
-            blendFunc(GL_SRC_ALPHA, GL_ONE);
 
-            horn.applyTransform(scale);
+            VertexConsumer vertices = MinecraftClient.getInstance().getBufferBuilders().getEntityVertexConsumers().getBuffer(RenderLayer.getTranslucentNoCrumbling());
-
+            glow.render(stack, vertices, OverlayTexture.DEFAULT_UV, 0x0F00F0, Color.r(tint), Color.g(tint), Color.b(tint), 0.4F);
-            MinecraftClient.getInstance().gameRenderer.disableLightmap();
-            Color.glColor(tint, 0.4F);
-
-            glow.render(scale);
-
-            MinecraftClient.getInstance().gameRenderer.enableLightmap();
-
-            enableTexture();
-            enableLighting();
-            disableBlend();
-            glPopAttrib();
         }
     }
 

src/main/java/com/minelittlepony/client/model/entities/ModelBreezie.java

@@ -76,7 +76,7 @@ public class ModelBreezie<T extends LivingEntity> extends BipedEntityModel<T> {
     }
 
     @Override
-    public void method_17087(T entity, float move, float swing, float ticks, float headYaw, float headPitch, float scale) {
+    public void setAngles(T entity, float move, float swing, float ticks, float headYaw, float headPitch) {
 
         head.yaw = headYaw * 0.017453292F;
         head.pitch = headPitch * 0.017453292F;

src/main/java/com/minelittlepony/client/model/entities/ModelEnderStallion.java

@@ -1,14 +1,11 @@
 package com.minelittlepony.client.model.entities;
 
 import net.minecraft.client.model.ModelPart;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.mob.EndermanEntity;
 import net.minecraft.util.math.MathHelper;
 
-import com.minelittlepony.client.model.components.PonySnout;
-import com.minelittlepony.client.util.render.Part;
-
-import com.mojang.blaze3d.platform.GlStateManager;
-
 public class ModelEnderStallion extends ModelSkeletonPony<EndermanEntity> {
 
     public boolean isCarrying;
@@ -17,14 +14,11 @@ public class ModelEnderStallion extends ModelSkeletonPony<EndermanEntity> {
     public boolean isAlicorn;
     public boolean isBoss;
 
-    private Part leftHorn;
+    private ModelPart leftHorn;
-    private Part rightHorn;
+    private ModelPart rightHorn;
 
     public ModelEnderStallion() {
         super();
-        attributes.armRotationX = 3;
-        attributes.armRotationY = 14;
-        attributes.armLength = 30;
         attributes.visualHeight = 3;
     }
 
@@ -37,24 +31,16 @@ public class ModelEnderStallion extends ModelSkeletonPony<EndermanEntity> {
         isAlicorn = entity.getUuid().getLeastSignificantBits() % 3 == 0;
         isBoss = !isAlicorn && entity.getUuid().getLeastSignificantBits() % 90 == 0;
 
-        leftHorn.field_3664 = rightHorn.field_3664 = !isBoss;
+        leftHorn.visible = rightHorn.visible = !isBoss;
         horn.setVisible(!isBoss);
 
-        tail.setVisible(false);
-        snout.isHidden = true;
-        leftSleeve.field_3664 = true;
-        rightSleeve.field_3664 = true;
-
-        leftPantLeg.field_3664 = true;
-        rightPantLeg.field_3664 = true;
-
         leftHorn.pitch = 0.5F;
         rightHorn.pitch = 0.5F;
     }
 
     @Override
-    public void setAngles(EndermanEntity entity, float move, float swing, float ticks, float headYaw, float headPitch, float scale) {
+    public void setAngles(EndermanEntity entity, float move, float swing, float ticks, float headYaw, float headPitch) {
-        super.setAngles(entity, move, swing, ticks, headYaw, headPitch, scale);
+        super.setAngles(entity, move, swing, ticks, headYaw, headPitch);
 
         if (isAttacking) {
             head.pivotY -= 5;
@@ -62,11 +48,11 @@ public class ModelEnderStallion extends ModelSkeletonPony<EndermanEntity> {
     }
 
     @Override
-    public void render(EndermanEntity entity, float move, float swing, float ticks, float headYaw, float headPitch, float scale) {
+    public void render(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha) {
-        GlStateManager.pushMatrix();
+        stack.push();
-        GlStateManager.translatef(0, -1.15F, 0);
+        stack.translate(0, -1.15F, 0);
-        super.render(entity, move, swing, ticks, headYaw, headPitch, scale);
+        super.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-        GlStateManager.popMatrix();
+        stack.pop();
     }
 
     @Override
@@ -74,65 +60,27 @@ public class ModelEnderStallion extends ModelSkeletonPony<EndermanEntity> {
         return isAlicorn;
     }
 
-    @Override
-    protected void initHead(float yOffset, float stretch) {
-        head = new Part(this, 0, 0)
-                                 .offset(HEAD_CENTRE_X, HEAD_CENTRE_Y, HEAD_CENTRE_Z)
-                                 .around(HEAD_RP_X, HEAD_RP_Y + yOffset, HEAD_RP_Z - 2)
-                                 .box(-4, -4, -4, 8, 8, 8, stretch)
-                     .tex(12, 16).box(-4, -6, 1, 2, 2, 2, stretch)
-                          .flip().box( 2, -6, 1, 2, 2, 2, stretch);
-
-        leftHorn = ((Part)head).child().tex(0, 52);
-        leftHorn.tex(0, 52)
-                .rotate(0.1F, 0, -0.8F)
-                .offset(-2, -10, -3)
-                .box(0, 0, 0, 2, 6, 2, stretch)
-                .child()
-                    .rotate(0, 0, 0.9F)
-                    .around(-3.9F, -6, 0.001F)
-                    .box(0, 0, 0, 2, 6, 2, stretch);
-
-        rightHorn = ((Part)head).child().tex(0, 52);
-        rightHorn.tex(8, 52)
-                .rotate(0.1F, 0, 0.8F)
-                .offset(0, -10, -3)
-                .box(0, 0, 0, 2, 6, 2, stretch)
-                .child()
-                    .rotate(0, 0, -0.9F)
-                    .around(3.9F, -6, 0.001F)
-                    .box(0, 0, 0, 2, 6, 2, stretch);
-
-        helmet = new Part(this, 32, 0)
-                                     .offset(HEAD_CENTRE_X, HEAD_CENTRE_Y, HEAD_CENTRE_Z)
-                                     .around(HEAD_RP_X, HEAD_RP_Y + yOffset, HEAD_RP_Z - 2)
-                                     .box(-4, -4, -4, 8, 8, 8, stretch - 0.5F);
-
-        snout = new PonySnout(this);
-        snout.init(yOffset, stretch);
-    }
-
     @Override
     public void rotateArmHolding(ModelPart arm, float direction, float swingProgress, float ticks) {
         arm.pitch = -0.3707964F;
         arm.pitch += 0.4F + MathHelper.sin(ticks * 0.067F) / 10;
     }
 
-    @Override
-    protected void preInitLegs() {
-        leftArm = new ModelPart(this, 0, 20);
-        rightArm = new ModelPart(this, 0, 20);
-
-        leftLeg = new ModelPart(this, 0, 20);
-        rightLeg = new ModelPart(this, 0, 20);
-    }
-
     @Override
     public void setVisible(boolean visible) {
         super.setVisible(visible);
 
+        tail.setVisible(false);
+
+        snout.isHidden = true;
         leftHorn.visible = visible;
         rightHorn.visible = visible;
+
+        leftSleeve.visible = false;
+        rightSleeve.visible = false;
+
+        leftPantLeg.visible = false;
+        rightPantLeg.visible = false;
     }
 
     @Override

src/main/java/com/minelittlepony/client/model/entities/ModelGuardianPony.java

@@ -1,23 +1,25 @@
 package com.minelittlepony.client.model.entities;
 
+import net.minecraft.client.model.ModelPart;
+import net.minecraft.client.render.VertexConsumer;
 import net.minecraft.client.render.entity.model.EntityModel;
 import net.minecraft.client.render.entity.model.GuardianEntityModel;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.mob.GuardianEntity;
 
 import com.minelittlepony.client.model.IPonyMixinModel;
-import com.minelittlepony.client.util.render.Part;
 
-public class ModelGuardianPony extends GuardianEntityModel implements IPonyMixinModel.Caster<GuardianEntity, ModelSeapony<GuardianEntity>, Part> {
+public class ModelGuardianPony extends GuardianEntityModel implements IPonyMixinModel.Caster<GuardianEntity, ModelSeapony<GuardianEntity>, ModelPart> {
     private final ModelSeapony<GuardianEntity> mixin = new ModelSeapony<>();
 
     @Override
-    public void setAngles(GuardianEntity entity, float move, float swing, float ticks, float headYaw, float headPitch, float scale) {
+    public void setAngles(GuardianEntity entity, float move, float swing, float ticks, float headYaw, float headPitch) {
-        mixin().setAngles(entity, move, swing, ticks, headYaw, headPitch, scale);
+        mixin().setAngles(entity, move, swing, ticks, headYaw, headPitch);
     }
 
     @Override
-    public void render(GuardianEntity entity, float move, float swing, float ticks, float headYaw, float headPitch, float scale) {
+    public void render(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float limbDistance, float limbAngle, float tickDelta, float alpha) {
-        mixin().render(entity, move, swing, ticks, headYaw, headPitch, scale);
+        mixin().render(stack, vertices, overlayUv, lightUv, limbDistance, limbAngle, tickDelta, alpha);
     }
 
     @Override

src/main/java/com/minelittlepony/client/model/entities/ModelIllagerPony.java

@@ -14,8 +14,8 @@ public class ModelIllagerPony<T extends IllagerEntity> extends ModelAlicorn<T> {
     }
 
     @Override
-    public void setAngles(T illager, float move, float swing, float ticks, float headYaw, float headPitch, float scale) {
+    public void setAngles(T illager, float move, float swing, float ticks, float headYaw, float headPitch) {
-        super.setAngles(illager, move, swing, ticks, headYaw, headPitch, scale);
+        super.setAngles(illager, move, swing, ticks, headYaw, headPitch);
 
         IllagerEntity.State pose = illager.getState();
 

src/main/java/com/minelittlepony/client/model/entities/ModelSeapony.java

@@ -11,6 +11,9 @@ import com.minelittlepony.model.armour.IEquestrianArmour;
 import com.minelittlepony.pony.IPony;
 import com.mojang.blaze3d.platform.GlStateManager;
 
+import net.minecraft.client.model.ModelPart;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.util.math.MathHelper;
 
@@ -18,11 +21,11 @@ import org.lwjgl.opengl.GL11;
 
 public class ModelSeapony<T extends LivingEntity> extends ModelUnicorn<T> {
 
-    Part bodyCenter;
+    private ModelPart bodyCenter;
 
-    Part leftFin;
+    private ModelPart leftFin;
-    Part centerFin;
+    private ModelPart centerFin;
-    Part rightFin;
+    private ModelPart rightFin;
 
     public ModelSeapony(boolean smallArms) {
         super(smallArms);
@@ -57,7 +60,7 @@ public class ModelSeapony<T extends LivingEntity> extends ModelUnicorn<T> {
         // noop
     }
 
-    @Override
+    @Deprecated
     protected void initLegs(float yOffset, float stretch) {
         super.initLegs(yOffset, stretch);
         // hide the back legs
@@ -79,13 +82,13 @@ public class ModelSeapony<T extends LivingEntity> extends ModelUnicorn<T> {
                 .west(0, 0, 0, 12, 8, stretch);
     }
 
-    @Override
+    @Deprecated
     protected void initTail(float yOffset, float stretch) {
         tail = new SeaponyTail(this);
         tail.init(yOffset, stretch);
     }
 
-    @Override
+    @Deprecated
     protected void initBody(float yOffset, float stretch) {
         super.initBody(yOffset, stretch);
         bodyCenter = new Part(this, 0, 48)
@@ -94,8 +97,8 @@ public class ModelSeapony<T extends LivingEntity> extends ModelUnicorn<T> {
     }
 
     @Override
-    public void setAngles(T entity, float move, float swing, float ticks, float headYaw, float headPitch, float scale) {
+    public void setAngles(T entity, float move, float swing, float ticks, float headYaw, float headPitch) {
-        super.setAngles(entity, move, swing, ticks, headYaw, headPitch, scale);
+        super.setAngles(entity, move, swing, ticks, headYaw, headPitch);
 
         float flapMotion = MathHelper.cos(ticks / 10) / 5;
 
@@ -138,37 +141,34 @@ public class ModelSeapony<T extends LivingEntity> extends ModelUnicorn<T> {
     }
 
     @Override
-    public void render(T entity, float move, float swing, float ticks, float headYaw, float headPitch, float scale) {
+    public void render(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha) {
         setVisible(leftSleeve.visible);
 
-        super.render(entity, move, swing, ticks, headYaw, headPitch, scale);
+        super.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
     }
 
     @Override
-    public void transform(BodyPart part) {
+    public void transform(BodyPart part, MatrixStack stack) {
-        GlStateManager.translatef(0, 0.6F, 0);
+        stack.translate(0, 0.6F, 0);
-
+        super.transform(part, stack);
-        super.transform(part);
     }
 
     @Override
-    protected void renderBody(float scale) {
+    protected void renderBody(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha) {
-        torso.render(scale);
+        torso.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-        bodyCenter.render(scale);
+        bodyCenter.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-        torso.applyTransform(scale);
+        torso.rotate(stack);
 
-        tail.renderPart(scale, attributes.interpolatorId);
+        tail.renderPart(stack, vertices, overlayUv, lightUv, red, green, blue, alpha, attributes.interpolatorId);
 
-        GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS);
         GlStateManager.enableBlend();
 
 
-        leftFin.render(scale);
+        leftFin.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-        centerFin.render(scale);
+        centerFin.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-        rightFin.render(scale);
+        rightFin.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
 
         GlStateManager.disableBlend();
-        GL11.glPopAttrib();
     }
 
     @Override
@@ -215,10 +215,10 @@ public class ModelSeapony<T extends LivingEntity> extends ModelUnicorn<T> {
         }
 
         @Override
-        public void transform(BodyPart part) {
+        public void transform(BodyPart part, MatrixStack stack) {
-            GlStateManager.translatef(0, 0.6F, 0);
+            stack.translate(0, 0.6F, 0);
 
-            super.transform(part);
+            super.transform(part, stack);
         }
     }
 }

src/main/java/com/minelittlepony/client/model/entities/ModelSkeletonPony.java

@@ -1,6 +1,8 @@
 package com.minelittlepony.client.model.entities;
 
 import net.minecraft.entity.mob.WitherSkeletonEntity;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.mob.HostileEntity;
 import net.minecraft.item.Items;
 import net.minecraft.item.ItemStack;
@@ -18,17 +20,13 @@ public class ModelSkeletonPony<T extends HostileEntity> extends ModelAlicorn<T>
 
     public ModelSkeletonPony() {
         super(false);
-        attributes.armWidth = 2;
-        attributes.armDepth = 2;
-        attributes.armRotationX = 3F;
-        attributes.armRotationY = 8F;
     }
 
     @Override
-    protected void renderVest(float scale) { }
+    protected void renderVest(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha) { }
 
     @Override
-    protected void renderSleeves(float scale) { }
+    protected void renderSleeves(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha) { }
 
     @Override
     public void animateModel(T entity, float move, float swing, float ticks) {

src/main/java/com/minelittlepony/client/model/entities/ModelVillagerPony.java

@@ -1,6 +1,9 @@
 package com.minelittlepony.client.model.entities;
 
+import net.minecraft.client.model.ModelPart;
+import net.minecraft.client.render.VertexConsumer;
 import net.minecraft.client.render.entity.model.ModelWithHat;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.entity.passive.AbstractTraderEntity;
 import net.minecraft.util.math.MathHelper;
@@ -11,14 +14,13 @@ import com.minelittlepony.client.model.components.BatWings;
 import com.minelittlepony.client.model.components.PonyEars;
 import com.minelittlepony.client.model.races.ModelAlicorn;
 import com.minelittlepony.client.render.entities.villager.PonyTextures;
-import com.minelittlepony.client.util.render.Part;
 import com.minelittlepony.model.IPart;
 import com.minelittlepony.pony.meta.Race;
 
 public class ModelVillagerPony<T extends LivingEntity & VillagerDataContainer> extends ModelAlicorn<T> implements ModelWithHat {
 
-    private Part apron;
+    private ModelPart apron;
-    private Part trinket;
+    private ModelPart trinket;
 
     private IPart batWings;
 
@@ -65,10 +67,10 @@ public class ModelVillagerPony<T extends LivingEntity & VillagerDataContainer> e
     }
 
     @Override
-    protected void renderBody(float scale) {
+    protected void renderBody(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha) {
-        super.renderBody(scale);
+        super.renderBody(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-        apron.render(scale);
+        apron.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-        //trinket.render(scale);
+        //trinket.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
     }
 
     @Override
@@ -90,8 +92,8 @@ public class ModelVillagerPony<T extends LivingEntity & VillagerDataContainer> e
     }
 
     @Override
-    public void setAngles(T entity, float move, float swing, float ticks, float headYaw, float headPitch, float scale) {
+    public void setAngles(T entity, float move, float swing, float ticks, float headYaw, float headPitch) {
-        super.setAngles(entity, move, swing, ticks, headYaw, headPitch, scale);
+        super.setAngles(entity, move, swing, ticks, headYaw, headPitch);
 
         boolean isHeadRolling = entity instanceof AbstractTraderEntity
                 && ((AbstractTraderEntity)entity).getHeadRollingTimeLeft() > 0;

src/main/java/com/minelittlepony/client/model/entities/ModelWitchPony.java

@@ -26,8 +26,8 @@ public class ModelWitchPony extends ModelZebra<WitchEntity> {
     }
 
     @Override
-    public void setAngles(WitchEntity entity, float move, float swing, float ticks, float headYaw, float headPitch, float scale) {
+    public void setAngles(WitchEntity entity, float move, float swing, float ticks, float headYaw, float headPitch) {
-        super.setAngles(entity, move, swing, ticks, headYaw, headPitch, scale);
+        super.setAngles(entity, move, swing, ticks, headYaw, headPitch);
 
         if (entity.isDrinking()) {
             float noseRot = MathHelper.sin(entity.age);
@@ -49,8 +49,8 @@ public class ModelWitchPony extends ModelZebra<WitchEntity> {
             rightSleeve.pitch = legDrinkingAngle;
             rightArm.yaw = 0.1F;
             rightSleeve.yaw = 0.1F;
-            rightArm.z = 0.1F;
+            rightArm.pivotX = 0.1F;
-            rightSleeve.z = 0.1F;
+            rightSleeve.pivotX = 0.1F;
 
             if (rot > 0) {
                 rot = 0;
@@ -59,8 +59,8 @@ public class ModelWitchPony extends ModelZebra<WitchEntity> {
             head.pitch = -rot / 2;
             helmet.pitch = -rot / 2;
         } else {
-            rightArm.z = 0;
+            rightArm.pivotX = 0;
-            rightSleeve.z = 0;
+            rightSleeve.pivotX = 0;
         }
     }
 

src/main/java/com/minelittlepony/client/model/entities/ModelZombiePony.java

@@ -2,14 +2,14 @@ package com.minelittlepony.client.model.entities;
 
 import com.minelittlepony.client.model.IMobModel;
 import com.minelittlepony.client.model.races.ModelAlicorn;
-import com.minelittlepony.client.util.render.Part;
+import com.minelittlepony.mson.api.model.MsonPart;
 
 import net.minecraft.entity.mob.HostileEntity;
 import net.minecraft.util.math.MathHelper;
 
 public class ModelZombiePony<Zombie extends HostileEntity> extends ModelAlicorn<Zombie> implements IMobModel {
 
-    public boolean isPegasus;
+    private boolean isPegasus;
 
     public ModelZombiePony() {
         super(false);
@@ -23,14 +23,15 @@ public class ModelZombiePony<Zombie extends HostileEntity> extends ModelAlicorn<
     @Override
     protected void rotateLegs(float move, float swing, float ticks, Zombie entity) {
         super.rotateLegs(move, swing, ticks, entity);
-        if (rightArmPose != ArmPose.EMPTY) return;
 
+        if (rightArmPose == ArmPose.EMPTY) {
             if (islookAngleRight(move)) {
                 rotateArmHolding(rightArm, 1, getSwingAmount(), ticks);
-            Part.shiftRotationPoint(rightArm, 0.5F, 1.5F, 3);
+                ((MsonPart)rightArm).shift(0.5F, 1.5F, 3);
             } else {
                 rotateArmHolding(leftArm, -1, getSwingAmount(), ticks);
-            Part.shiftRotationPoint(leftArm, -0.5F, 1.5F, 3);
+                ((MsonPart)leftArm).shift(-0.5F, 1.5F, 3);
+            }
         }
     }
 

src/main/java/com/minelittlepony/client/model/entities/ModelZombieVillagerPony.java

@@ -4,21 +4,22 @@ import net.minecraft.entity.mob.ZombieVillagerEntity;
 import net.minecraft.util.math.MathHelper;
 
 import com.minelittlepony.client.model.IMobModel;
-import com.minelittlepony.client.util.render.Part;
+import com.minelittlepony.mson.api.model.MsonPart;
 
 public class ModelZombieVillagerPony extends ModelVillagerPony<ZombieVillagerEntity> implements IMobModel {
 
     @Override
     protected void rotateLegs(float move, float swing, float ticks, ZombieVillagerEntity entity) {
         super.rotateLegs(move, swing, ticks, entity);
-        if (rightArmPose != ArmPose.EMPTY) return;
 
+        if (rightArmPose == ArmPose.EMPTY) {
             if (islookAngleRight(move)) {
                 rotateArmHolding(rightArm, 1, getSwingAmount(), ticks);
-            Part.shiftRotationPoint(rightArm, 0.5F, 1.5F, 3);
+                ((MsonPart)rightArm).shift(0.5F, 1.5F, 3);
             } else {
                 rotateArmHolding(leftArm, -1, getSwingAmount(), ticks);
-            Part.shiftRotationPoint(leftArm, -0.5F, 1.5F, 3);
+                ((MsonPart)leftArm).shift(-0.5F, 1.5F, 3);
+            }
         }
     }
 

src/main/java/com/minelittlepony/client/model/gear/AbstractGear.java

@@ -1,15 +1,41 @@
 package com.minelittlepony.client.model.gear;
 
 import net.minecraft.client.model.Model;
+import net.minecraft.client.model.ModelPart;
+import net.minecraft.client.render.RenderLayer;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.util.math.MatrixStack;
 
 import com.minelittlepony.model.gear.IGear;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
 public abstract class AbstractGear extends Model implements IGear {
 
+    private final List<ModelPart> parts = new ArrayList<>();
+
     public AbstractGear() {
+        super(RenderLayer::getEntitySolid);
         textureWidth = 64;
         textureHeight = 64;
+    }
 
-        init(0, 0);
+    @Override
+    public void accept(ModelPart t) {
+        parts.add(t);
+    }
+
+    @Override
+    public void renderPart(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha, UUID interpolatorId) {
+        render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
+    }
+
+    @Override
+    public void render(MatrixStack stack, VertexConsumer renderContext, int overlayUv, int lightUv, float red, float green, float blue, float alpha) {
+        parts.forEach(part -> {
+            part.render(stack, renderContext, overlayUv, lightUv, red, green, blue, alpha);
+        });
     }
 }

src/main/java/com/minelittlepony/client/model/gear/ChristmasHat.java

@@ -1,5 +1,8 @@
 package com.minelittlepony.client.model.gear;
 
+import net.minecraft.client.model.ModelPart;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.Entity;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.math.MathHelper;
@@ -26,23 +29,23 @@ public class ChristmasHat extends AbstractGear {
 
     @Override
     public void init(float yOffset, float stretch) {
-        left = new Part(this, 0, 0).size(16, 8)
+        accept(left = new Part(this, 0, 0).size(16, 8)
                 .around(-7, 0.5F, 0.5F)
                 .offset(-7, 0, 0)
                 .at(3, -4, 0)
                 .box(0, 0, 0, 7, 1, 1, stretch)
                 .tex(0, 2).box(0, -1, 0, 1, 1, 1, stretch)
                 .tex(4, 2).box(2, -1, 0, 1, 1, 1, stretch)
-                .tex(8, 2).box(4, -1, 0, 1, 1, 1, stretch);
+                .tex(8, 2).box(4, -1, 0, 1, 1, 1, stretch));
 
-        right = new Part(this, 0, 4).size(16, 8)
+        accept(right = new Part(this, 0, 4).size(16, 8)
                 .around(7, 0.5F, 0.5F)
                 .offset(0, 0, 0)
                 .at(-3, -4, 0)
                 .box(0, 0, 0, 7, 1, 1, stretch)
                 .tex(0, 6).box(6, -1, 0, 1, 1, 1, stretch)
                 .tex(4, 6).box(4, -1, 0, 1, 1, 1, stretch)
-                .tex(8, 6).box(2, -1, 0, 1, 1, 1, stretch);
+                .tex(8, 6).box(2, -1, 0, 1, 1, 1, stretch));
     }
 
     @Override
@@ -87,17 +90,15 @@ public class ChristmasHat extends AbstractGear {
     }
 
     @Override
-    public void renderPart(float scale, UUID interpolatorId) {
+    public void renderPart(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha, UUID interpolatorId) {
         GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS);
 
         if (tint != 0) {
             Color.glColor(tint, 1);
         }
 
-        left.render(scale);
+        super.render(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-        right.render(scale);
 
         GL11.glPopAttrib();
     }
-
 }

src/main/java/com/minelittlepony/client/model/gear/Muffin.java

@@ -15,22 +15,15 @@ public class Muffin extends AbstractGear implements IStackable {
 
     private static final Identifier TEXTURE = new Identifier("minelittlepony", "textures/models/muffin.png");
 
-    private Part crown;
-
     @Override
     public void init(float yOffset, float stretch) {
-        crown = new Part(this, 0, 0).size(64, 44)
+        this.accept(new Part(this, 0, 0).size(64, 44)
                 .around(-4, -12, -6)
                 .box(0, 0, 0, 8, 4, 8, stretch)
                 .box(3, -1.5F, 3, 2, 2, 2, stretch)
                 .tex(0, 12).box(1.5F, -1, 1.5F, 5, 1, 5, stretch)
                 .tex(0, 18).box(2, 1, 1, 4, 7, 6, stretch)
-                .tex(0, 18).box(1, 1, 2, 6, 7, 4, stretch);
+                .tex(0, 18).box(1, 1, 2, 6, 7, 4, stretch));
-    }
-
-    @Override
-    public void renderPart(float scale, UUID interpolatorId) {
-        crown.render(scale);
     }
 
     @Override

src/main/java/com/minelittlepony/client/model/gear/SaddleBags.java

@@ -10,6 +10,9 @@ import com.mojang.blaze3d.platform.GlStateManager;
 
 import java.util.UUID;
 
+import net.minecraft.client.model.ModelPart;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.Entity;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.math.MathHelper;
@@ -18,10 +21,10 @@ public class SaddleBags extends AbstractGear {
 
     public static final Identifier TEXTURE = new Identifier("minelittlepony", "textures/models/saddlebags.png");
 
-    private Part leftBag;
+    private ModelPart leftBag;
-    private Part rightBag;
+    private ModelPart rightBag;
 
-    private Part strap;
+    private ModelPart strap;
 
     private boolean hangLow = false;
 
@@ -64,7 +67,7 @@ public class SaddleBags extends AbstractGear {
 
         x += 3;
 
-        rightBag.offset(-x, y, z).around(0, 4, 4).flip()
+        rightBag.offset(-x, y, z).around(0, 4, 4).flipX()
                 .tex(56, 25).south(0, 0, 0, 3, 6, stretch)
                 .tex(59, 25).south(0, 0, 8, 3, 6, stretch)
                 .tex(56, 19).west(3, 0, 0, 6, 8, stretch)
@@ -114,18 +117,17 @@ public class SaddleBags extends AbstractGear {
     }
 
     @Override
-    public void renderPart(float scale, UUID interpolatorId) {
+    public void renderPart(MatrixStack stack, VertexConsumer renderContext, int overlayUv, int lightUv, float red, float green, float blue, float alpha, UUID interpolatorId) {
         dropAmount = model.getMetadata().getInterpolator(interpolatorId).interpolate("dropAmount", dropAmount, 3);
 
-        GlStateManager.pushMatrix();
+        stack.push();
-        GlStateManager.translatef(0, dropAmount, 0);
+        stack.translate(0, dropAmount, 0);
 
-        leftBag.render(scale);
+        leftBag.render(stack, renderContext, overlayUv, lightUv, red, green, blue, alpha);
-        rightBag.render(scale);
+        rightBag.render(stack, renderContext, overlayUv, lightUv, red, green, blue, alpha);
 
-
+        stack.pop();
-        GlStateManager.popMatrix();
+        strap.render(stack, renderContext, overlayUv, lightUv, red, green, blue, alpha);
-        strap.render(scale);
     }
 
     @Override

src/main/java/com/minelittlepony/client/model/gear/Stetson.java

@@ -14,17 +14,15 @@ import java.util.UUID;
 public class Stetson extends AbstractGear implements IStackable {
     private static final Identifier TEXTURE = new Identifier("minelittlepony", "textures/models/stetson.png");
 
-    private Part rimshot;
-
     @Override
     public void init(float yOffset, float stretch) {
-        rimshot = new Part(this).size(64, 64)
+        accept(rimshot = new Part(this).size(64, 64)
                 .tex(16, 33).top(-9, yOffset - 4, -12, 16, 17, stretch)
                 .tex(0, 33).bottom(-9, yOffset - 3.999F, -12, 16, 17, stretch)
                 .rotate(-0.3F, 0, 0.1F)
                 .child(new Part(this).size(64, 64)
                     .tex(0, 0).box(-5, yOffset - 8, -6, 9, 4, 9, stretch)
-                    .tex(0, 13).box(-6, yOffset - 6, -7, 11, 2, 11, stretch));
+                    .tex(0, 13).box(-6, yOffset - 6, -7, 11, 2, 11, stretch)));
 
         rimshot.child()
             .around(-9, yOffset - 4, -12)
@@ -42,11 +40,6 @@ public class Stetson extends AbstractGear implements IStackable {
         return TEXTURE;
     }
 
-    @Override
-    public void renderPart(float scale, UUID interpolatorId) {
-        rimshot.render(scale);
-    }
-
     @Override
     public boolean canRender(IModel model, Entity entity) {
         return model.isWearing(Wearable.STETSON);

src/main/java/com/minelittlepony/client/model/gear/WitchHat.java

@@ -1,5 +1,6 @@
 package com.minelittlepony.client.model.gear;
 
+import net.minecraft.client.model.ModelPart;
 import net.minecraft.entity.Entity;
 import net.minecraft.util.Identifier;
 
@@ -15,16 +16,11 @@ public class WitchHat extends AbstractGear implements IStackable {
 
     private static final Identifier WITCH_TEXTURES = new Identifier("textures/entity/witch.png");
 
-    private Part witchHat;
+    private ModelPart witchHat;
-
-    @Override
-    public void renderPart(float scale, UUID interpolatorId) {
-        witchHat.render(scale * 1.3F);
-    }
 
     @Override
     public void init(float yOffset, float stretch) {
-        witchHat = new Part(this).size(64, 128);
+        accept(witchHat = new Part(this).size(64, 128));
         witchHat.around(HEAD_RP_X, HEAD_RP_Y + yOffset, HEAD_RP_Z)
                 .tex(0, 64).box(-5, -6, -7, 10, 2, 10, stretch)
                 .child(0).around(1.75F, -4, 2)

src/main/java/com/minelittlepony/client/model/races/ModelAlicorn.java

@@ -1,9 +1,10 @@
 package com.minelittlepony.client.model.races;
 
-import com.minelittlepony.client.model.components.PegasusWings;
 import com.minelittlepony.model.IPart;
 import com.minelittlepony.model.IPegasus;
 
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.LivingEntity;
 
 public class ModelAlicorn<T extends LivingEntity> extends ModelUnicorn<T> implements IPegasus {
@@ -20,18 +21,8 @@ public class ModelAlicorn<T extends LivingEntity> extends ModelUnicorn<T> implem
     }
 
     @Override
-    public void init(float yOffset, float stretch) {
+    public void setAngles(T entity, float move, float swing, float ticks, float headYaw, float headPitch) {
-        super.init(yOffset, stretch);
+        super.setAngles(entity, move, swing, ticks, headYaw, headPitch);
-        initWings(yOffset, stretch);
-    }
-
-    protected void initWings(float yOffset, float stretch) {
-        wings = new PegasusWings<>(this, yOffset, stretch);
-    }
-
-    @Override
-    public void setAngles(T entity, float move, float swing, float ticks, float headYaw, float headPitch, float scale) {
-        super.setAngles(entity, move, swing, ticks, headYaw, headPitch, scale);
 
         if (canFly()) {
             getWings().setRotationAndAngles(attributes.isGoingFast, attributes.interpolatorId, move, swing, 0, ticks);
@@ -39,11 +30,11 @@ public class ModelAlicorn<T extends LivingEntity> extends ModelUnicorn<T> implem
     }
 
     @Override
-    protected void renderBody(float scale) {
+    protected void renderBody(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha) {
-        super.renderBody(scale);
+        super.renderBody(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
 
         if (canFly()) {
-            getWings().renderPart(scale, attributes.interpolatorId);
+            getWings().renderPart(stack, vertices, overlayUv, lightUv, red, green, blue, alpha, attributes.interpolatorId);
         }
     }
 

src/main/java/com/minelittlepony/client/model/races/ModelBatpony.java

@@ -2,24 +2,8 @@ package com.minelittlepony.client.model.races;
 
 import net.minecraft.entity.LivingEntity;
 
-import com.minelittlepony.client.model.components.BatWings;
-import com.minelittlepony.client.model.components.PonyEars;
-import com.minelittlepony.client.util.render.Part;
-
 public class ModelBatpony<T extends LivingEntity> extends ModelPegasus<T> {
-
     public ModelBatpony(boolean smallArms) {
         super(smallArms);
     }
-
-    @Override
-    protected void initWings(float yOffset, float stretch) {
-        wings = new BatWings<>(this, yOffset, stretch);
-    }
-
-    @Override
-    protected void initEars(Part head, float yOffset, float stretch) {
-        ears = new PonyEars(head, true);
-        ears.init(yOffset, stretch);
-    }
 }

src/main/java/com/minelittlepony/client/model/races/ModelChangeling.java

@@ -3,19 +3,12 @@ package com.minelittlepony.client.model.races;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.util.math.MathHelper;
 
-import com.minelittlepony.client.model.components.BugWings;
-
 public class ModelChangeling<T extends LivingEntity> extends ModelAlicorn<T> {
 
     public ModelChangeling(boolean smallArms) {
         super(smallArms);
     }
 
-    @Override
-    protected void initWings(float yOffset, float stretch) {
-        wings = new BugWings<>(this, yOffset, stretch);
-    }
-
     @Override
     public boolean wingsAreOpen() {
         return (isFlying() || attributes.isCrouching) && !getAttributes().isGliding;

src/main/java/com/minelittlepony/client/model/races/ModelEarthPony.java

@@ -1,35 +1,26 @@
 package com.minelittlepony.client.model.races;
 
 import com.minelittlepony.client.model.AbstractPonyModel;
-import com.minelittlepony.client.util.render.Part;
 
+import net.minecraft.client.model.ModelPart;
 import net.minecraft.entity.LivingEntity;
 
 public class ModelEarthPony<T extends LivingEntity> extends AbstractPonyModel<T> {
 
     private final boolean smallArms;
 
-    public Part bipedCape;
+    public ModelPart bipedCape;
 
     public ModelEarthPony(boolean smallArms) {
         super(smallArms);
         this.smallArms = smallArms;
-
-        if (smallArms) {
-            attributes.armWidth = 3;
-            attributes.armRotationX = 2F;
-            attributes.armRotationY = 8.5F;
-        }
     }
 
     @Override
-    public void setAngles(T entity, float move, float swing, float ticks, float headYaw, float headPitch, float scale) {
+    public void setAngles(T entity, float move, float swing, float ticks, float headYaw, float headPitch) {
-        super.setAngles(entity, move, swing, ticks, headYaw, headPitch, scale);
+        super.setAngles(entity, move, swing, ticks, headYaw, headPitch);
-
-        if (bipedCape != null) {
         bipedCape.pivotY = isSneaking ? 2 : isRiding ? -4 : 0;
     }
-    }
 
     @Override
     protected float getLegOutset() {
@@ -40,16 +31,4 @@ public class ModelEarthPony<T extends LivingEntity> extends AbstractPonyModel<T>
         }
         return super.getLegOutset();
     }
-
-    @Override
-    protected void initHead(float yOffset, float stretch) {
-        super.initHead(yOffset, stretch);
-        bipedCape = new Part(this, 0, 0)
-                .size(64, 32).box(-5, 0, -1, 10, 16, 1, stretch);
-    }
-
-    @Override
-    public void renderCape(float scale) {
-        bipedCape.render(scale);
-    }
 }

src/main/java/com/minelittlepony/client/model/races/ModelPegasus.java

@@ -4,6 +4,8 @@ import com.minelittlepony.client.model.components.PegasusWings;
 import com.minelittlepony.model.IPart;
 import com.minelittlepony.model.IPegasus;
 
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.LivingEntity;
 
 public class ModelPegasus<T extends LivingEntity> extends ModelEarthPony<T> implements IPegasus {
@@ -19,26 +21,20 @@ public class ModelPegasus<T extends LivingEntity> extends ModelEarthPony<T> impl
         return wings;
     }
 
-    @Override
-    public void init(float yOffset, float stretch) {
-        super.init(yOffset, stretch);
-        initWings(yOffset, stretch);
-    }
-
     protected void initWings(float yOffset, float stretch) {
         wings = new PegasusWings<>(this, yOffset, stretch);
     }
 
     @Override
-    public void setAngles(T entity, float move, float swing, float ticks, float headYaw, float headPitch, float scale) {
+    public void setAngles(T entity, float move, float swing, float ticks, float headYaw, float headPitch) {
-        super.setAngles(entity, move, swing, ticks, headYaw, headPitch, scale);
+        super.setAngles(entity, move, swing, ticks, headYaw, headPitch);
         getWings().setRotationAndAngles(attributes.isGoingFast, entity.getUuid(), move, swing, 0, ticks);
     }
 
     @Override
-    protected void renderBody(float scale) {
+    protected void renderBody(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha) {
-        super.renderBody(scale);
+        super.renderBody(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
-        getWings().renderPart(scale, attributes.interpolatorId);
+        getWings().renderPart(stack, vertices, overlayUv, lightUv, red, green, blue, alpha, attributes.interpolatorId);
     }
 
     @Override

src/main/java/com/minelittlepony/client/model/races/ModelUnicorn.java

@@ -1,9 +1,12 @@
 package com.minelittlepony.client.model.races;
 
 import com.minelittlepony.client.model.components.UnicornHorn;
-import com.minelittlepony.client.util.render.Part;
 import com.minelittlepony.model.IUnicorn;
+import com.minelittlepony.mson.api.model.MsonPart;
+
 import net.minecraft.client.model.ModelPart;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.util.Arm;
 import net.minecraft.util.math.MathHelper;
@@ -11,10 +14,10 @@ import net.minecraft.util.math.MathHelper;
 /**
  * Used for both unicorns and alicorns since there's no logical way to keep them distinct and not duplicate stuff.
  */
-public class ModelUnicorn<T extends LivingEntity> extends ModelEarthPony<T> implements IUnicorn<Part> {
+public class ModelUnicorn<T extends LivingEntity> extends ModelEarthPony<T> implements IUnicorn<ModelPart> {
 
-    public Part unicornArmRight;
+    public ModelPart unicornArmRight;
-    public Part unicornArmLeft;
+    public ModelPart unicornArmLeft;
 
     public UnicornHorn horn;
 
@@ -22,12 +25,6 @@ public class ModelUnicorn<T extends LivingEntity> extends ModelEarthPony<T> impl
         super(smallArms);
     }
 
-    @Override
-    public void init(float yOffset, float stretch) {
-        super.init(yOffset, stretch);
-        horn = new UnicornHorn(this, yOffset, stretch);
-    }
-
     @Override
     public float getWobbleAmount() {
         if (isCasting()) {
@@ -40,8 +37,8 @@ public class ModelUnicorn<T extends LivingEntity> extends ModelEarthPony<T> impl
     protected void rotateLegs(float move, float swing, float ticks, T entity) {
         super.rotateLegs(move, swing, ticks, entity);
 
-        unicornArmRight.rotate(0, 0, 0).around(-7, 12, -2);
+        ((MsonPart)unicornArmRight).rotate(0, 0, 0).around(-7, 12, -2);
-        unicornArmLeft.rotate(0, 0, 0).around(-7, 12, -2);
+        ((MsonPart)unicornArmLeft).rotate(0, 0, 0).around(-7, 12, -2);
     }
 
     @Override
@@ -65,7 +62,7 @@ public class ModelUnicorn<T extends LivingEntity> extends ModelEarthPony<T> impl
     }
 
     @Override
-    public Part getUnicornArmForSide(Arm side) {
+    public ModelPart getUnicornArmForSide(Arm side) {
         return side == Arm.LEFT ? unicornArmLeft : unicornArmRight;
     }
 
@@ -82,41 +79,18 @@ public class ModelUnicorn<T extends LivingEntity> extends ModelEarthPony<T> impl
     }
 
     @Override
-    protected void renderHead(float scale) {
+    protected void renderHead(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha) {
-        super.renderHead(scale);
+        super.renderHead(stack, vertices, overlayUv, lightUv, red, green, blue, alpha);
 
         if (hasHorn()) {
-            head.applyTransform(scale);
+            head.rotate(stack);
-            horn.renderPart(scale, attributes.interpolatorId);
+            horn.renderPart(stack, vertices, overlayUv, lightUv, red, green, blue, alpha, attributes.interpolatorId);
             if (canCast() && isCasting()) {
-                horn.renderMagic(getMagicColor(), scale);
+                horn.renderMagic(stack, getMagicColor());
             }
         }
     }
 
-    @Override
-    protected void initLegs(float yOffset, float stretch) {
-        super.initLegs(yOffset, stretch);
-        unicornArmLeft = new Part(this, 40, 32).size(64, 64);
-        unicornArmRight = new Part(this, 40, 32).size(64, 64);
-
-        int armLength = attributes.armLength;
-        int armWidth = attributes.armWidth;
-        int armDepth = attributes.armDepth;
-
-        float rarmX = attributes.armRotationX;
-        float rarmY = attributes.armRotationY;
-
-        float armX = THIRDP_ARM_CENTRE_X;
-        float armY = THIRDP_ARM_CENTRE_Y;
-        float armZ = BODY_CENTRE_Z / 2 - 1 - armDepth;
-
-        unicornArmLeft .box(armX, armY, armZ, armWidth, armLength, armDepth, stretch + .25F)
-                        .around(rarmX, yOffset + rarmY, 0);
-        unicornArmRight.box(armX - armWidth, armY, armZ, armWidth, armLength, armDepth, stretch + .25F)
-                        .around(-rarmX, yOffset + rarmY, 0);
-    }
-
     @Override
     public ModelPart getArm(Arm side) {
         if (canCast() && getArmPoseForSide(side) != ArmPose.EMPTY) {

src/main/java/com/minelittlepony/client/model/races/ModelZebra.java

@@ -1,18 +1,15 @@
 package com.minelittlepony.client.model.races;
 
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.LivingEntity;
 
 import com.minelittlepony.client.model.armour.ModelPonyArmour;
 import com.minelittlepony.client.model.armour.ArmourWrapper;
-import com.minelittlepony.client.util.render.Part;
 import com.minelittlepony.model.BodyPart;
 import com.minelittlepony.model.armour.IEquestrianArmour;
-import com.mojang.blaze3d.platform.GlStateManager;
 
 public class ModelZebra<T extends LivingEntity> extends ModelEarthPony<T> {
 
-    public Part bristles;
-
     public ModelZebra(boolean useSmallArms) {
         super(useSmallArms);
     }
@@ -23,52 +20,25 @@ public class ModelZebra<T extends LivingEntity> extends ModelEarthPony<T> {
     }
 
     @Override
-    public void transform(BodyPart part) {
+    public void transform(BodyPart part, MatrixStack stack) {
-        if (part == BodyPart.HEAD || part == BodyPart.NECK) {
+        applyLongNeck(part, stack);
-            GlStateManager.translatef(0, -0.1F, 0);
+        super.transform(part, stack);
-        }
-        if (part == BodyPart.NECK) {
-             GlStateManager.scalef(1, 1.3F, 1);
-        }
-        super.transform(part);
-    }
-
-    @Override
-    protected void initHead(float yOffset, float stretch) {
-        super.initHead(yOffset, stretch);
-
-        bristles = new Part(this, 56, 32);
-        head.addChild(bristles);
-
-        bristles.offset(-1, -1, -3)
-                .box(0, -10, 2, 2, 6, 2, stretch)
-                .box(0, -10, 4, 2, 8, 2, stretch)
-                .box(0, -8, 6, 2, 6, 2, stretch)
-                .pitch = 0.3F;
-        bristles.child(0).offset(-1.01F, 2, -7) //0.01 to prevent z-fighting
-                .box(0, -10, 4, 2, 8, 2, stretch)
-                .box(0, -8, 6, 2, 6, 2, stretch)
-                .pitch = -1F;
-    }
-
-
-    @Override
-    public void setVisible(boolean visible) {
-        super.setVisible(visible);
-        bristles.visible = visible;
     }
 
     class Armour extends ModelPonyArmour<T> {
-
         @Override
-        public void transform(BodyPart part) {
+        public void transform(BodyPart part, MatrixStack stack) {
+            applyLongNeck(part, stack);
+            super.transform(part, stack);
+        }
+    }
+
+    static void applyLongNeck(BodyPart part, MatrixStack stack) {
         if (part == BodyPart.HEAD || part == BodyPart.NECK) {
-                GlStateManager.translatef(0, -0.1F, 0);
+            stack.translate(0, -0.1F, 0);
         }
         if (part == BodyPart.NECK) {
-                 GlStateManager.scalef(1, 1.3F, 1);
+             stack.scale(1, 1.3F, 1);
-            }
-            super.transform(part);
         }
     }
 }

src/main/java/com/minelittlepony/client/pony/Pony.java

@@ -90,7 +90,7 @@ public class Pony implements IPony {
         }
 
         BlockState below = entity.getEntityWorld()
-                .getBlockState(entity.getBlockPos().down());
+                .getBlockState(entity.getBlockPos().down(1));
 
         // Check for stairs so we can keep Pegasi from flailing their wings as they descend
         double offsetAmount = below.getBlock() instanceof StairsBlock ? 1 : 0.05;
@@ -124,7 +124,7 @@ public class Pony implements IPony {
     protected Vec3d getVisualEyePosition(LivingEntity entity) {
         Size size = entity.isBaby() ? Size.FOAL : metadata.getSize();
 
-        return new Vec3d(entity.x, entity.y + (double) entity.getEyeHeight(entity.getPose()) * size.getScaleFactor(), entity.z);
+        return new Vec3d(entity.getX(), entity.getY() + (double) entity.getEyeHeight(entity.getPose()) * size.getScaleFactor(), entity.getZ());
     }
 
     @Override
@@ -192,9 +192,10 @@ public class Pony implements IPony {
         float delta = MinecraftClient.getInstance().getTickDelta();
 
         return new Vec3d(
-                MathHelper.lerp(delta, entity.prevRenderX, entity.x),
+                MathHelper.lerp(delta, entity.prevRenderX, entity.getX()),
-                MathHelper.lerp(delta, entity.prevRenderY, entity.y),
+                MathHelper.lerp(delta, entity.prevRenderY, entity.getY()),
-                MathHelper.lerp(delta, entity.prevRenderZ, entity.z));
+                MathHelper.lerp(delta, entity.prevRenderZ, entity.getZ())
+        );
     }
 
     @Override

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

@@ -1,15 +1,17 @@
 package com.minelittlepony.client.render;
 
 import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.render.RenderLayer;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.render.VertexConsumerProvider;
 import net.minecraft.client.render.WorldRenderer;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.util.math.Box;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.util.shape.VoxelShapes;
 
 import com.minelittlepony.pony.IPony;
-import com.mojang.blaze3d.platform.GlStateManager.DestFactor;
-import com.mojang.blaze3d.platform.GlStateManager.SourceFactor;
-
-import static com.mojang.blaze3d.systems.RenderSystem.*;
 
 public class DebugBoundingBoxRenderer {
 
@@ -18,7 +20,7 @@ public class DebugBoundingBoxRenderer {
     private DebugBoundingBoxRenderer() {
     }
 
-    public void render(IPony pony, LivingEntity entity, float ticks) {
+    public void render(IPony pony, LivingEntity entity, MatrixStack stack, VertexConsumerProvider renderContext) {
         MinecraftClient mc = MinecraftClient.getInstance();
 
         if (!mc.getEntityRenderManager().shouldRenderHitboxes() || entity.squaredDistanceTo(mc.player) > 70) {
@@ -27,16 +29,10 @@ public class DebugBoundingBoxRenderer {
 
         Box boundingBox = pony.getComputedBoundingBox(entity);
 
-        enableBlend();
+        Vec3d cam = mc.gameRenderer.getCamera().getPos();
-        blendFuncSeparate(SourceFactor.SRC_ALPHA, DestFactor.ONE_MINUS_SRC_ALPHA, SourceFactor.ONE, DestFactor.ZERO);
-        lineWidth(2);
-        disableTexture();
-        depthMask(false);
 
-        WorldRenderer.drawBoxOutline(boundingBox.offset(mc.gameRenderer.getCamera().getPos().multiply(-1)), 1, 1, 0, 1);
+        VertexConsumer vertices = renderContext.getBuffer(RenderLayer.getLines());
 
-        depthMask(true);
+        WorldRenderer.method_22983(stack, vertices, VoxelShapes.cuboid(boundingBox), -cam.x, -cam.y, -cam.z, 1, 1, 1, 1);
-        enableTexture();
-        disableBlend();
     }
 }

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

@@ -1,40 +1,42 @@
 package com.minelittlepony.client.render;
 
-import net.minecraft.client.render.VisibleRegion;
+import net.minecraft.client.render.Frustum;
+import net.minecraft.client.util.math.Matrix4f;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.util.math.Box;
 
 import com.minelittlepony.pony.IPony;
 
-public class FrustrumCheck<T extends LivingEntity> implements VisibleRegion {
+public class FrustrumCheck<T extends LivingEntity> extends Frustum {
 
     private T entity;
 
-    private VisibleRegion vanilla;
+    private Frustum vanilla;
 
     private final RenderPony<T, ?> renderer;
 
     public FrustrumCheck(RenderPony<T, ?> render) {
+        super(new Matrix4f(), new Matrix4f());
         renderer = render;
     }
 
-    public VisibleRegion withCamera(T entity, VisibleRegion vanillaFrustrum) {
+    public Frustum withCamera(T entity, Frustum vanillaFrustrum) {
         this.entity = entity;
         vanilla = vanillaFrustrum;
         return this;
     }
 
     @Override
-    public boolean intersects(Box bounds) {
+    public boolean isVisible(Box bounds) {
         IPony pony = renderer.getPony(entity);
 
         Box boundingBox = pony.getComputedBoundingBox(entity);
 
-        return vanilla.intersects(boundingBox);
+        return vanilla.isVisible(boundingBox);
     }
 
     @Override
-    public void setOrigin(double x, double y, double z) {
+    public void setPosition(double x, double y, double z) {
-        vanilla.setOrigin(x, y, z);
+        vanilla.setPosition(x, y, z);
     }
 }

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

@@ -10,6 +10,7 @@ import com.minelittlepony.pony.IPony;
 import com.minelittlepony.util.math.MathUtil;
 
 import net.minecraft.client.render.entity.model.EntityModel;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.util.Identifier;
 
@@ -34,17 +35,17 @@ public interface IPonyRender<T extends LivingEntity, M extends EntityModel<T> &
     /**
      * Called by riders to have their transportation adjust their position.
      */
-    default void translateRider(T entity, IPony entityPony, LivingEntity passenger, IPony passengerPony, float ticks) {
+    default void translateRider(T entity, IPony entityPony, LivingEntity passenger, IPony passengerPony, MatrixStack stack, float ticks) {
         if (!passengerPony.getRace(false).isHuman()) {
             //float yaw = MathUtil.interpolateDegress(entity.prevRenderYawOffset, entity.renderYawOffset, ticks);
-            float yaw = MathUtil.interpolateDegress((float)entity.prevRenderY, (float)entity.y, ticks);
+            float yaw = MathUtil.interpolateDegress((float)entity.prevRenderY, (float)entity.getY(), ticks);
 
             getModelWrapper().apply(entityPony.getMetadata());
             M model = getModelWrapper().getBody();
 
-            model.transform(BodyPart.BACK);
+            model.transform(BodyPart.BACK, stack);
 
-            getInternalRenderer().applyPostureRiding(entity, yaw, ticks);
+            getInternalRenderer().applyPostureRiding(entity, stack, yaw, ticks);
         }
     }
 }

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

@@ -7,15 +7,23 @@ import com.minelittlepony.client.util.render.Color;
 import com.minelittlepony.pony.IPony;
 import com.mojang.blaze3d.platform.GlStateManager.DestFactor;
 import com.mojang.blaze3d.platform.GlStateManager.SourceFactor;
+
+import javax.annotation.Nullable;
+
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.network.AbstractClientPlayerEntity;
 import net.minecraft.client.render.FirstPersonRenderer;
+import net.minecraft.client.render.OverlayTexture;
+import net.minecraft.client.render.VertexConsumerProvider;
 import net.minecraft.client.render.item.ItemRenderer;
 import net.minecraft.client.render.model.json.ModelTransformation;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.client.util.math.Vector3f;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.Arm;
 import net.minecraft.util.UseAction;
+import net.minecraft.world.World;
 
 import static com.mojang.blaze3d.systems.RenderSystem.*;
 
@@ -39,8 +47,8 @@ public class LevitatingItemRenderer {
     /**
      * Renders a magical overlay over an item in third person.
      */
-    public void renderItemGlow(LivingEntity entity, ItemStack drop, ModelTransformation.Type transform, Arm hand, int glowColor) {
+    public void renderItemGlow(LivingEntity entity, ItemStack drop, ModelTransformation.Type transform, Arm hand, int glowColor, MatrixStack stack, VertexConsumerProvider renderContext) {
-        pushMatrix();
+        stack.push();
         disableLighting();
         setColor(glowColor);
 
@@ -48,17 +56,17 @@ public class LevitatingItemRenderer {
 
         usingTransparency = true;
 
-        scalef(1.1F, 1.1F, 1.1F);
+        stack.scale(1.1F, 1.1F, 1.1F);
 
-        translatef(0.01F, 0.01F, 0.01F);
+        stack.translate(0.01F, 0.01F, 0.01F);
-        renderItem.renderHeldItem(drop, entity, transform, hand == Arm.LEFT);
+        renderItem.method_23177(entity, drop, transform, hand == Arm.LEFT, stack, renderContext, entity.world, 0x0F00F0, OverlayTexture.DEFAULT_UV);
-        translatef(-0.02F, -0.02F, -0.02F);
+        stack.translate(-0.02F, -0.02F, -0.02F);
-        renderItem.renderHeldItem(drop, entity, transform, hand == Arm.LEFT);
+        renderItem.method_23177(entity, drop, transform, hand == Arm.LEFT, stack, renderContext, entity.world, 0x0F00F0, OverlayTexture.DEFAULT_UV);
 
         usingTransparency = false;
         unsetColor();
         enableLighting();
-        popMatrix();
+        stack.pop();
 
         // I hate rendering
     }
@@ -74,20 +82,20 @@ public class LevitatingItemRenderer {
     /**
      * Renders an item in first person optionally with a magical overlay.
      */
-    public void renderItemInFirstPerson(FirstPersonRenderer renderer, AbstractClientPlayerEntity entity, ItemStack stack, ModelTransformation.Type transform, boolean left) {
+    public void renderItemInFirstPerson(FirstPersonRenderer renderer, @Nullable AbstractClientPlayerEntity entity, ItemStack stack, ModelTransformation.Type transform, boolean left, MatrixStack matrix, VertexConsumerProvider renderContext, @Nullable World world, int lightUv) {
         IPony pony = MineLittlePony.getInstance().getManager().getPony(entity);
 
-        pushMatrix();
+        matrix.push();
 
         boolean doMagic = MineLittlePony.getInstance().getConfig().fpsmagic.get() && pony.getMetadata().hasMagic();
 
         ItemRenderer itemRenderer = MinecraftClient.getInstance().getItemRenderer();
 
         if (doMagic) {
-            setupPerspective(itemRenderer, entity, stack, left);
+            setupPerspective(itemRenderer, entity, stack, left, matrix);
         }
 
-        renderer.renderItemFromSide(entity, stack, transform, left);
+        itemRenderer.method_23177(entity, stack, transform, left, matrix, renderContext, world, lightUv, OverlayTexture.DEFAULT_UV);
 
         if (doMagic) {
             disableLighting();
@@ -96,12 +104,12 @@ public class LevitatingItemRenderer {
 
             setColor(pony.getMetadata().getGlowColor());
 
-            scalef(1.1F, 1.1F, 1.1F);
+            matrix.scale(1.1F, 1.1F, 1.1F);
 
-            translatef(0.015F, 0.01F, 0.01F);
+            matrix.translate(0.015F, 0.01F, 0.01F);
-            renderer.renderItemFromSide(entity, stack, transform, left);
+            itemRenderer.method_23177(entity, stack, transform, left, matrix, renderContext, world, lightUv, OverlayTexture.DEFAULT_UV);
-            translatef(-0.03F, -0.02F, -0.02F);
+            matrix.translate(-0.03F, -0.02F, -0.02F);
-            renderer.renderItemFromSide(entity, stack, transform, left);
+            itemRenderer.method_23177(entity, stack, transform, left, matrix, renderContext, world, lightUv, OverlayTexture.DEFAULT_UV);
 
             usingTransparency = false;
 
@@ -109,7 +117,7 @@ public class LevitatingItemRenderer {
             enableLighting();
         }
 
-        popMatrix();
+        matrix.pop();
 
         // I hate rendering
     }
@@ -117,8 +125,8 @@ public class LevitatingItemRenderer {
     /**
      * Moves held items to look like they're floating in the player's field.
      */
-    private void setupPerspective(ItemRenderer renderer, LivingEntity entity, ItemStack stack, boolean left) {
+    private void setupPerspective(ItemRenderer renderer, LivingEntity entity, ItemStack item, boolean left, MatrixStack stack) {
-        UseAction action = stack.getUseAction();
+        UseAction action = item.getUseAction();
 
         boolean doNormal = entity.getItemUseTime() <= 0 || action == UseAction.NONE || action == UseAction.CROSSBOW;
 
@@ -128,20 +136,17 @@ public class LevitatingItemRenderer {
             float floatAmount = (float)Math.sin(ticks / 9) / 40;
             float driftAmount = (float)Math.cos(ticks / 6) / 40;
 
-            boolean handHeldTool = action == UseAction.BOW
+            boolean handHeldTool =
+                       action == UseAction.BOW
                     || action == UseAction.CROSSBOW
                     || action == UseAction.BLOCK;
 
-            translatef(driftAmount - floatAmount / 4, floatAmount, handHeldTool ? -0.3F : -0.6F);
+            stack.translate(driftAmount - floatAmount / 4, floatAmount, handHeldTool ? -0.3F : -0.6F);
 
-            if (!renderer.hasDepthInGui(stack) && !handHeldTool) { // bows have to point forwards
+            if (/*!renderer.hasDepthInGui(item) && */!handHeldTool) { // bows have to point forwards
-                if (left) {
+                int sign = left ? 1 : -1;
-                    rotatef(-60, 0, 1, 0);
+                stack.multiply(Vector3f.POSITIVE_Y.getDegreesQuaternion(sign * -60));
-                    rotatef(30, 0, 0, 1);
+                stack.multiply(Vector3f.POSITIVE_Z.getDegreesQuaternion(sign * 30));
-                } else {
-                    rotatef(60, 0, 1, 0);
-                    rotatef(-30, 0, 0, 1);
-                }
             }
         }
     }

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

@@ -7,12 +7,15 @@ import com.minelittlepony.client.model.ModelWrapper;
 import com.minelittlepony.client.transform.PonyPosture;
 import com.minelittlepony.pony.IPony;
 import com.minelittlepony.util.math.MathUtil;
-import com.mojang.blaze3d.platform.GlStateManager;
+import com.mojang.blaze3d.platform.GlStateManager.DestFactor;
+import com.mojang.blaze3d.platform.GlStateManager.SourceFactor;
+import com.mojang.blaze3d.systems.RenderSystem;
 
 import javax.annotation.Nonnull;
 
-import net.minecraft.client.render.VisibleRegion;
+import net.minecraft.client.render.Frustum;
 import net.minecraft.client.render.entity.model.EntityModel;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.util.Identifier;
@@ -30,15 +33,15 @@ public class RenderPony<T extends LivingEntity, M extends EntityModel<T> & IPony
     private final FrustrumCheck<T> frustrum = new FrustrumCheck<>(this);
 
     public static void enableModelRenderProfile(boolean skipBlend) {
-        GlStateManager.enableBlend();
+        RenderSystem.enableBlend();
         if (!skipBlend) {
-            GlStateManager.blendFunc(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA);
+            RenderSystem.blendFunc(SourceFactor.SRC_ALPHA, DestFactor.ONE_MINUS_SRC_ALPHA);
         }
-        GlStateManager.alphaFunc(516, 0.003921569F);
+        RenderSystem.alphaFunc(516, 0.003921569F);
     }
 
     public static void disableModelRenderProfile() {
-        GlStateManager.disableBlend();
+        RenderSystem.disableBlend();
     }
 
     public RenderPony(IPonyRender<T, M> renderer) {
@@ -49,21 +52,21 @@ public class RenderPony<T extends LivingEntity, M extends EntityModel<T> & IPony
         skipBlend = true;
     }
 
-    public VisibleRegion getFrustrum(T entity, VisibleRegion vanilla) {
+    public Frustum getFrustrum(T entity, Frustum vanilla) {
         if (entity.isSleeping() || !MineLittlePony.getInstance().getConfig().frustrum.get()) {
             return vanilla;
         }
         return frustrum.withCamera(entity, vanilla);
     }
 
-    public void preRenderCallback(T entity, float ticks) {
+    public void preRenderCallback(T entity, MatrixStack stack, float ticks) {
         updateModel(entity);
 
         float s = getScaleFactor();
-        GlStateManager.scalef(s, s, s);
+        stack.scale(s, s, s);
         enableModelRenderProfile(skipBlend);
 
-        translateRider(entity, ticks);
+        translateRider(entity, stack, ticks);
     }
 
     public float getRenderYaw(T entity, float rotationYaw, float partialTicks) {
@@ -77,7 +80,7 @@ public class RenderPony<T extends LivingEntity, M extends EntityModel<T> & IPony
         return rotationYaw;
     }
 
-    protected void translateRider(T entity, float ticks) {
+    protected void translateRider(T entity, MatrixStack stack, float ticks) {
         if (entity.hasVehicle() && entity.getVehicle() instanceof LivingEntity) {
 
             LivingEntity ridingEntity = (LivingEntity) entity.getVehicle();
@@ -85,23 +88,23 @@ public class RenderPony<T extends LivingEntity, M extends EntityModel<T> & IPony
 
             if (renderer != null) {
                 // negate vanilla translations so the rider begins at the ridees feet.
-                GlStateManager.translatef(0, -ridingEntity.getHeight(), 0);
+                stack.translate(0, -ridingEntity.getHeight(), 0);
 
                 IPony riderPony = renderer.getEntityPony(ridingEntity);
 
-                renderer.translateRider(ridingEntity, riderPony, entity, pony, ticks);
+                renderer.translateRider(ridingEntity, riderPony, entity, pony, stack, ticks);
             }
         }
     }
 
     @SuppressWarnings("unchecked")
-    public void applyPostureTransform(T player, float yaw, float ticks) {
+    public void applyPostureTransform(T player, MatrixStack stack, float yaw, float ticks) {
-        ((PonyPosture<T>) getPosture(player)).apply(player, getModel(), yaw, ticks, 1);
+        ((PonyPosture<T>) getPosture(player)).apply(player, getModel(), stack, yaw, ticks, 1);
     }
 
     @SuppressWarnings("unchecked")
-    public void applyPostureRiding(T player, float yaw, float ticks) {
+    public void applyPostureRiding(T player, MatrixStack stack, float yaw, float ticks) {
-        ((PonyPosture<T>) getPosture(player)).apply(player, getModel(), yaw, ticks, -1);
+        ((PonyPosture<T>) getPosture(player)).apply(player, getModel(), stack, yaw, ticks, -1);
     }
 
     @Nonnull
@@ -161,7 +164,7 @@ public class RenderPony<T extends LivingEntity, M extends EntityModel<T> & IPony
         return getModel().getSize().getScaleFactor();
     }
 
-    public double getNamePlateYOffset(T entity, double initial) {
+    public double getNamePlateYOffset(T entity) {
 
         // We start by negating the height calculation done by mahjong.
         float y = -(entity.getHeight() + 0.5F - (entity.isInSneakingPose() ? 0.25F : 0));
@@ -181,6 +184,6 @@ public class RenderPony<T extends LivingEntity, M extends EntityModel<T> & IPony
             y /= 2;
         }
 
-        return initial + y;
+        return y;
     }
 }

src/main/java/com/minelittlepony/client/render/entities/MobRenderers.java

@@ -2,54 +2,52 @@ package com.minelittlepony.client.render.entities;
 
 import com.minelittlepony.client.MineLittlePony;
 import com.minelittlepony.client.PonyRenderManager;
-import com.minelittlepony.client.render.entities.villager.RenderPonyVillager;
+import com.minelittlepony.client.render.entities.villager.*;
-import com.minelittlepony.client.render.entities.villager.RenderPonyZombieVillager;
 import com.minelittlepony.common.util.settings.Setting;
 
 import java.util.Arrays;
 import java.util.List;
 import java.util.function.BiConsumer;
 
-import net.minecraft.entity.mob.*;
+import net.minecraft.entity.EntityType;
-import net.minecraft.entity.passive.*;
 
 /**
  * Central location where new entity renderers are registered and applied.
  */
 public enum MobRenderers {
     VILLAGERS((state, pony) -> {
-        pony.switchRenderer(state, VillagerEntity.class, RenderPonyVillager::new);
+        pony.switchRenderer(state, EntityType.VILLAGER, RenderPonyVillager::new);
-        pony.switchRenderer(state, WitchEntity.class, RenderPonyWitch::new);
+        pony.switchRenderer(state, EntityType.WITCH, RenderPonyWitch::new);
-        pony.switchRenderer(state, ZombieVillagerEntity.class, RenderPonyZombieVillager::new);
+        pony.switchRenderer(state, EntityType.ZOMBIE_VILLAGER, RenderPonyZombieVillager::new);
-        pony.switchRenderer(state, WanderingTraderEntity.class, RenderPonyTrader::new);
+        pony.switchRenderer(state, EntityType.WANDERING_TRADER, RenderPonyTrader::new);
     }),
     ILLAGERS((state, pony) -> {
-        pony.switchRenderer(state, VexEntity.class, RenderPonyVex::new);
+        pony.switchRenderer(state, EntityType.VEX, RenderPonyVex::new);
-        pony.switchRenderer(state, EvokerEntity.class, RenderPonyIllager.Evoker::new);
+        pony.switchRenderer(state, EntityType.EVOKER, RenderPonyIllager.Evoker::new);
-        pony.switchRenderer(state, VindicatorEntity.class, RenderPonyIllager.Vindicator::new);
+        pony.switchRenderer(state, EntityType.VINDICATOR, RenderPonyIllager.Vindicator::new);
-        pony.switchRenderer(state, IllusionerEntity.class, RenderPonyIllager.Illusionist::new);
+        pony.switchRenderer(state, EntityType.ILLUSIONER, RenderPonyIllager.Illusionist::new);
-        pony.switchRenderer(state, PillagerEntity.class, RenderPonyPillager::new);
+        pony.switchRenderer(state, EntityType.PILLAGER, RenderPonyPillager::new);
     }),
     ZOMBIES((state, pony) -> {
-        pony.switchRenderer(state, ZombieEntity.class, RenderPonyZombie::new);
+        pony.switchRenderer(state, EntityType.ZOMBIE, RenderPonyZombie::new);
-        pony.switchRenderer(state, HuskEntity.class, RenderPonyZombie.Husk::new);
+        pony.switchRenderer(state, EntityType.HUSK, RenderPonyZombie.Husk::new);
-        pony.switchRenderer(state, GiantEntity.class, RenderPonyZombie.Giant::new);
+        pony.switchRenderer(state, EntityType.GIANT, RenderPonyZombie.Giant::new);
-        pony.switchRenderer(state, DrownedEntity.class, RenderPonyZombie.Drowned::new);
+        pony.switchRenderer(state, EntityType.DROWNED, RenderPonyZombie.Drowned::new);
     }),
     PIGZOMBIES((state, pony) -> {
-        pony.switchRenderer(state, ZombiePigmanEntity.class, RenderPonyZombie.Pigman::new);
+        pony.switchRenderer(state, EntityType.ZOMBIE_PIGMAN, RenderPonyZombie.Pigman::new);
     }),
     SKELETONS((state, pony) -> {
-        pony.switchRenderer(state, SkeletonEntity.class, RenderPonySkeleton::new);
+        pony.switchRenderer(state, EntityType.SKELETON, RenderPonySkeleton::new);
-        pony.switchRenderer(state, StrayEntity.class, RenderPonySkeleton.Stray::new);
+        pony.switchRenderer(state, EntityType.STRAY, RenderPonySkeleton.Stray::new);
-        pony.switchRenderer(state, WitherSkeletonEntity.class, RenderPonySkeleton.Wither::new);
+        pony.switchRenderer(state, EntityType.WITHER_SKELETON, RenderPonySkeleton.Wither::new);
     }),
     GUARDIANS((state, pony) -> {
-        pony.switchRenderer(state, GuardianEntity.class, RenderPonyGuardian::new);
+        pony.switchRenderer(state, EntityType.GUARDIAN, RenderPonyGuardian::new);
-        pony.switchRenderer(state, ElderGuardianEntity.class, RenderPonyGuardian.Elder::new);
+        pony.switchRenderer(state, EntityType.ELDER_GUARDIAN, RenderPonyGuardian.Elder::new);
     }),
     ENDERMEN((state, pony) -> {
-        pony.switchRenderer(state, EndermanEntity.class, RenderEnderStallion::new);
+        pony.switchRenderer(state, EntityType.ENDERMAN, RenderEnderStallion::new);
     });
 
     public static final List<MobRenderers> registry = Arrays.asList(values());

src/main/java/com/minelittlepony/client/render/entities/RenderEnderStallion.java

@@ -6,10 +6,12 @@ import com.minelittlepony.client.render.layer.LayerHeldPonyItem;
 import com.minelittlepony.client.render.layer.LayerHeldPonyItemMagical;
 import com.minelittlepony.client.render.layer.LayerEyeGlow.IGlowingRenderer;
 
-import net.fabricmc.fabric.api.client.render.EntityRendererRegistry;
+import net.fabricmc.fabric.api.client.rendereregistry.v1.EntityRendererRegistry;
 import net.minecraft.block.BlockState;
+import net.minecraft.client.render.VertexConsumerProvider;
 import net.minecraft.client.render.entity.EntityRenderDispatcher;
 import net.minecraft.client.render.entity.feature.StuckArrowsFeatureRenderer;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.mob.EndermanEntity;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.Identifier;
@@ -55,18 +57,17 @@ public class RenderEnderStallion extends RenderPonyMob<EndermanEntity, ModelEnde
     }
 
     @Override
-    public void render(EndermanEntity entity, double x, double y, double z, float entityYaw, float partialTicks) {
+    public void render(EndermanEntity entity, float entityYaw, float tickDelta, MatrixStack stack, VertexConsumerProvider renderContext, int lightUv) {
         ModelEnderStallion modelenderman = getModel();
 
         modelenderman.isCarrying = entity.getCarriedBlock() != null;
         modelenderman.isAttacking = entity.isAngry();
 
         if (entity.isAngry()) {
-            x += rnd.nextGaussian() / 50;
+            stack.translate(rnd.nextGaussian() / 50, 0, rnd.nextGaussian() / 50);
-            z += rnd.nextGaussian() / 50;
         }
 
-        super.render(entity, x, y, z, entityYaw, partialTicks);
+        super.render(entity, entityYaw, tickDelta, stack, renderContext, lightUv);
     }
 
     @Override

src/main/java/com/minelittlepony/client/render/entities/RenderPonyGuardian.java

@@ -7,11 +7,13 @@ import com.minelittlepony.client.model.entities.ModelGuardianPony;
 import com.minelittlepony.client.render.entities.RenderPonyMob.Proxy;
 import com.minelittlepony.client.render.layer.LayerHeldPonyItem;
 import com.minelittlepony.client.render.layer.LayerHeldPonyItemMagical;
-import com.mojang.blaze3d.platform.GlStateManager;
+import com.mojang.blaze3d.systems.RenderSystem;
 
-import net.fabricmc.fabric.api.client.render.EntityRendererRegistry;
+import net.fabricmc.fabric.api.client.rendereregistry.v1.EntityRendererRegistry;
+import net.minecraft.client.render.VertexConsumerProvider;
 import net.minecraft.client.render.entity.EntityRenderDispatcher;
 import net.minecraft.client.render.entity.GuardianEntityRenderer;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.EntityDimensions;
 import net.minecraft.entity.mob.ElderGuardianEntity;
 import net.minecraft.entity.mob.GuardianEntity;
@@ -43,27 +45,27 @@ public class RenderPonyGuardian extends GuardianEntityRenderer {
 
     @Override
     @Nonnull
-    protected final Identifier getTexture(GuardianEntity entity) {
+    public final Identifier getTexture(GuardianEntity entity) {
         return ponyRenderer.getTextureFor(entity);
     }
 
     @Override
-    protected void scale(GuardianEntity entity, float ticks) {
+    protected void scale(GuardianEntity entity, MatrixStack stack, float ticks) {
-        ponyRenderer.scale(entity, ticks);
+        ponyRenderer.scale(entity, stack, ticks);
     }
 
     @Override
-    public void render(GuardianEntity entity, double x, double y, double z, float entityYaw, float partialTicks) {
+    public void render(GuardianEntity entity, float entityYaw, float tickDelta, MatrixStack stack, VertexConsumerProvider renderContext, int lightUv) {
         IResizeable resize = (IResizeable)entity;
         EntityDimensions origin = resize.getCurrentSize();
 
         // aligns the beam to their horns
         resize.setCurrentSize(EntityDimensions.changing(origin.width, entity instanceof ElderGuardianEntity ? 6 : 3));
 
-        super.render(entity, x, y, z, entityYaw, partialTicks);
+        super.render(entity, entityYaw, tickDelta, stack, renderContext, lightUv);
 
         // The beams in RenderGuardian leave lighting disabled, so we need to change it back. #MojangPls
-        GlStateManager.enableLighting();
+        RenderSystem.enableLighting();
         resize.setCurrentSize(origin);
     }
 
@@ -74,9 +76,9 @@ public class RenderPonyGuardian extends GuardianEntityRenderer {
         }
 
         @Override
-        protected void scale(GuardianEntity entity, float ticks) {
+        protected void scale(GuardianEntity entity, MatrixStack stack, float ticks) {
-            super.scale(entity, ticks);
+            super.scale(entity, stack, ticks);
-            GlStateManager.scalef(2.35F, 2.35F, 2.35F);
+            stack.scale(2.35F, 2.35F, 2.35F);
         }
     }
 }

src/main/java/com/minelittlepony/client/render/entities/RenderPonyIllager.java

@@ -3,10 +3,11 @@ package com.minelittlepony.client.render.entities;
 import com.minelittlepony.client.model.entities.ModelIllagerPony;
 import com.minelittlepony.client.render.layer.LayerHeldItemIllager;
 import com.minelittlepony.client.render.layer.LayerHeldPonyItem;
-import com.mojang.blaze3d.platform.GlStateManager;
 
-import net.fabricmc.fabric.api.client.render.EntityRendererRegistry;
+import net.fabricmc.fabric.api.client.rendereregistry.v1.EntityRendererRegistry;
+import net.minecraft.client.render.VertexConsumerProvider;
 import net.minecraft.client.render.entity.EntityRenderDispatcher;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.mob.EvokerEntity;
 import net.minecraft.entity.mob.IllagerEntity;
 import net.minecraft.entity.mob.IllusionerEntity;
@@ -31,9 +32,9 @@ public abstract class RenderPonyIllager<T extends IllagerEntity> extends RenderP
     }
 
     @Override
-    public void scale(T entity, float ticks) {
+    public void scale(T entity, MatrixStack stack, float ticks) {
-        super.scale(entity, ticks);
+        super.scale(entity, stack, ticks);
-        GlStateManager.scalef(BASE_MODEL_SCALE, BASE_MODEL_SCALE, BASE_MODEL_SCALE);
+        stack.scale(BASE_MODEL_SCALE, BASE_MODEL_SCALE, BASE_MODEL_SCALE);
     }
 
     public static class Vindicator extends RenderPonyIllager<VindicatorEntity> {
@@ -73,25 +74,28 @@ public abstract class RenderPonyIllager<T extends IllagerEntity> extends RenderP
         }
 
         @Override
-        public void render(IllusionerEntity entity, double x, double y, double z, float yaw, float ticks) {
+        public void render(IllusionerEntity entity, float entityYaw, float tickDelta, MatrixStack stack, VertexConsumerProvider renderContext, int lightUv) {
             if (entity.isInvisible()) {
-                Vec3d[] clones = entity.method_7065(ticks);
+                Vec3d[] clones = entity.method_7065(tickDelta);
-                float rotation = getAge(entity, ticks);
+                float rotation = getAge(entity, tickDelta);
 
                 for (int i = 0; i < clones.length; ++i) {
-                    super.render(entity,
+                    stack.push();
-                            x + clones[i].x + MathHelper.cos(i + rotation * 0.5F) * 0.025D,
+                    stack.translate(
-                            y + clones[i].y + MathHelper.cos(i + rotation * 0.75F) * 0.0125D,
+                            clones[i].x + MathHelper.cos(i + rotation * 0.5F) * 0.025D,
-                            z + clones[i].z + MathHelper.cos(i + rotation * 0.7F) * 0.025D,
+                            clones[i].y + MathHelper.cos(i + rotation * 0.75F) * 0.0125D,
-                            yaw, ticks);
+                            clones[i].z + MathHelper.cos(i + rotation * 0.7F) * 0.025D
+                    );
+                    super.render(entity, entityYaw, tickDelta, stack, renderContext, lightUv);
+                    stack.pop();
                 }
             } else {
-                super.render(entity, x, y, z, yaw, ticks);
+                super.render(entity, entityYaw, tickDelta, stack, renderContext, lightUv);
             }
         }
 
         @Override
-        protected boolean method_4056(IllusionerEntity entity) {
+        protected boolean method_4056(IllusionerEntity entity, boolean xray) {
             return true;
         }
     }

src/main/java/com/minelittlepony/client/render/entities/RenderPonyMob.java

@@ -13,16 +13,16 @@ import com.minelittlepony.client.render.layer.LayerHeldPonyItemMagical;
 import com.minelittlepony.client.render.layer.LayerPonyArmor;
 import com.minelittlepony.client.render.layer.LayerPonyCustomHead;
 import com.minelittlepony.client.render.layer.LayerPonyElytra;
-import com.minelittlepony.client.util.render.Part;
 import com.minelittlepony.model.IUnicorn;
 import com.minelittlepony.pony.IPony;
-import com.mojang.blaze3d.platform.GlStateManager;
 
-import net.minecraft.client.render.VisibleRegion;
+import net.minecraft.client.model.ModelPart;
+import net.minecraft.client.render.Frustum;
+import net.minecraft.client.render.VertexConsumerProvider;
 import net.minecraft.client.render.entity.EntityRenderDispatcher;
 import net.minecraft.client.render.entity.MobEntityRenderer;
-import net.minecraft.client.render.entity.feature.StuckArrowsFeatureRenderer;
 import net.minecraft.client.render.entity.model.EntityModel;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.mob.MobEntity;
 import net.minecraft.util.Identifier;
 
@@ -44,7 +44,7 @@ public abstract class RenderPonyMob<T extends MobEntity, M extends EntityModel<T
     protected void addLayers() {
         addFeature(new LayerPonyArmor<>(this));
         addFeature(createItemHoldingLayer());
-        addFeature(new StuckArrowsFeatureRenderer<>(this));
+        //addFeature(new StuckArrowsFeatureRenderer<>(this));
         addFeature(new LayerPonyCustomHead<>(this));
         addFeature(new LayerPonyElytra<>(this));
         addFeature(new LayerGear<>(this));
@@ -53,32 +53,32 @@ public abstract class RenderPonyMob<T extends MobEntity, M extends EntityModel<T
     protected abstract LayerHeldPonyItem<T, M> createItemHoldingLayer();
 
     @Override
-    public void render(T entity, double xPosition, double yPosition, double zPosition, float yaw, float ticks) {
+    public void render(T entity, float entityYaw, float tickDelta, MatrixStack stack, VertexConsumerProvider renderContext, int lightUv) {
         if (entity.isInSneakingPose()) {
-            yPosition -= 0.125D;
+            stack.translate(0, 0.125D, 0);
         }
 
-        super.render(entity, xPosition, yPosition, zPosition, yaw, ticks);
+        super.render(entity, entityYaw, tickDelta, stack, renderContext, lightUv);
 
-        DebugBoundingBoxRenderer.instance.render(renderPony.getPony(entity), entity, ticks);
+        DebugBoundingBoxRenderer.instance.render(renderPony.getPony(entity), entity, stack, renderContext);
     }
 
     @Override
-    protected void setupTransforms(T entity, float ageInTicks, float rotationYaw, float partialTicks) {
+    protected void setupTransforms(T entity, MatrixStack stack, float ageInTicks, float rotationYaw, float partialTicks) {
         rotationYaw = renderPony.getRenderYaw(entity, rotationYaw, partialTicks);
-        super.setupTransforms(entity, ageInTicks, rotationYaw, partialTicks);
+        super.setupTransforms(entity, stack, ageInTicks, rotationYaw, partialTicks);
 
-        renderPony.applyPostureTransform(entity, rotationYaw, partialTicks);
+        renderPony.applyPostureTransform(entity, stack, rotationYaw, partialTicks);
     }
 
     @Override
-    public boolean isVisible(T entity, VisibleRegion camera, double camX, double camY, double camZ) {
+    public boolean isVisible(T entity, Frustum visibleRegion, double camX, double camY, double camZ) {
-        return super.isVisible(entity, renderPony.getFrustrum(entity, camera), camX, camY, camZ);
+        return super.isVisible(entity, renderPony.getFrustrum(entity, visibleRegion), camX, camY, camZ);
     }
 
     @Override
-    public void scale(T entity, float ticks) {
+    public void scale(T entity, MatrixStack stack, float ticks) {
-        renderPony.preRenderCallback(entity, ticks);
+        renderPony.preRenderCallback(entity, stack, ticks);
         // shadowRadius
         field_4673 = renderPony.getShadowScale();
 
@@ -87,9 +87,9 @@ public abstract class RenderPonyMob<T extends MobEntity, M extends EntityModel<T
         }
 
         if (!entity.hasVehicle()) {
-            GlStateManager.translatef(0, 0, -entity.getWidth() / 2); // move us to the center of the shadow
+            stack.translate(0, 0, -entity.getWidth() / 2); // move us to the center of the shadow
         } else {
-            GlStateManager.translated(0, entity.getHeightOffset(), 0);
+            stack.translate(0, entity.getHeightOffset(), 0);
         }
     }
 
@@ -99,8 +99,9 @@ public abstract class RenderPonyMob<T extends MobEntity, M extends EntityModel<T
     }
 
     @Override
-    protected void renderLabel(T entity, String name, double x, double y, double z, int maxDistance) {
+    protected void renderLabelIfPresent(T entity, String name, MatrixStack stack, VertexConsumerProvider renderContext, int maxDistance) {
-        super.renderLabel(entity, name, x, renderPony.getNamePlateYOffset(entity, y), z, maxDistance);
+        stack.translate(0, renderPony.getNamePlateYOffset(entity), 0);
+        super.renderLabelIfPresent(entity, name, stack, renderContext, maxDistance);
     }
 
     @Deprecated
@@ -120,7 +121,7 @@ public abstract class RenderPonyMob<T extends MobEntity, M extends EntityModel<T
         return MineLittlePony.getInstance().getManager().getPony(findTexture(entity));
     }
 
-    public abstract static class Caster<T extends MobEntity, M extends ClientPonyModel<T> & IUnicorn<Part>> extends RenderPonyMob<T, M> {
+    public abstract static class Caster<T extends MobEntity, M extends ClientPonyModel<T> & IUnicorn<ModelPart>> extends RenderPonyMob<T, M> {
 
         public Caster(EntityRenderDispatcher manager, M model) {
             super(manager, model);

src/main/java/com/minelittlepony/client/render/entities/RenderPonyPillager.java

@@ -1,6 +1,6 @@
 package com.minelittlepony.client.render.entities;
 
-import net.fabricmc.fabric.api.client.render.EntityRendererRegistry;
+import net.fabricmc.fabric.api.client.rendereregistry.v1.EntityRendererRegistry;
 import net.minecraft.client.render.entity.EntityRenderDispatcher;
 import net.minecraft.entity.mob.PillagerEntity;
 import net.minecraft.util.Identifier;

src/main/java/com/minelittlepony/client/render/entities/RenderPonySkeleton.java

@@ -4,10 +4,10 @@ import com.minelittlepony.client.model.entities.ModelSkeletonPony;
 import com.minelittlepony.client.render.layer.LayerHeldPonyItem;
 import com.minelittlepony.client.render.layer.LayerHeldPonyItemMagical;
 import com.minelittlepony.client.render.layer.LayerPonyStrayOverlay;
-import com.mojang.blaze3d.platform.GlStateManager;
 
-import net.fabricmc.fabric.api.client.render.EntityRendererRegistry;
+import net.fabricmc.fabric.api.client.rendereregistry.v1.EntityRendererRegistry;
 import net.minecraft.client.render.entity.EntityRenderDispatcher;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.mob.AbstractSkeletonEntity;
 import net.minecraft.entity.mob.StrayEntity;
 import net.minecraft.entity.mob.WitherSkeletonEntity;
@@ -58,9 +58,9 @@ public class RenderPonySkeleton<Skeleton extends AbstractSkeletonEntity> extends
         }
 
         @Override
-        public void scale(WitherSkeletonEntity skeleton, float ticks) {
+        public void scale(WitherSkeletonEntity skeleton, MatrixStack stack, float ticks) {
-            super.scale(skeleton, ticks);
+            super.scale(skeleton, stack, ticks);
-            GlStateManager.scalef(1.2F, 1.2F, 1.2F);
+            stack.scale(1.2F, 1.2F, 1.2F);
         }
 
     }

src/main/java/com/minelittlepony/client/render/entities/RenderPonyTrader.java

@@ -1,12 +1,12 @@
 package com.minelittlepony.client.render.entities;
 
-import net.fabricmc.fabric.api.client.render.EntityRendererRegistry;
+import net.fabricmc.fabric.api.client.rendereregistry.v1.EntityRendererRegistry;
 import net.minecraft.client.render.entity.EntityRenderDispatcher;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.passive.WanderingTraderEntity;
 import net.minecraft.util.Identifier;
 
 import com.minelittlepony.client.model.races.ModelAlicorn;
-import com.mojang.blaze3d.platform.GlStateManager;
 
 public class RenderPonyTrader extends RenderPonyMob.Caster<WanderingTraderEntity, ModelAlicorn<WanderingTraderEntity>> {
 
@@ -22,8 +22,8 @@ public class RenderPonyTrader extends RenderPonyMob.Caster<WanderingTraderEntity
     }
 
     @Override
-    public void scale(WanderingTraderEntity entity, float ticks) {
+    public void scale(WanderingTraderEntity entity, MatrixStack stack, float ticks) {
-        super.scale(entity, ticks);
+        super.scale(entity, stack, ticks);
-        GlStateManager.scalef(0.9375F, 0.9375F, 0.9375F);
+        stack.scale(0.9375F, 0.9375F, 0.9375F);
     }
 }

src/main/java/com/minelittlepony/client/render/entities/RenderPonyVex.java

@@ -1,13 +1,13 @@
 package com.minelittlepony.client.render.entities;
 
-import net.fabricmc.fabric.api.client.render.EntityRendererRegistry;
+import net.fabricmc.fabric.api.client.rendereregistry.v1.EntityRendererRegistry;
 import net.minecraft.client.render.entity.BipedEntityRenderer;
 import net.minecraft.client.render.entity.EntityRenderDispatcher;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.mob.VexEntity;
 import net.minecraft.util.Identifier;
 
 import com.minelittlepony.client.model.entities.ModelBreezie;
-import com.mojang.blaze3d.platform.GlStateManager;
 
 /**
  * AKA a breezie :D
@@ -22,12 +22,12 @@ public class RenderPonyVex extends BipedEntityRenderer<VexEntity, ModelBreezie<V
     }
 
     @Override
-    protected void scale(VexEntity entity, float ticks) {
+    protected void scale(VexEntity entity, MatrixStack stack, float ticks) {
-        GlStateManager.scalef(0.4F, 0.4F, 0.4F);
+        stack.scale(0.4F, 0.4F, 0.4F);
     }
 
     @Override
-    protected Identifier getTexture(VexEntity entity) {
+    public Identifier getTexture(VexEntity entity) {
         return entity.isCharging() ? VEX_CHARGING : VEX;
     }
 

src/main/java/com/minelittlepony/client/render/entities/RenderPonyWitch.java

@@ -2,11 +2,12 @@ package com.minelittlepony.client.render.entities;
 
 import com.minelittlepony.client.model.entities.ModelWitchPony;
 import com.minelittlepony.client.render.layer.LayerHeldPonyItem;
-import com.mojang.blaze3d.platform.GlStateManager;
 
-import net.fabricmc.fabric.api.client.render.EntityRendererRegistry;
+import net.fabricmc.fabric.api.client.rendereregistry.v1.EntityRendererRegistry;
 import net.minecraft.client.render.entity.EntityRenderDispatcher;
 import net.minecraft.client.render.model.json.ModelTransformation;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.client.util.math.Vector3f;
 import net.minecraft.entity.mob.WitchEntity;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.Arm;
@@ -24,17 +25,17 @@ public class RenderPonyWitch extends RenderPonyMob<WitchEntity, ModelWitchPony>
     protected LayerHeldPonyItem<WitchEntity, ModelWitchPony> createItemHoldingLayer() {
         return new LayerHeldPonyItem<WitchEntity, ModelWitchPony>(this) {
             @Override
-            protected void preItemRender(WitchEntity entity, ItemStack drop, ModelTransformation.Type transform, Arm hand) {
+            protected void preItemRender(WitchEntity entity, ItemStack drop, ModelTransformation.Type transform, Arm hand, MatrixStack stack) {
-                GlStateManager.translatef(0, -0.3F, -0.8F);
+                stack.translate(0, -0.3F, -0.8F);
-                GlStateManager.rotatef(10, 1, 0, 0);
+                stack.multiply(Vector3f.POSITIVE_X.getDegreesQuaternion(10));
             }
         };
     }
 
     @Override
-    public void scale(WitchEntity entity, float ticks) {
+    public void scale(WitchEntity entity, MatrixStack stack, float ticks) {
-        super.scale(entity, ticks);
+        super.scale(entity, stack, ticks);
-        GlStateManager.scalef(BASE_MODEL_SCALE, BASE_MODEL_SCALE, BASE_MODEL_SCALE);
+        stack.scale(BASE_MODEL_SCALE, BASE_MODEL_SCALE, BASE_MODEL_SCALE);
     }
 
     @Override

src/main/java/com/minelittlepony/client/render/entities/RenderPonyZombie.java

@@ -1,10 +1,10 @@
 package com.minelittlepony.client.render.entities;
 
 import com.minelittlepony.client.model.entities.ModelZombiePony;
-import com.mojang.blaze3d.platform.GlStateManager;
 
-import net.fabricmc.fabric.api.client.render.EntityRendererRegistry;
+import net.fabricmc.fabric.api.client.rendereregistry.v1.EntityRendererRegistry;
 import net.minecraft.client.render.entity.EntityRenderDispatcher;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.mob.DrownedEntity;
 import net.minecraft.entity.mob.GiantEntity;
 import net.minecraft.entity.mob.HuskEntity;
@@ -28,7 +28,6 @@ public class RenderPonyZombie<Zombie extends ZombieEntity> extends RenderPonyMob
         return ZOMBIE;
     }
 
-
     public static class Drowned extends RenderPonyZombie<DrownedEntity> {
 
         public Drowned(EntityRenderDispatcher manager, EntityRendererRegistry.Context context) {
@@ -60,9 +59,9 @@ public class RenderPonyZombie<Zombie extends ZombieEntity> extends RenderPonyMob
         }
 
         @Override
-        public void scale(HuskEntity entity, float ticks) {
+        public void scale(HuskEntity entity, MatrixStack stack, float ticks) {
-            super.scale(entity, ticks);
+            super.scale(entity, stack, ticks);
-            GlStateManager.scalef(1.0625F, 1.0625F, 1.0625F);
+            stack.scale(1.0625F, 1.0625F, 1.0625F);
         }
 
         @Override
@@ -79,9 +78,9 @@ public class RenderPonyZombie<Zombie extends ZombieEntity> extends RenderPonyMob
 		}
 
 		@Override
-		public void scale(GiantEntity entity, float ticks) {
+		public void scale(GiantEntity entity, MatrixStack stack, float ticks) {
-	        super.scale(entity, ticks);
+	        super.scale(entity, stack, ticks);
-	        GlStateManager.scalef(3, 3, 3);
+	        stack.scale(3, 3, 3);
 	    }
 
 		@Override

src/main/java/com/minelittlepony/client/render/entities/player/RenderPonyPlayer.java

@@ -18,20 +18,19 @@ import com.minelittlepony.client.render.layer.LayerPonyElytra;
 import com.minelittlepony.model.gear.IGear;
 import com.minelittlepony.pony.IPony;
 import com.minelittlepony.pony.meta.Race;
-import com.mojang.blaze3d.platform.GlStateManager;
 
 import java.util.List;
 
 import net.minecraft.block.BedBlock;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.network.AbstractClientPlayerEntity;
-import net.minecraft.client.render.VisibleRegion;
+import net.minecraft.client.render.Frustum;
+import net.minecraft.client.render.VertexConsumerProvider;
 import net.minecraft.client.render.entity.EntityRenderDispatcher;
 import net.minecraft.client.render.entity.PlayerEntityRenderer;
 import net.minecraft.client.render.entity.feature.FeatureRenderer;
 import net.minecraft.client.render.entity.feature.StuckArrowsFeatureRenderer;
-import net.minecraft.entity.Entity;
+import net.minecraft.client.util.math.MatrixStack;
-import net.minecraft.entity.LivingEntity;
 import net.minecraft.util.Arm;
 import net.minecraft.util.Identifier;
 
@@ -57,7 +56,7 @@ public class RenderPonyPlayer extends PlayerEntityRenderer implements IPonyRende
         addLayer(new LayerPonyElytra<>(this));
         addLayer(new LayerHeldPonyItemMagical<>(this));
         addLayer(new LayerPonyCape<>(this));
-        addLayer(new LayerEntityOnPonyShoulder<>(renderManager, this));
+        addLayer(new LayerEntityOnPonyShoulder<>(this));
         addLayer(new LayerGear<>(this));
     }
 
@@ -67,42 +66,40 @@ public class RenderPonyPlayer extends PlayerEntityRenderer implements IPonyRende
     }
 
     @Override
-    public float scaleAndTranslate(AbstractClientPlayerEntity player, float ticks) {
+    protected void scale(AbstractClientPlayerEntity player, MatrixStack stack, float ticks) {
-        if (!player.hasVehicle() && !player.isSleeping()) {
+        renderPony.preRenderCallback(player, stack, ticks);
-            float x = player.getWidth() / 2 * renderPony.getPony(player).getMetadata().getSize().getScaleFactor();
-            float y = 0;
-
-            if (player.isInSneakingPose()) {
-                // Sneaking makes the player 1/15th shorter.
-                // This should be compatible with height-changing mods.
-                y += player.getHeight() / 15;
-            }
-
-            super.postRender(player, 0, y, x, 0, ticks);
-        }
-
-        return super.scaleAndTranslate(player, ticks);
-    }
-
-    @Override
-    protected void scale(AbstractClientPlayerEntity player, float ticks) {
-        renderPony.preRenderCallback(player, ticks);
-        field_4673 = renderPony.getShadowScale();
 
         if (player.hasVehicle()) {
-            GlStateManager.translated(0, player.getHeightOffset(), 0);
+            stack.translate(0, player.getHeightOffset(), 0);
         }
     }
 
     @Override
-    public void render(AbstractClientPlayerEntity entity, double xPosition, double yPosition, double zPosition, float yaw, float ticks) {
+    public void render(AbstractClientPlayerEntity entity, float entityYaw, float tickDelta, MatrixStack stack, VertexConsumerProvider renderContext, int lightUv) {
-        super.render(entity, xPosition, yPosition, zPosition, yaw, ticks);
+        field_4673 = renderPony.getShadowScale();
+        super.render(entity, entityYaw, tickDelta, stack, renderContext, lightUv);
+
+        DebugBoundingBoxRenderer.instance.render(renderPony.getPony(entity), entity, stack, renderContext);
+
+        // Translate the shadow position after everything is done
+        // (shadows are drawn after us)
+        if (!entity.hasVehicle() && !entity.isSleeping()) {
+            float x = entity.getWidth() / 2 * renderPony.getPony(entity).getMetadata().getSize().getScaleFactor();
+            float y = 0;
+
+            if (entity.isInSneakingPose()) {
+                // Sneaking makes the player 1/15th shorter.
+                // This should be compatible with height-changing mods.
+                y += entity.getHeight() / 15;
+            }
+
+            stack.translate(x, y, 0);
+        }
 
-        DebugBoundingBoxRenderer.instance.render(renderPony.getPony(entity), entity, ticks);
     }
 
     @Override
-    public boolean isVisible(AbstractClientPlayerEntity entity, VisibleRegion camera, double camX, double camY, double camZ) {
+    public boolean isVisible(AbstractClientPlayerEntity entity, Frustum camera, double camX, double camY, double camZ) {
         if (entity.isSleeping() && entity == MinecraftClient.getInstance().player) {
             return true;
         }
@@ -110,58 +107,51 @@ public class RenderPonyPlayer extends PlayerEntityRenderer implements IPonyRende
     }
 
     @Override
-    protected void renderLabel(AbstractClientPlayerEntity entity, String name, double x, double y, double z, int maxDistance) {
+    protected void renderLabelIfPresent(AbstractClientPlayerEntity entity, String name, MatrixStack stack, VertexConsumerProvider renderContext, int maxDistance) {
         if (entity.isSleeping()) {
             if (entity.getSleepingPosition().isPresent() && entity.getEntityWorld().getBlockState(entity.getSleepingPosition().get()).getBlock() instanceof BedBlock) {
                 double bedRad = Math.toRadians(entity.getSleepingDirection().asRotation());
-                x += Math.cos(bedRad);
+
-                z -= Math.sin(bedRad);
+                stack.translate(Math.cos(bedRad), 0, -Math.sin(bedRad));
             }
         }
-        super.renderLabel(entity, name, x, renderPony.getNamePlateYOffset(entity, y), z, maxDistance);
+        stack.translate(0, renderPony.getNamePlateYOffset(entity), 0);
+        super.renderLabelIfPresent(entity, name, stack, renderContext, maxDistance);
     }
 
     @Override
-    public void postRender(Entity player, double x, double y, double z, float yaw, float ticks) {
+    public final void renderRightArm(MatrixStack stack, VertexConsumerProvider renderContext, int lightUv, AbstractClientPlayerEntity player) {
-        if (player.hasVehicle() && ((LivingEntity)player).isSleeping()) {
+        renderArm(stack, renderContext, lightUv, player, Arm.RIGHT);
-            super.postRender(player, x, y, z, yaw, ticks);
-        }
     }
 
     @Override
-    public final void renderRightArm(AbstractClientPlayerEntity player) {
+    public final void renderLeftArm(MatrixStack stack, VertexConsumerProvider renderContext, int lightUv, AbstractClientPlayerEntity player) {
-        renderArm(player, Arm.RIGHT);
+        renderArm(stack, renderContext, lightUv, player, Arm.LEFT);
     }
 
-    @Override
+    protected void renderArm(MatrixStack stack, VertexConsumerProvider renderContext, int lightUv, AbstractClientPlayerEntity player, Arm side) {
-    public final void renderLeftArm(AbstractClientPlayerEntity player) {
-        renderArm(player, Arm.LEFT);
-    }
-
-    protected void renderArm(AbstractClientPlayerEntity player, Arm side) {
         renderPony.updateModel(player);
-        bindEntityTexture(player);
 
-        GlStateManager.pushMatrix();
+        stack.push();
         float reflect = side == Arm.LEFT ? 1 : -1;
 
-        GlStateManager.translatef(reflect * -0.1F, -0.74F, 0);
+        stack.translate(reflect * -0.1F, -0.74F, 0);
 
         if (side == Arm.LEFT) {
-            super.renderLeftArm(player);
+            super.renderLeftArm(stack, renderContext, lightUv, player);
         } else {
-            super.renderRightArm(player);
+            super.renderRightArm(stack, renderContext, lightUv, player);
         }
 
-        GlStateManager.popMatrix();
+        stack.pop();
     }
 
     @Override
-    protected void setupTransforms(AbstractClientPlayerEntity player, float age, float yaw, float ticks) {
+    protected void setupTransforms(AbstractClientPlayerEntity entity, MatrixStack stack, float ageInTicks, float rotationYaw, float partialTicks) {
-        yaw = renderPony.getRenderYaw(player, yaw, ticks);
+        rotationYaw = renderPony.getRenderYaw(entity, rotationYaw, partialTicks);
-        super.setupTransforms(player, age, yaw, ticks);
+        super.setupTransforms(entity, stack, ageInTicks, rotationYaw, partialTicks);
 
-        renderPony.applyPostureTransform(player, yaw, ticks);
+        renderPony.applyPostureTransform(entity, stack, rotationYaw, partialTicks);
     }
 
     @Override

src/main/java/com/minelittlepony/client/render/entities/player/RenderSeaponyPlayer.java

@@ -35,9 +35,9 @@ public class RenderSeaponyPlayer extends RenderPonyPlayer {
         float interpolated = pony.getMetadata().getInterpolator(player.getUuid()).interpolate("seapony_state", state, 5);
 
         if (!MathUtil.compareFloats(interpolated, state)) {
-            double x = player.x + (player.getEntityWorld().getRandom().nextFloat() * 2) - 1;
+            double x = player.getX() + (player.getEntityWorld().getRandom().nextFloat() * 2) - 1;
-            double y = player.y + (player.getEntityWorld().getRandom().nextFloat() * 2);
+            double y = player.getY() + (player.getEntityWorld().getRandom().nextFloat() * 2);
-            double z = player.z + (player.getEntityWorld().getRandom().nextFloat() * 2) - 1;
+            double z = player.getZ() + (player.getEntityWorld().getRandom().nextFloat() * 2) - 1;
 
             player.getEntityWorld().addParticle(ParticleTypes.END_ROD, x, y, z, 0, 0, 0);
         }

src/main/java/com/minelittlepony/client/render/entities/villager/AbstractVillagerRenderer.java

@@ -1,5 +1,6 @@
 package com.minelittlepony.client.render.entities.villager;
 
+import net.minecraft.client.model.ModelPart;
 import net.minecraft.client.render.entity.EntityRenderDispatcher;
 import net.minecraft.client.render.entity.model.ModelWithHat;
 import net.minecraft.entity.mob.MobEntity;
@@ -10,14 +11,13 @@ import net.minecraft.village.VillagerProfession;
 import com.minelittlepony.client.model.ClientPonyModel;
 import com.minelittlepony.client.render.entities.RenderPonyMob;
 import com.minelittlepony.client.render.layer.LayerGear;
-import com.minelittlepony.client.util.render.Part;
 import com.minelittlepony.model.IUnicorn;
 import com.minelittlepony.model.gear.IGear;
 import com.minelittlepony.util.resources.ITextureSupplier;
 
 abstract class AbstractVillagerRenderer<
     T extends MobEntity & VillagerDataContainer,
-    M extends ClientPonyModel<T> & IUnicorn<Part> & ModelWithHat> extends RenderPonyMob.Caster<T, M> {
+    M extends ClientPonyModel<T> & IUnicorn<ModelPart> & ModelWithHat> extends RenderPonyMob.Caster<T, M> {
 
     private final ITextureSupplier<T> baseTextures;
 

src/main/java/com/minelittlepony/client/render/entities/villager/RenderPonyVillager.java

@@ -2,10 +2,10 @@ package com.minelittlepony.client.render.entities.villager;
 
 import com.minelittlepony.client.model.entities.ModelVillagerPony;
 import com.minelittlepony.util.resources.ITextureSupplier;
-import com.mojang.blaze3d.platform.GlStateManager;
 
-import net.fabricmc.fabric.api.client.render.EntityRendererRegistry;
+import net.fabricmc.fabric.api.client.rendereregistry.v1.EntityRendererRegistry;
 import net.minecraft.client.render.entity.EntityRenderDispatcher;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.passive.VillagerEntity;
 
 public class RenderPonyVillager extends AbstractVillagerRenderer<VillagerEntity, ModelVillagerPony<VillagerEntity>> {
@@ -18,9 +18,9 @@ public class RenderPonyVillager extends AbstractVillagerRenderer<VillagerEntity,
     }
 
     @Override
-    public void scale(VillagerEntity villager, float ticks) {
+    public void scale(VillagerEntity villager, MatrixStack stack, float ticks) {
-        super.scale(villager, ticks);
+        super.scale(villager, stack, ticks);
-        GlStateManager.scalef(BASE_MODEL_SCALE, BASE_MODEL_SCALE, BASE_MODEL_SCALE);
+        stack.scale(BASE_MODEL_SCALE, BASE_MODEL_SCALE, BASE_MODEL_SCALE);
     }
 
 }

src/main/java/com/minelittlepony/client/render/entities/villager/RenderPonyZombieVillager.java

@@ -3,8 +3,9 @@ package com.minelittlepony.client.render.entities.villager;
 import com.minelittlepony.client.model.entities.ModelZombieVillagerPony;
 import com.minelittlepony.util.resources.ITextureSupplier;
 
-import net.fabricmc.fabric.api.client.render.EntityRendererRegistry;
+import net.fabricmc.fabric.api.client.rendereregistry.v1.EntityRendererRegistry;
 import net.minecraft.client.render.entity.EntityRenderDispatcher;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.mob.ZombieVillagerEntity;
 
 public class RenderPonyZombieVillager extends AbstractVillagerRenderer<ZombieVillagerEntity, ModelZombieVillagerPony> {
@@ -17,11 +18,11 @@ public class RenderPonyZombieVillager extends AbstractVillagerRenderer<ZombieVil
     }
 
     @Override
-    protected void setupTransforms(ZombieVillagerEntity entity, float move, float rotationYaw, float ticks) {
+    protected void setupTransforms(ZombieVillagerEntity entity, MatrixStack stack, float move, float rotationYaw, float ticks) {
         if (entity.isConverting()) {
             rotationYaw += (float) (Math.cos(entity.age * 3.25D) * (Math.PI / 4));
         }
 
-        super.setupTransforms(entity, move, rotationYaw, ticks);
+        super.setupTransforms(entity, stack, move, rotationYaw, ticks);
     }
 }

src/main/java/com/minelittlepony/client/render/layer/AbstractPonyLayer.java

@@ -3,9 +3,11 @@ package com.minelittlepony.client.render.layer;
 import com.minelittlepony.client.model.IPonyModel;
 import com.minelittlepony.client.render.IPonyRender;
 
+import net.minecraft.client.render.VertexConsumerProvider;
 import net.minecraft.client.render.entity.feature.FeatureRenderer;
 import net.minecraft.client.render.entity.feature.FeatureRendererContext;
 import net.minecraft.client.render.entity.model.EntityModel;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.LivingEntity;
 
 public abstract class AbstractPonyLayer<T extends LivingEntity, M extends EntityModel<T> & IPonyModel<T>> extends FeatureRenderer<T, M> {
@@ -21,17 +23,19 @@ public abstract class AbstractPonyLayer<T extends LivingEntity, M extends Entity
     /**
      * Renders this layer.
      *
+     * @param stack        The GL transformation matrix
+     * @param vertices     The output 3D vertex buffer
+     * @param lightUv      The current light value
      * @param entity       The entity we're being called for.
-     * @param move         Entity motion parameter - i.e. velocity in no specific direction used in bipeds to calculate step amount.
+     * @param limbDistance Entity motion parameter - i.e. velocity in no specific direction used in bipeds to calculate step amount.
-     * @param swing        Degree to which each 'limb' swings.
+     * @param limbAngle    Degree to which each 'limb' swings.
-     * @param partialTicks Render partial ticks
+     * @param tickDelta    Render partial ticks
-     * @param ticks        Total whole and partial ticks since the entity's existance. Used in animations together with {@code swing} and {@code move}.
+     * @param age          Total whole and partial ticks since the entity's existance. Used in animations together with {@code swing} and {@code move}.
      * @param headYaw      Horizontal head motion in radians.
      * @param headPitch    Vertical head motion in radians.
-     * @param scale        Scaling factor used to render this model. Determined by the return value of {@link RenderLivingBase.prepareScale}. Usually {@code 0.0625F}.
      */
     @Override
-    public abstract void render(T entity, float move, float swing, float partialTicks, float ticks, float headYaw, float headPitch, float scale);
+    public abstract void render(MatrixStack stack, VertexConsumerProvider renderContext, int lightUv, T entity, float limbDistance, float limbAngle, float tickDelta, float age, float headYaw, float headPitch);
 
     @SuppressWarnings("unchecked")
     protected <C extends IPonyRender<T, M> & FeatureRendererContext<T, M>> C getContext() {
@@ -45,9 +49,4 @@ public abstract class AbstractPonyLayer<T extends LivingEntity, M extends Entity
     public M getMainModel() {
         return getContext().getModel();
     }
-
-    @Override
-    public boolean hasHurtOverlay() {
-        return false;
-    }
 }

src/main/java/com/minelittlepony/client/render/layer/LayerDJPon3Head.java

@@ -1,13 +1,16 @@
 package com.minelittlepony.client.render.layer;
 
 import net.minecraft.client.network.AbstractClientPlayerEntity;
+import net.minecraft.client.render.OverlayTexture;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.render.VertexConsumerProvider;
 import net.minecraft.client.render.entity.model.EntityModel;
+import net.minecraft.client.util.math.MatrixStack;
 
 import com.minelittlepony.client.model.IPonyModel;
 import com.minelittlepony.client.model.components.ModelDeadMau5Ears;
 import com.minelittlepony.client.render.IPonyRender;
 import com.minelittlepony.model.BodyPart;
-import com.mojang.blaze3d.platform.GlStateManager;
 
 public class LayerDJPon3Head<T extends AbstractClientPlayerEntity, M extends EntityModel<T> & IPonyModel<T>> extends AbstractPonyLayer<T, M> {
 
@@ -18,26 +21,22 @@ public class LayerDJPon3Head<T extends AbstractClientPlayerEntity, M extends Ent
     }
 
     @Override
-    public void render(T entity, float move, float swing, float partialTicks, float ticks, float headYaw, float headPitch, float scale) {
+    public void render(MatrixStack stack, VertexConsumerProvider renderContext, int lightUv, T entity, float limbDistance, float limbAngle, float tickDelta, float age, float headYaw, float headPitch) {
         if ("deadmau5".equals(entity.getName().getString())) {
-            getContext().bindTexture(entity.getSkinTexture());
+            stack.push();
+            getPlayerModel().transform(BodyPart.HEAD, stack);
+            getPlayerModel().getHead().rotate(stack);
 
-            GlStateManager.pushMatrix();
+            stack.scale(1.3333334F, 1.3333334F, 1.3333334F);
-            getPlayerModel().transform(BodyPart.HEAD);
+            stack.translate(0, 0.3F, 0);
-            getPlayerModel().getHead().applyTransform(scale);
-
-            GlStateManager.scalef(1.3333334F, 1.3333334F, 1.3333334F);
-            GlStateManager.translatef(0, 0.3F, 0);
 
             deadMau5.setVisible(true);
-            deadMau5.render(move, swing, partialTicks, 0, 0, scale);
 
-            GlStateManager.popMatrix();
+            VertexConsumer vertices = renderContext.getBuffer(deadMau5.getLayer(entity.getSkinTexture()));
-        }
-    }
 
-    @Override
+            deadMau5.render(stack, vertices, OverlayTexture.DEFAULT_UV, lightUv, limbDistance, limbAngle, tickDelta, 1);
-    public boolean hasHurtOverlay() {
+
-        return true;
+            stack.pop();
+        }
     }
 }

src/main/java/com/minelittlepony/client/render/layer/LayerEntityOnPonyShoulder.java

@@ -1,87 +1,49 @@
 package com.minelittlepony.client.render.layer;
 
-import net.minecraft.client.network.AbstractClientPlayerEntity;
+import net.minecraft.client.render.OverlayTexture;
-import net.minecraft.client.render.entity.EntityRenderDispatcher;
+import net.minecraft.client.render.VertexConsumer;
-import net.minecraft.client.render.entity.EntityRenderer;
+import net.minecraft.client.render.VertexConsumerProvider;
+import net.minecraft.client.render.entity.ParrotEntityRenderer;
+import net.minecraft.client.render.entity.model.ParrotEntityModel;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.client.util.math.Vector3f;
 import net.minecraft.entity.EntityType;
-import net.minecraft.entity.LivingEntity;
+import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.nbt.CompoundTag;
 
 import com.minelittlepony.client.model.ClientPonyModel;
 import com.minelittlepony.client.render.IPonyRender;
 import com.minelittlepony.model.BodyPart;
-import com.mojang.blaze3d.platform.GlStateManager;
 
-import javax.annotation.Nullable;
+public class LayerEntityOnPonyShoulder<T extends PlayerEntity, M extends ClientPonyModel<T>> extends AbstractPonyLayer<T, M> {
 
-public class LayerEntityOnPonyShoulder<M extends ClientPonyModel<AbstractClientPlayerEntity>> extends AbstractPonyLayer<AbstractClientPlayerEntity, M> {
+    private final ParrotEntityModel model = new ParrotEntityModel();
 
-    private final EntityRenderDispatcher renderManager;
+    public LayerEntityOnPonyShoulder(IPonyRender<T, M> context) {
-
-    private LivingEntity leftEntity;
-    private LivingEntity rightEntity;
-
-    public LayerEntityOnPonyShoulder(EntityRenderDispatcher manager, IPonyRender<AbstractClientPlayerEntity, M> context) {
         super(context);
-        renderManager = manager;
     }
 
     @Override
-    public void render(AbstractClientPlayerEntity player, float move, float swing, float partialTicks, float ticks, float headYaw, float headPitch, float scale) {
+    public void render(MatrixStack stack, VertexConsumerProvider renderContext, int lightUv, T entity, float limbDistance, float limbAngle, float tickDelta, float age, float headYaw, float headPitch) {
-
+        renderShoulderParrot(stack, renderContext, lightUv, entity, limbDistance, limbAngle, headYaw, headPitch, true);
-        GlStateManager.enableRescaleNormal();
+        renderShoulderParrot(stack, renderContext, lightUv, entity, limbDistance, limbAngle, headYaw, headPitch, false);
-        GlStateManager.color4f(1, 1, 1, 1);
-
-        CompoundTag leftTag = player.getShoulderEntityLeft();
-
-        if (!leftTag.isEmpty()) {
-            leftEntity = renderShoulderEntity(player, leftEntity, leftTag, headYaw, headPitch, true);
     }
 
-        CompoundTag rightTag = player.getShoulderEntityRight();
+    private void renderShoulderParrot(MatrixStack stack, VertexConsumerProvider renderContext, int lightUv, T entity, float limbDistance, float limbAngle, float headYaw, float headPitch, boolean left) {
 
-        if (!rightTag.isEmpty()) {
+        CompoundTag riderTag = left ? entity.getShoulderEntityLeft() : entity.getShoulderEntityRight();
-            rightEntity = renderShoulderEntity(player, rightEntity, rightTag, headYaw, headPitch, false);
-        }
 
-        GlStateManager.disableRescaleNormal();
+        EntityType.get(riderTag.getString("id")).filter(p -> p == EntityType.PARROT).ifPresent((entityType) -> {
-    }
+           stack.push();
 
-    @Nullable
+           getModel().transform(BodyPart.BODY, stack);
-    private LivingEntity renderShoulderEntity(AbstractClientPlayerEntity player, @Nullable LivingEntity entity, CompoundTag shoulderTag, float headYaw, float headPitch, boolean left) {
 
-        if (entity == null || !entity.getUuid().equals(shoulderTag.getUuid("UUID"))) {
+           stack.translate(left ? 0.25 : -0.25, entity.isInSneakingPose() ? -0.5 : -0.25, 0.35);
-            entity = (LivingEntity) EntityType.getEntityFromTag(shoulderTag, player.world).orElse(null);
+           stack.multiply(Vector3f.POSITIVE_Z.getDegreesQuaternion(left ? -5 : 5));
-            // this isn't an entity.
-            if (entity == null) {
-                return null;
-            }
-        }
 
-        EntityRenderer<LivingEntity> render = renderManager.getRenderer(entity);
+           VertexConsumer vertexConsumer = renderContext.getBuffer(model.getLayer(ParrotEntityRenderer.SKINS[riderTag.getInt("Variant")]));
-
+           model.method_17106(stack, vertexConsumer, lightUv, OverlayTexture.DEFAULT_UV, limbDistance, limbAngle, headYaw, headPitch, entity.age);
-        if (render == null) {
+           stack.pop();
-            return entity;
+        });
-        }
-
-        GlStateManager.pushMatrix();
-
-        getModel().transform(BodyPart.BODY);
-
-        // render on the haunches
-        GlStateManager.translatef(left ? 0.25F : -0.25F, 0.25F, 0.35F);
-        GlStateManager.scalef(1, -1, -1);
-        GlStateManager.rotatef(left ? -5 : 5, 0, 0, 1);
-
-        // look where the player is looking
-        entity.prevHeadYaw = headYaw;
-        entity.headYaw = headYaw;
-        entity.pitch = headPitch;
-        entity.prevPitch = headPitch;
-
-        render.render(entity, 0, 0, 0, 0, 0);
-
-        GlStateManager.popMatrix();
-        return entity;
     }
 }

src/main/java/com/minelittlepony/client/render/layer/LayerEyeGlow.java

@@ -1,55 +1,27 @@
 package com.minelittlepony.client.render.layer;
 
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.render.RenderLayer;
+import net.minecraft.client.render.entity.feature.EyesFeatureRenderer;
+import net.minecraft.client.render.entity.feature.FeatureRendererContext;
 import net.minecraft.client.render.entity.model.EntityModel;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.util.Identifier;
 
 import com.minelittlepony.client.model.IPonyModel;
 import com.minelittlepony.client.render.IPonyRender;
-import com.mojang.blaze3d.platform.GLX;
-import com.mojang.blaze3d.platform.GlStateManager.DestFactor;
-import com.mojang.blaze3d.platform.GlStateManager.SourceFactor;
 
-import static com.mojang.blaze3d.platform.GlStateManager.*;
+public class LayerEyeGlow<T extends LivingEntity, M extends EntityModel<T> & IPonyModel<T>> extends EyesFeatureRenderer<T, M> {
 
-public class LayerEyeGlow<T extends LivingEntity, M extends EntityModel<T> & IPonyModel<T>> extends AbstractPonyLayer<T, M> {
+    private final RenderLayer layer;
 
-    private final Identifier eyeTexture;
+    public <V extends FeatureRendererContext<T, M> & IPonyRender<T, M> & IGlowingRenderer> LayerEyeGlow(V renderer) {
-
-    public <V extends IPonyRender<T, M> & IGlowingRenderer> LayerEyeGlow(V renderer) {
         super(renderer);
-        eyeTexture = renderer.getEyeTexture();
+        layer = RenderLayer.getEyes(renderer.getEyeTexture());
     }
 
     @Override
-    public void render(T entity, float move, float swing, float partialTicks, float ticks, float headYaw, float headPitch, float scale) {
+    public RenderLayer getEyesTexture() {
-        getContext().bindTexture(eyeTexture);
+        return layer;
-
-        enableBlend();
-        disableAlphaTest();
-        blendFunc(SourceFactor.ONE, DestFactor.ONE);
-
-        disableLighting();
-        depthMask(!entity.isInvisible());
-        GLX.glMultiTexCoord2f(GLX.GL_TEXTURE1, 61680, 0);
-        enableLighting();
-
-        color4f(1, 1, 1, 1);
-
-        MinecraftClient.getInstance().gameRenderer.setFogBlack(true);
-
-        getModel().setAngles(entity, move, swing, ticks, headYaw, headPitch, scale);
-
-        MinecraftClient.getInstance().gameRenderer.setFogBlack(false);
-
-        getContext().applyLightmapCoordinates(entity);
-
-        depthMask(true);
-
-        blendFunc(SourceFactor.ONE, DestFactor.ZERO);
-        disableBlend();
-        enableAlphaTest();
     }
 
     public interface IGlowingRenderer {

src/main/java/com/minelittlepony/client/render/layer/LayerGear.java

@@ -1,10 +1,13 @@
 package com.minelittlepony.client.render.layer;
 
+import net.minecraft.client.render.OverlayTexture;
+import net.minecraft.client.render.RenderLayer;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.render.VertexConsumerProvider;
 import net.minecraft.client.render.entity.model.EntityModel;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.LivingEntity;
 
-import org.lwjgl.opengl.GL11;
-
 import com.google.common.collect.Lists;
 import com.minelittlepony.client.model.IPonyModel;
 import com.minelittlepony.client.model.gear.ChristmasHat;
@@ -16,7 +19,6 @@ import com.minelittlepony.client.render.IPonyRender;
 import com.minelittlepony.model.BodyPart;
 import com.minelittlepony.model.gear.IGear;
 import com.minelittlepony.model.gear.IStackable;
-import com.mojang.blaze3d.platform.GlStateManager;
 
 import java.util.HashMap;
 import java.util.List;
@@ -43,7 +45,7 @@ public class LayerGear<T extends LivingEntity, M extends EntityModel<T> & IPonyM
     }
 
     @Override
-    public void render(T entity, float move, float swing, float partialTicks, float ticks, float headYaw, float headPitch, float scale) {
+    public void render(MatrixStack stack, VertexConsumerProvider renderContext, int lightUv, T entity, float limbDistance, float limbAngle, float tickDelta, float age, float headYaw, float headPitch) {
 
         if (entity.isInvisible()) {
             return;
@@ -55,37 +57,34 @@ public class LayerGear<T extends LivingEntity, M extends EntityModel<T> & IPonyM
 
         for (IGear gear : gears) {
             if (getContext().shouldRender(model, entity, gear)) {
-                GlStateManager.pushMatrix();
+                stack.push();
-                model.transform(gear.getGearLocation());
+                model.transform(gear.getGearLocation(), stack);
-                model.getBodyPart(gear.getGearLocation()).applyTransform(scale);
+                model.getBodyPart(gear.getGearLocation()).rotate(stack);
 
                 if (gear instanceof IStackable) {
                     BodyPart part = gear.getGearLocation();
                     renderStackingOffsets.compute(part, (k, v) -> {
                         float offset = ((IStackable)gear).getStackingOffset();
                         if (v != null) {
-                            GlStateManager.translatef(0, -v, 0);
+                            stack.translate(0, -v, 0);
                             offset += v;
                         }
                         return offset;
                     });
                 }
 
-                renderGear(model, entity, gear, move, swing, scale, ticks);
+                renderGear(model, entity, gear, stack, renderContext, lightUv, limbDistance, limbAngle, tickDelta);
-                GlStateManager.popMatrix();
+                stack.pop();
             }
         }
     }
 
-    private void renderGear(M model, T entity, IGear gear, float move, float swing, float scale, float ticks) {
+    private void renderGear(M model, T entity, IGear gear, MatrixStack stack, VertexConsumerProvider renderContext, int lightUv, float limbDistance, float limbAngle, float tickDelta) {
-        GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS);
-
-        getContext().bindTexture(gear.getTexture(entity, getContext()));
 
         gear.setLivingAnimations(model, entity);
-        gear.setRotationAndAngles(model.getAttributes().isGoingFast, entity.getUuid(), move, swing, model.getWobbleAmount(), ticks);
+        gear.setRotationAndAngles(model.getAttributes().isGoingFast, entity.getUuid(), limbDistance, limbAngle, model.getWobbleAmount(), tickDelta);
-        gear.renderPart(scale, entity.getUuid());
 
-        GL11.glPopAttrib();
+        VertexConsumer vertexConsumer = renderContext.getBuffer(RenderLayer.getEntitySolid(gear.getTexture(entity, getContext())));
+        gear.renderPart(stack, vertexConsumer, OverlayTexture.DEFAULT_UV, lightUv, limbDistance, limbAngle, tickDelta, 1F, entity.getUuid());
     }
 }

src/main/java/com/minelittlepony/client/render/layer/LayerHeldItemIllager.java

@@ -1,5 +1,7 @@
 package com.minelittlepony.client.render.layer;
 
+import net.minecraft.client.render.VertexConsumerProvider;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.mob.IllagerEntity;
 import net.minecraft.util.Arm;
 
@@ -13,15 +15,15 @@ public class LayerHeldItemIllager<T extends IllagerEntity, M extends ModelAlicor
     }
 
     @Override
-    public void render(T entity, float move, float swing, float partialTicks, float ticks, float headYaw, float headPitch, float scale) {
+    public void render(MatrixStack stack, VertexConsumerProvider renderContext, int lightUv, T entity, float limbDistance, float limbAngle, float tickDelta, float age, float headYaw, float headPitch) {
         if (shouldRender(entity)) {
-            super.render(entity, move, swing, partialTicks, ticks, headYaw, headPitch, scale);
+            super.render(stack, renderContext, lightUv, entity, limbDistance, limbAngle, tickDelta, age, headYaw, headPitch);
         }
     }
 
     @Override
-    protected void renderArm(Arm side) {
+    protected void renderArm(Arm arm, MatrixStack stack) {
-        getModel().getArm(side).applyTransform(0.0625F);
+        getModel().getArm(arm).rotate(stack);
     }
 
     public boolean shouldRender(T entity) {

src/main/java/com/minelittlepony/client/render/layer/LayerHeldPonyItem.java

@@ -5,8 +5,11 @@ import com.minelittlepony.client.render.IPonyRender;
 import com.minelittlepony.model.BodyPart;
 
 import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.render.VertexConsumerProvider;
 import net.minecraft.client.render.entity.model.EntityModel;
 import net.minecraft.client.render.model.json.ModelTransformation;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.client.util.math.Vector3f;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.Arm;
@@ -32,7 +35,7 @@ public class LayerHeldPonyItem<T extends LivingEntity, M extends EntityModel<T>
     }
 
     @Override
-    public void render(T entity, float move, float swing, float partialTicks, float ticks, float headYaw, float headPitch, float scale) {
+    public void render(MatrixStack stack, VertexConsumerProvider renderContext, int lightUv, T entity, float limbDistance, float limbAngle, float tickDelta, float age, float headYaw, float headPitch) {
 
         ItemStack left = getLeftItem(entity);
         ItemStack right = getRightItem(entity);
@@ -40,55 +43,55 @@ public class LayerHeldPonyItem<T extends LivingEntity, M extends EntityModel<T>
         if (!left.isEmpty() || !right.isEmpty()) {
             M model = getModel();
 
-            pushMatrix();
+            stack.push();
 
-            model.transform(BodyPart.LEGS);
+            model.transform(BodyPart.LEGS, stack);
 
-            renderHeldItem(entity, right, ModelTransformation.Type.THIRD_PERSON_RIGHT_HAND, Arm.RIGHT);
+            renderHeldItem(entity, right, ModelTransformation.Type.THIRD_PERSON_RIGHT_HAND, Arm.RIGHT, stack, renderContext, lightUv);
-            renderHeldItem(entity, left, ModelTransformation.Type.THIRD_PERSON_LEFT_HAND, Arm.LEFT);
+            renderHeldItem(entity, left, ModelTransformation.Type.THIRD_PERSON_LEFT_HAND, Arm.LEFT, stack, renderContext, lightUv);
 
-            popMatrix();
+            stack.pop();
         }
     }
 
-    private void renderHeldItem(T entity, ItemStack drop, ModelTransformation.Type transform, Arm hand) {
+    private void renderHeldItem(T entity, ItemStack drop, ModelTransformation.Type transform, Arm arm, MatrixStack stack, VertexConsumerProvider renderContext, int lightUv) {
         if (!drop.isEmpty()) {
             pushMatrix();
-            renderArm(hand);
+            renderArm(arm, stack);
 
             if (getMainModel().getAttributes().isCrouching) {
                 translatef(0, 0.2F, 0);
             }
 
-            float left = hand == Arm.LEFT ? 1 : -1;
+            float left = arm == Arm.LEFT ? 1 : -1;
 
             if (entity.hasVehicle()) {
-                translatef(left / 10, -0.2F, -0.5F);
+                stack.translate(left / 10, -0.2F, -0.5F);
             }
 
-            rotatef(-90, 1, 0, 0);
+            stack.multiply(Vector3f.POSITIVE_X.getDegreesQuaternion(-90));
-            rotatef(left * 180, 0, 1, 0);
+            stack.multiply(Vector3f.POSITIVE_Y.getDegreesQuaternion(left * 180));
-            translatef(left * -0.2F, 0, 0);
+            stack.translate(left * -0.2F, 0, 0);
 
-            preItemRender(entity, drop, transform, hand);
+            preItemRender(entity, drop, transform, arm, stack);
-            MinecraftClient.getInstance().getItemRenderer().renderHeldItem(drop, entity, transform, hand == Arm.LEFT);
+            MinecraftClient.getInstance().getFirstPersonRenderer().renderItem(entity, drop, transform, arm == Arm.LEFT, stack, renderContext, lightUv);
-            postItemRender(entity, drop, transform, hand);
+            postItemRender(entity, drop, transform, arm, stack, renderContext);
 
             popMatrix();
         }
     }
 
-    protected void preItemRender(T entity, ItemStack drop, ModelTransformation.Type transform, Arm hand) {
+    protected void preItemRender(T entity, ItemStack drop, ModelTransformation.Type transform, Arm hand, MatrixStack stack) {
-        translatef(0, 0.125F, -1);
+        stack.translate(0, 0.125F, -1);
     }
 
-    protected void postItemRender(T entity, ItemStack drop, ModelTransformation.Type transform, Arm hand) {
+    protected void postItemRender(T entity, ItemStack drop, ModelTransformation.Type transform, Arm hand, MatrixStack stack, VertexConsumerProvider renderContext) {
     }
 
     /**
      * Renders the main arm
      */
-    protected void renderArm(Arm side) {
+    protected void renderArm(Arm arm, MatrixStack stack) {
-        getModel().setArmAngle(0.0625F, side);
+        getModel().setArmAngle(arm, stack);
     }
 }

src/main/java/com/minelittlepony/client/render/layer/LayerHeldPonyItemMagical.java

@@ -3,12 +3,13 @@ package com.minelittlepony.client.render.layer;
 import com.minelittlepony.client.PonyRenderManager;
 import com.minelittlepony.client.model.IPonyModel;
 import com.minelittlepony.client.render.IPonyRender;
-import com.minelittlepony.client.util.render.Part;
 import com.minelittlepony.model.IUnicorn;
-import com.mojang.blaze3d.platform.GlStateManager;
 
+import net.minecraft.client.model.ModelPart;
+import net.minecraft.client.render.VertexConsumerProvider;
 import net.minecraft.client.render.entity.model.EntityModel;
 import net.minecraft.client.render.model.json.ModelTransformation;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.Arm;
@@ -24,28 +25,28 @@ public class LayerHeldPonyItemMagical<T extends LivingEntity, M extends EntityMo
     }
 
     @Override
-    protected void preItemRender(T entity, ItemStack drop, ModelTransformation.Type transform, Arm hand) {
+    protected void preItemRender(T entity, ItemStack drop, ModelTransformation.Type transform, Arm hand, MatrixStack stack) {
         if (isUnicorn()) {
-            GlStateManager.translatef(hand == Arm.LEFT ? -0.6F : 0, 0.5F, -0.3F);
+            stack.translate(hand == Arm.LEFT ? -0.6F : 0, 0.5F, -0.3F);
         } else {
-            super.preItemRender(entity, drop, transform, hand);
+            super.preItemRender(entity, drop, transform, hand, stack);
         }
     }
 
     @Override
-    protected void postItemRender(T entity, ItemStack drop, ModelTransformation.Type transform, Arm hand) {
+    protected void postItemRender(T entity, ItemStack drop, ModelTransformation.Type transform, Arm hand, MatrixStack stack, VertexConsumerProvider renderContext) {
         if (isUnicorn()) {
-            PonyRenderManager.getInstance().getMagicRenderer().renderItemGlow(entity, drop, transform, hand, ((IUnicorn<?>)getModel()).getMagicColor());
+            PonyRenderManager.getInstance().getMagicRenderer().renderItemGlow(entity, drop, transform, hand, ((IUnicorn<?>)getModel()).getMagicColor(), stack, renderContext);
         }
     }
 
     @SuppressWarnings("unchecked")
     @Override
-    protected void renderArm(Arm side) {
+    protected void renderArm(Arm arm, MatrixStack stack) {
         if (isUnicorn()) {
-            ((IUnicorn<Part>)getModel()).getUnicornArmForSide(side).applyTransform(0.0625F);
+            ((IUnicorn<ModelPart>)getModel()).getUnicornArmForSide(arm).rotate(stack);
         } else {
-            super.renderArm(side);
+            super.renderArm(arm, stack);
         }
     }
 }

src/main/java/com/minelittlepony/client/render/layer/LayerOverlayBase.java

@@ -1,8 +1,13 @@
 package com.minelittlepony.client.render.layer;
 
+import net.minecraft.client.render.OverlayTexture;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.render.VertexConsumerProvider;
 import net.minecraft.client.render.entity.feature.FeatureRenderer;
 import net.minecraft.client.render.entity.feature.FeatureRendererContext;
 import net.minecraft.client.render.entity.model.BipedEntityModel;
+import net.minecraft.client.render.item.ItemRenderer;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.util.Identifier;
 
@@ -19,21 +24,15 @@ public abstract class LayerOverlayBase<T extends LivingEntity, M extends BipedEn
     }
 
     @Override
-    public boolean hasHurtOverlay() {
+    public void render(MatrixStack stack, VertexConsumerProvider renderContext, int lightUv, T entity, float limbDistance, float limbAngle, float tickDelta, float age, float headYaw, float headPitch) {
-        return false;
-    }
-
-    @Override
-    public void render(T entity, float move, float swing, float partialTicks, float ticks, float headYaw, float headPitch, float scale) {
         M overlayModel = getOverlayModel();
 
         renderer.getModel().setAttributes(overlayModel);
-        overlayModel.animateModel(entity, move, swing, partialTicks);
+        overlayModel.animateModel(entity, limbDistance, limbAngle, tickDelta);
-        overlayModel.setAngles(entity, move, swing, ticks, headYaw, headPitch, scale);
+        overlayModel.setAngles(entity, limbDistance, limbAngle, age, headYaw, headPitch);
 
-        renderer.bindTexture(getOverlayTexture());
+        VertexConsumer vertexConsumer = ItemRenderer.getArmorVertexConsumer(renderContext, overlayModel.getLayer(getOverlayTexture()), false, false);
-
+        overlayModel.render(stack, vertexConsumer, lightUv, OverlayTexture.DEFAULT_UV, 1, 1, 1, 1);
-        overlayModel.setAngles(entity, move, swing, ticks, headYaw, headPitch, scale);
     }
 
     protected abstract M getOverlayModel();

src/main/java/com/minelittlepony/client/render/layer/LayerPonyArmor.java

@@ -10,11 +10,15 @@ import com.minelittlepony.model.armour.ArmourLayer;
 import com.minelittlepony.model.armour.IArmour;
 import com.minelittlepony.model.armour.IArmourTextureResolver;
 import com.minelittlepony.model.armour.IEquestrianArmour;
-import com.mojang.blaze3d.platform.GlStateManager;
 
-import net.minecraft.client.render.entity.feature.ArmorFeatureRenderer;
+import net.minecraft.client.render.OverlayTexture;
+import net.minecraft.client.render.RenderLayer;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.render.VertexConsumerProvider;
 import net.minecraft.client.render.entity.model.BipedEntityModel;
 import net.minecraft.client.render.entity.model.EntityModel;
+import net.minecraft.client.render.item.ItemRenderer;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.EquipmentSlot;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.item.ArmorItem;
@@ -34,19 +38,19 @@ public class LayerPonyArmor<T extends LivingEntity, M extends EntityModel<T> & I
     }
 
     @Override
-    public void render(T entity, float move, float swing, float partialTicks, float ticks, float headYaw, float headPitch, float scale) {
+    public void render(MatrixStack stack, VertexConsumerProvider renderContext, int lightUv, T entity, float limbDistance, float limbAngle, float tickDelta, float age, float headYaw, float headPitch) {
         pony = getContext().getModelWrapper();
 
         for (EquipmentSlot i : EquipmentSlot.values()) {
             if (i.getType() == EquipmentSlot.Type.ARMOR) {
-                renderArmor(entity, move, swing, partialTicks, ticks, headYaw, headPitch, scale, i, ArmourLayer.INNER);
+                renderArmor(stack, renderContext, lightUv, entity, limbDistance, limbAngle, tickDelta, age, headYaw, headPitch, i, ArmourLayer.INNER);
-                renderArmor(entity, move, swing, partialTicks, ticks, headYaw, headPitch, scale, i, ArmourLayer.OUTER);
+                renderArmor(stack, renderContext, lightUv, entity, limbDistance, limbAngle, tickDelta, age, headYaw, headPitch, i, ArmourLayer.OUTER);
             }
         }
     }
 
     @SuppressWarnings("unchecked")
-    private <V extends BipedEntityModel<T> & IArmour> void renderArmor(T entity, float move, float swing, float partialTicks, float ticks, float headYaw, float headPitch, float scale, EquipmentSlot armorSlot, ArmourLayer layer) {
+    private <V extends BipedEntityModel<T> & IArmour> void renderArmor(MatrixStack stack, VertexConsumerProvider renderContext, int lightUv, T entity, float limbDistance, float limbAngle, float tickDelta, float age, float headYaw, float headPitch, EquipmentSlot armorSlot, ArmourLayer layer) {
         ItemStack itemstack = entity.getEquippedStack(armorSlot);
 
         if (!itemstack.isEmpty() && itemstack.getItem() instanceof ArmorItem) {
@@ -55,7 +59,7 @@ public class LayerPonyArmor<T extends LivingEntity, M extends EntityModel<T> & I
 
             if (armour.prepareToRender(armorSlot, layer)) {
                 ((BipedEntityModel<T>)pony.getBody()).setAttributes(armour);
-                armour.setAngles(entity, move, swing, ticks, headYaw, headPitch, scale);
+                armour.setAngles(entity, limbAngle, limbDistance, age, headYaw, headPitch);
                 armour.synchroniseLegs(pony.getBody());
 
                 IArmourTextureResolver<T> resolver = armour instanceof IArmourTextureResolver ? (IArmourTextureResolver<T>)armour : (IArmourTextureResolver<T>)textures;
@@ -63,28 +67,32 @@ public class LayerPonyArmor<T extends LivingEntity, M extends EntityModel<T> & I
                 Identifier armourTexture = resolver.getArmourTexture(entity, itemstack, armorSlot, layer, null);
                 armour.setVariant(resolver.getArmourVariant(layer, armourTexture));
 
-                getContext().bindTexture(armourTexture);
+                boolean glint = itemstack.hasEnchantmentGlint();
 
                 ArmorItem itemarmor = (ArmorItem) itemstack.getItem();
 
                 if (itemarmor.getMaterial() == ArmorMaterials.LEATHER) {
+
+                    float red = 1;
+                    float green = 1;
+                    float blue = 1;
+
                     if (itemarmor instanceof DyeableArmorItem) {
-                        Color.glColor(((DyeableArmorItem)itemarmor).getColor(itemstack), 1);
+                        int color = ((DyeableArmorItem)itemarmor).getColor(itemstack);
+                        red = Color.r(color);
+                        green = Color.g(color);
+                        blue = Color.b(color);
                     }
 
-                    armour.render(entity, move, swing, ticks, headYaw, headPitch, scale);
+                    VertexConsumer vertices = ItemRenderer.getArmorVertexConsumer(renderContext, RenderLayer.getEntityCutoutNoCull(armourTexture), false, glint);
+
+                    armour.render(stack, vertices, lightUv, OverlayTexture.DEFAULT_UV, red, green, blue, 1);
                     armourTexture = resolver.getArmourTexture(entity, itemstack, armorSlot, layer, "overlay");
                     armour.setVariant(resolver.getArmourVariant(layer, armourTexture));
-
-                    getContext().bindTexture(armourTexture);
                 }
 
-                GlStateManager.color4f(1, 1, 1, 1);
+                VertexConsumer vertices = ItemRenderer.getArmorVertexConsumer(renderContext, RenderLayer.getEntityCutoutNoCull(armourTexture), false, glint);
-                armour.render(entity, move, swing, ticks, headYaw, headPitch, scale);
+                armour.render(stack, vertices, lightUv, OverlayTexture.DEFAULT_UV, 1, 1, 1, 1);
-
-                if (itemstack.hasEnchantmentGlint()) {
-                    ArmorFeatureRenderer.renderEnchantedGlint(this::bindTexture, entity, armour, move, swing, partialTicks, ticks, headYaw, headPitch, scale);
-                }
             }
         }
     }

src/main/java/com/minelittlepony/client/render/layer/LayerPonyCape.java

@@ -5,13 +5,17 @@ import com.minelittlepony.client.render.IPonyRender;
 import com.minelittlepony.model.BodyPart;
 
 import net.minecraft.client.network.AbstractClientPlayerEntity;
+import net.minecraft.client.render.OverlayTexture;
+import net.minecraft.client.render.RenderLayer;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.render.VertexConsumerProvider;
 import net.minecraft.client.render.entity.PlayerModelPart;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.client.util.math.Vector3f;
 import net.minecraft.item.Items;
 import net.minecraft.entity.EquipmentSlot;
 import net.minecraft.util.math.MathHelper;
 
-import javax.annotation.Nonnull;
-
 import static com.minelittlepony.model.PonyModelConstants.PI;
 import static com.mojang.blaze3d.platform.GlStateManager.*;
 
@@ -22,7 +26,7 @@ public class LayerPonyCape<M extends ClientPonyModel<AbstractClientPlayerEntity>
     }
 
     @Override
-    public void render(@Nonnull AbstractClientPlayerEntity player, float move, float swing, float partialTicks, float ticks, float headYaw, float headPitch, float scale) {
+    public void render(MatrixStack stack, VertexConsumerProvider renderContext, int lightUv, AbstractClientPlayerEntity player, float limbDistance, float limbAngle, float tickDelta, float age, float headYaw, float headPitch) {
         M model = getModel();
 
         if (player.hasSkinTexture() && !player.isInvisible()
@@ -31,15 +35,15 @@ public class LayerPonyCape<M extends ClientPonyModel<AbstractClientPlayerEntity>
 
             pushMatrix();
 
-            model.transform(BodyPart.BODY);
+            model.transform(BodyPart.BODY, stack);
-            translatef(0, 0.24F, 0);
+            stack.translate(0, 0.24F, 0);
-            model.getBodyPart(BodyPart.BODY).applyTransform(scale);
+            model.getBodyPart(BodyPart.BODY).rotate(stack);
 
-            double capeX = MathHelper.lerp(partialTicks, player.field_7524, player.field_7500) - MathHelper.lerp(partialTicks, player.prevX, player.x);
+            double capeX = MathHelper.lerp(tickDelta, player.field_7524, player.field_7500) - MathHelper.lerp(tickDelta, player.prevX, player.getX());
-            double capeY = MathHelper.lerp(partialTicks, player.field_7502, player.field_7521) - MathHelper.lerp(partialTicks, player.prevY, player.y);
+            double capeY = MathHelper.lerp(tickDelta, player.field_7502, player.field_7521) - MathHelper.lerp(tickDelta, player.prevY, player.getY());
-            double capeZ = MathHelper.lerp(partialTicks, player.field_7522, player.field_7499) - MathHelper.lerp(partialTicks, player.prevZ, player.z);
+            double capeZ = MathHelper.lerp(tickDelta, player.field_7522, player.field_7499) - MathHelper.lerp(tickDelta, player.prevZ, player.getZ());
 
-            float motionYaw = player.prevBodyYaw + (player.bodyYaw - player.prevBodyYaw) * scale;
+            float motionYaw = player.prevBodyYaw + (player.bodyYaw - player.prevBodyYaw);
 
             //double capeX = player.prevRenderX + (player.x - player.prevRenderX) * scale - (player.prevX + (player.x - player.prevX) * scale);
             //double capeY = player.prevRenderY + (player.y - player.prevRenderY) * scale - (player.prevY + (player.y - player.prevY) * scale);
@@ -61,18 +65,19 @@ public class LayerPonyCape<M extends ClientPonyModel<AbstractClientPlayerEntity>
 
             if (capeMotionX < 0) capeMotionX = 0;
 
-            float camera = MathHelper.lerp(partialTicks, player.field_7505, player.field_7483);
+            float camera = MathHelper.lerp(tickDelta, player.field_7505, player.field_7483);
             //float camera = player.prevCameraYaw + (player.cameraYaw - player.prevCameraYaw) * scale;
-            capeMotionY += MathHelper.sin(MathHelper.lerp(partialTicks, player.prevHorizontalSpeed, player.horizontalSpeed) * 6) * 32 * camera;
+            capeMotionY += MathHelper.sin(MathHelper.lerp(tickDelta, player.prevHorizontalSpeed, player.horizontalSpeed) * 6) * 32 * camera;
 
-            rotatef(2 + capeMotionX / 12 + capeMotionY, 1, 0, 0);
+            stack.multiply(Vector3f.POSITIVE_X.getDegreesQuaternion(2 + capeMotionX / 12 + capeMotionY));
-            rotatef( diagMotion / 2, 0, 0, 1);
+            stack.multiply(Vector3f.POSITIVE_Z.getDegreesQuaternion( diagMotion / 2));
-            rotatef(-diagMotion / 2, 0, 1, 0);
+            stack.multiply(Vector3f.POSITIVE_Y.getDegreesQuaternion(-diagMotion / 2));
-            rotatef(180, 0, 0, 1);
+            stack.multiply(Vector3f.POSITIVE_Z.getDegreesQuaternion(180));
-            rotatef(90, 1, 0, 0);
+            stack.multiply(Vector3f.POSITIVE_X.getDegreesQuaternion(90));
-            getContext().bindTexture(player.getCapeTexture());
+
-            model.renderCape(0.0625F);
+            VertexConsumer vertices = renderContext.getBuffer(RenderLayer.getEntitySolid(player.getCapeTexture()));
-            popMatrix();
+            model.renderCape(stack, vertices, lightUv, OverlayTexture.DEFAULT_UV);
+            stack.pop();
         }
     }
 }

src/main/java/com/minelittlepony/client/render/layer/LayerPonyCustomHead.java

@@ -10,9 +10,12 @@ import net.minecraft.block.AbstractSkullBlock;
 import net.minecraft.block.SkullBlock.SkullType;
 import net.minecraft.block.entity.SkullBlockEntity;
 import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.render.VertexConsumerProvider;
 import net.minecraft.client.render.block.entity.SkullBlockEntityRenderer;
 import net.minecraft.client.render.entity.model.EntityModel;
 import net.minecraft.client.render.model.json.ModelTransformation;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.client.util.math.Vector3f;
 import net.minecraft.entity.EquipmentSlot;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.item.ArmorItem;
@@ -32,21 +35,21 @@ public class LayerPonyCustomHead<T extends LivingEntity, M extends EntityModel<T
     }
 
     @Override
-    public void render(T entity, float move, float swing, float partialTicks, float ticks, float headYaw, float headPitch, float scale) {
+    public void render(MatrixStack stack, VertexConsumerProvider renderContext, int lightUv, T entity, float limbDistance, float limbAngle, float tickDelta, float age, float headYaw, float headPitch) {
         ItemStack itemstack = entity.getEquippedStack(EquipmentSlot.HEAD);
         if (!itemstack.isEmpty()) {
             M model = getContext().getModelWrapper().getBody();
             Item item = itemstack.getItem();
 
-            pushMatrix();
+            stack.push();
 
-            model.transform(BodyPart.HEAD);
+            model.transform(BodyPart.HEAD, stack);
-            model.getHead().applyTransform(0.0625f);
+            model.getHead().rotate(stack);
 
             if (model instanceof AbstractPonyModel) {
-                translatef(0, 0.225F, 0);
+                stack.translate(0, 0.225F, 0);
             } else {
-                translatef(0, 0, 0.15F);
+                stack.translate(0, 0, 0.15F);
             }
 
             color4f(1, 1, 1, 1);
@@ -54,25 +57,25 @@ public class LayerPonyCustomHead<T extends LivingEntity, M extends EntityModel<T
             if (item instanceof BlockItem && ((BlockItem) item).getBlock() instanceof AbstractSkullBlock) {
                 boolean isVillager = entity instanceof VillagerDataContainer;
 
-                renderSkull(itemstack, isVillager, move);
+                renderSkull(stack, renderContext, itemstack, isVillager, limbDistance, lightUv);
             } else if (!(item instanceof ArmorItem) || ((ArmorItem)item).getSlotType() != EquipmentSlot.HEAD) {
-                renderBlock(entity, itemstack);
+                renderBlock(stack, renderContext, entity, itemstack, lightUv);
             }
 
-            popMatrix();
+            stack.pop();
         }
 
     }
 
-    private void renderBlock(T entity, ItemStack itemstack) {
+    private void renderBlock(MatrixStack stack, VertexConsumerProvider renderContext, T entity, ItemStack itemstack, int lightUv) {
-        rotatef(180, 0, 1, 0);
+        stack.multiply(Vector3f.POSITIVE_Y.getDegreesQuaternion(180));
-        scalef(0.625F, -0.625F, -0.625F);
+        stack.scale(0.625F, -0.625F, -0.625F);
-        translatef(0, 0.4F, -0.21F);
+        stack.translate(0, 0.4F, -0.21F);
 
-        MinecraftClient.getInstance().getFirstPersonRenderer().renderItem(entity, itemstack, ModelTransformation.Type.HEAD);
+        MinecraftClient.getInstance().getFirstPersonRenderer().renderItem(entity, itemstack, ModelTransformation.Type.HEAD, false, stack, renderContext, lightUv);
     }
 
-    private void renderSkull(ItemStack itemstack, boolean isVillager, float limbSwing) {
+    private void renderSkull(MatrixStack stack, VertexConsumerProvider renderContext, ItemStack itemstack, boolean isVillager, float limbDistance, int lightUv) {
         translatef(0, 0, -0.14F);
         float f = 1.1875f;
         scalef(f, -f, -f);
@@ -97,12 +100,6 @@ public class LayerPonyCustomHead<T extends LivingEntity, M extends EntityModel<T
 
         SkullType type = ((AbstractSkullBlock) ((BlockItem) itemstack.getItem()).getBlock()).getSkullType();
 
-        SkullBlockEntityRenderer.INSTANCE.render(-0.5F, 0, -0.5F, null, 180, type, profile, -1, limbSwing);
+        SkullBlockEntityRenderer.render(null, 180, type, profile, limbDistance, stack, renderContext, lightUv);
     }
-
-    @Override
-    public boolean hasHurtOverlay() {
-        return false;
-    }
-
 }

src/main/java/com/minelittlepony/client/render/layer/LayerPonyElytra.java

@@ -7,17 +7,19 @@ import com.minelittlepony.model.BodyPart;
 import com.mojang.blaze3d.platform.GlStateManager;
 
 import net.minecraft.client.network.AbstractClientPlayerEntity;
+import net.minecraft.client.render.OverlayTexture;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.render.VertexConsumerProvider;
 import net.minecraft.client.render.entity.PlayerModelPart;
-import net.minecraft.client.render.entity.feature.ArmorFeatureRenderer;
 import net.minecraft.client.render.entity.model.EntityModel;
+import net.minecraft.client.render.item.ItemRenderer;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.item.Items;
 import net.minecraft.entity.EquipmentSlot;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.Identifier;
 
-import javax.annotation.Nonnull;
-
 public class LayerPonyElytra<T extends LivingEntity, M extends EntityModel<T> & IPonyModel<T>> extends AbstractPonyLayer<T, M> {
 
     private static final Identifier TEXTURE_ELYTRA = new Identifier("textures/entity/elytra.png");
@@ -29,16 +31,14 @@ public class LayerPonyElytra<T extends LivingEntity, M extends EntityModel<T> &
     }
 
     @Override
-    public void render(@Nonnull T entity, float move, float swing, float partialTicks, float ticks, float yaw, float head, float scale) {
+    public void render(MatrixStack stack, VertexConsumerProvider renderContext, int lightUv, T entity, float limbDistance, float limbAngle, float tickDelta, float age, float headYaw, float headPitch) {
         ItemStack itemstack = entity.getEquippedStack(EquipmentSlot.CHEST);
 
         if (itemstack.getItem() == Items.ELYTRA) {
             GlStateManager.color4f(1, 1, 1, 1);
 
-            getContext().bindTexture(getElytraTexture(entity));
+            stack.push();
-
+            preRenderCallback(stack);
-            GlStateManager.pushMatrix();
-            preRenderCallback();
 
             EntityModel<T> elytra = getElytraModel();
 
@@ -46,20 +46,17 @@ public class LayerPonyElytra<T extends LivingEntity, M extends EntityModel<T> &
                 ((PonyElytra<T>)elytra).isSneaking = getContext().getEntityPony(entity).isCrouching(entity);
             }
 
-            elytra.setAngles(entity, move, swing, ticks, yaw, head, scale);
+            elytra.setAngles(entity, limbDistance, limbAngle, age, headYaw, headPitch);
-            elytra.render(entity, move, swing, ticks, yaw, head, scale);
+            VertexConsumer vertexConsumer = ItemRenderer.getArmorVertexConsumer(renderContext, modelElytra.getLayer(getElytraTexture(entity)), false, itemstack.hasEnchantmentGlint());
+            modelElytra.render(stack, vertexConsumer, lightUv, OverlayTexture.DEFAULT_UV, 1, 1, 1, 1);
 
-            if (itemstack.hasEnchantmentGlint()) {
+            stack.pop();
-                ArmorFeatureRenderer.renderEnchantedGlint(this::bindTexture, entity, elytra, move, swing, partialTicks, ticks, yaw, head, scale);
-            }
-
-            GlStateManager.popMatrix();
         }
     }
 
-    protected void preRenderCallback() {
+    protected void preRenderCallback(MatrixStack stack) {
-        GlStateManager.translatef(0, getPlayerModel().getRiderYOffset(), 0.125F);
+        stack.translate(0, getPlayerModel().getRiderYOffset(), 0.125F);
-        getPlayerModel().transform(BodyPart.BODY);
+        getPlayerModel().transform(BodyPart.BODY, stack);
     }
 
     protected EntityModel<T> getElytraModel() {

src/main/java/com/minelittlepony/client/render/layer/LayerPonyStrayOverlay.java

@@ -14,7 +14,6 @@ public class LayerPonyStrayOverlay<Skeleton extends AbstractSkeletonEntity> exte
 
     public LayerPonyStrayOverlay(LivingEntityRenderer<Skeleton, ModelSkeletonPony<Skeleton>> render) {
         super(render);
-        overlayModel.init(0, 0.25F);
     }
 
     @Override

src/main/java/com/minelittlepony/client/render/tileentities/skull/PonySkullRenderer.java

@@ -7,8 +7,9 @@ import com.minelittlepony.pony.IPony;
 import com.minelittlepony.settings.PonyConfig;
 import com.mojang.authlib.GameProfile;
 
-import net.fabricmc.fabric.api.client.render.BlockEntityRendererRegistry;
+import net.fabricmc.fabric.api.client.rendereregistry.v1.BlockEntityRendererRegistry;
 import net.minecraft.block.SkullBlock;
+import net.minecraft.block.entity.BlockEntityType;
 import net.minecraft.block.entity.SkullBlockEntity;
 import net.minecraft.client.render.block.entity.SkullBlockEntityRenderer;
 import net.minecraft.util.Identifier;
@@ -47,14 +48,14 @@ public class PonySkullRenderer extends SkullBlockEntityRenderer {
         if (ponySkulls) {
             if (!(INSTANCE instanceof PonySkullRenderer)) {
                 backup = INSTANCE;
-                BlockEntityRendererRegistry.INSTANCE.register(SkullBlockEntity.class, ponyInstance);
+                BlockEntityRendererRegistry.INSTANCE.register(BlockEntityType.SKULL, ponyInstance);
             }
         } else {
             if ((INSTANCE instanceof PonySkullRenderer)) {
                 if (backup == null) {
                     backup = new SkullBlockEntityRenderer();
                 }
-                BlockEntityRendererRegistry.INSTANCE.register(SkullBlockEntity.class, backup);
+                BlockEntityRendererRegistry.INSTANCE.register(BlockEntityType.SKULL, backup);
             }
         }
     }

src/main/java/com/minelittlepony/client/transform/PonyPosture.java

@@ -1,5 +1,6 @@
 package com.minelittlepony.client.transform;
 
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.entity.player.PlayerEntity;
 
@@ -17,15 +18,15 @@ public interface PonyPosture<T extends LivingEntity> {
         return true;
     }
 
-    default void apply(T player, IModel model, float yaw, float ticks, int invert) {
+    default void apply(T player, IModel model, MatrixStack stack, float yaw, float ticks, int invert) {
         if (applies(player)) {
-            double motionX = player.x - player.prevX;
+            double motionX = player.getX() - player.prevX;
-            double motionY = player.onGround ? 0 : player.y - player.prevY;
+            double motionY = player.onGround ? 0 : player.getY() - player.prevY;
-            double motionZ = player.z - player.prevZ;
+            double motionZ = player.getZ() - player.prevZ;
 
-            transform(model, player, motionX, invert * motionY, motionZ, yaw, ticks);
+            transform(model, player, stack, motionX, invert * motionY, motionZ, yaw, ticks);
         }
     }
 
-    void transform(IModel model, T entity, double motionX, double motionY, double motionZ, float yaw, float ticks);
+    void transform(IModel model, T entity, MatrixStack stack, double motionX, double motionY, double motionZ, float yaw, float ticks);
 }

src/main/java/com/minelittlepony/client/transform/PonyTransformation.java

@@ -6,7 +6,7 @@ import com.google.common.collect.Maps;
 import com.minelittlepony.model.BodyPart;
 import com.minelittlepony.model.IModel;
 import com.minelittlepony.pony.meta.Size;
-import com.mojang.blaze3d.platform.GlStateManager;
+import com.mojang.blaze3d.systems.RenderSystem;
 
 import java.util.Map;
 
@@ -227,15 +227,15 @@ public enum PonyTransformation {
     }
 
     public static void translateVec(Vec3d offset) {
-        GlStateManager.translated(offset.x, offset.y, offset.z);
+        RenderSystem.translated(offset.x, offset.y, offset.z);
     }
 
     protected void scale(float x, float y, float z) {
-        GlStateManager.scalef(x, y, z);
+        RenderSystem.scalef(x, y, z);
     }
 
     protected void translate(float x, float y, float z) {
-        GlStateManager.translatef(x, y, z);
+        RenderSystem.translatef(x, y, z);
     }
 
     public Vec3d getRiderOffset() {

src/main/java/com/minelittlepony/client/transform/PostureElytra.java

@@ -1,14 +1,15 @@
 package com.minelittlepony.client.transform;
 
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.client.util.math.Vector3f;
 import net.minecraft.entity.LivingEntity;
 
 import com.minelittlepony.model.IModel;
-import com.mojang.blaze3d.platform.GlStateManager;
 
 public class PostureElytra implements PonyPosture<LivingEntity> {
     @Override
-    public void transform(IModel model, LivingEntity entity, double motionX, double motionY, double motionZ, float yaw, float ticks) {
+    public void transform(IModel model, LivingEntity entity, MatrixStack stack, double motionX, double motionY, double motionZ, float yaw, float ticks) {
-        GlStateManager.rotatef(90, 1, 0, 0);
+        stack.multiply(Vector3f.POSITIVE_X.getDegreesQuaternion(90));
-        GlStateManager.translatef(0, model.getAttributes().isCrouching ? 0.2F : -1, 0);
+        stack.translate(0, model.getAttributes().isCrouching ? 0.2F : -1, 0);
     }
 }

src/main/java/com/minelittlepony/client/transform/PostureFalling.java

@@ -1,12 +1,13 @@
 package com.minelittlepony.client.transform;
 
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.LivingEntity;
 
 import com.minelittlepony.model.IModel;
 
 public class PostureFalling implements PonyPosture<LivingEntity> {
     @Override
-    public void transform(IModel model, LivingEntity entity, double motionX, double motionY, double motionZ, float yaw, float ticks) {
+    public void transform(IModel model, LivingEntity entity, MatrixStack stack, double motionX, double motionY, double motionZ, float yaw, float ticks) {
         model.getAttributes().motionPitch = 0;
     }
 }

src/main/java/com/minelittlepony/client/transform/PostureFlight.java

@@ -2,9 +2,10 @@ package com.minelittlepony.client.transform;
 
 import com.minelittlepony.model.IModel;
 import com.minelittlepony.util.transform.MotionCompositor;
-import com.mojang.blaze3d.platform.GlStateManager;
 
 import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.client.util.math.Vector3f;
 import net.minecraft.entity.LivingEntity;
 
 public class PostureFlight extends MotionCompositor implements PonyPosture<PlayerEntity> {
@@ -14,15 +15,14 @@ public class PostureFlight extends MotionCompositor implements PonyPosture<Playe
     }
 
     @Override
-    public void transform(IModel model, PlayerEntity player, double motionX, double motionY, double motionZ, float yaw, float ticks) {
+    public void transform(IModel model, PlayerEntity player, MatrixStack stack, double motionX, double motionY, double motionZ, float yaw, float ticks) {
         model.getAttributes().motionPitch = (float) calculateIncline(player, motionX, motionY, motionZ);
 
-        GlStateManager.rotatef(model.getAttributes().motionPitch, 1, 0, 0);
-
         float roll = (float)calculateRoll(player, motionX,  motionY, motionZ);
 
         roll = model.getMetadata().getInterpolator(player.getUuid()).interpolate("pegasusRoll", roll, 10);
 
-        GlStateManager.rotatef(roll, 0, 0, 1);
+        stack.multiply(Vector3f.POSITIVE_X.getDegreesQuaternion(model.getAttributes().motionPitch));
+        stack.multiply(Vector3f.POSITIVE_Z.getDegreesQuaternion(roll));
     }
 }

src/main/java/com/minelittlepony/client/transform/PostureStanding.java

@@ -1,5 +1,6 @@
 package com.minelittlepony.client.transform;
 
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.LivingEntity;
 
 import com.minelittlepony.model.IModel;
@@ -11,6 +12,6 @@ public class PostureStanding implements PonyPosture<LivingEntity> {
     }
 
     @Override
-    public void transform(IModel model, LivingEntity entity, double motionX, double motionY, double motionZ, float yaw, float ticks) {
+    public void transform(IModel model, LivingEntity entity, MatrixStack stack, double motionX, double motionY, double motionZ, float yaw, float ticks) {
     }
 }

src/main/java/com/minelittlepony/client/transform/PostureSwimming.java

@@ -1,9 +1,9 @@
 package com.minelittlepony.client.transform;
 
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.player.PlayerEntity;
 
 import com.minelittlepony.model.IModel;
-import com.mojang.blaze3d.platform.GlStateManager;
 
 public class PostureSwimming extends PostureFlight {
 
@@ -21,8 +21,8 @@ public class PostureSwimming extends PostureFlight {
     }
 
     @Override
-    public void transform(IModel model, PlayerEntity player, double motionX, double motionY, double motionZ, float yaw, float ticks) {
+    public void transform(IModel model, PlayerEntity player, MatrixStack stack, double motionX, double motionY, double motionZ, float yaw, float ticks) {
-        GlStateManager.translated(0, 0.9, -1);
+        stack.translate(0, 0.9, -1);
-        super.transform(model, player, motionX, motionY, motionZ, yaw, ticks);
+        super.transform(model, player, stack, motionX, motionY, motionZ, yaw, ticks);
     }
 }

src/main/java/com/minelittlepony/client/util/render/Cone.java

@@ -1,68 +0,0 @@
-package com.minelittlepony.client.util.render;
-
-import net.minecraft.client.model.Box;
-import net.minecraft.client.model.Quad;
-import net.minecraft.client.model.Vertex;
-import net.minecraft.client.render.BufferBuilder;
-
-class Cone extends Box {
-
-    private Quad[] polygons;
-
-    public Cone(Part renderer, int texX, int texY, float xMin, float yMin, float zMin, int w, int h, int d, float scale) {
-        super(renderer, texX, texY, xMin, yMin, zMin, w, h, d, scale);
-
-        float xMax = xMin + w + scale;
-        float yMax = yMin + h + scale;
-        float zMax = zMin + d + scale;
-
-        xMin -= scale;
-        yMin -= scale;
-        zMin -= scale;
-
-        if (renderer.mirror) {
-            float v = xMax;
-            xMax = xMin;
-            xMin = v;
-        }
-
-        float tipInset = 0.4f;
-
-        float tipXmin = xMin + w * tipInset;
-        float tipZmin = zMin + d * tipInset;
-        float tipXMax = xMax - w * tipInset;
-        float tipZMax = zMax - d * tipInset;
-
-        // w:west e:east d:down u:up s:south n:north
-        Vertex wds = renderer.vert(tipXmin, yMin, tipZmin, 0, 0);
-        Vertex eds = renderer.vert(tipXMax, yMin, tipZmin, 0, 8);
-        Vertex eus = renderer.vert(xMax,    yMax, zMin,    8, 8);
-        Vertex wus = renderer.vert(xMin,    yMax, zMin,    8, 0);
-        Vertex wdn = renderer.vert(tipXmin, yMin, tipZMax, 0, 0);
-        Vertex edn = renderer.vert(tipXMax, yMin, tipZMax, 0, 8);
-        Vertex eun = renderer.vert(xMax,    yMax, zMax,    8, 8);
-        Vertex wun = renderer.vert(xMin,    yMax, zMax,    8, 0);
-
-        polygons = new Quad[] {
-            renderer.quad(texX + d + w,     d, texY + d,  h, edn, eds, eus, eun),
-            renderer.quad(texX,             d, texY + d,  h, wds, wdn, wun, wus),
-            renderer.quad(texX + d,         w, texY,      d, edn, wdn, wds, eds),
-            renderer.quad(texX + d + w,     w, texY + d, -d, eus, wus, wun, eun),
-            renderer.quad(texX + d,         w, texY + d,  h, eds, wds, wus, eus),
-            renderer.quad(texX + d + w + d, w, texY + d,  h, wdn, edn, eun, wun)
-        };
-
-        if (renderer.mirror) {
-            for (Quad i : polygons) {
-                i.flip();
-            }
-        }
-    }
-
-    @Override
-    public void render(BufferBuilder buffer, float scale) {
-        for (Quad i : polygons) {
-            i.render(buffer, scale);
-        }
-    }
-}

src/main/java/com/minelittlepony/client/util/render/Part.java

@@ -1,288 +1,19 @@
 package com.minelittlepony.client.util.render;
 
-import net.minecraft.client.model.Box;
 import net.minecraft.client.model.Model;
 import net.minecraft.client.model.ModelPart;
-import net.minecraft.client.model.Quad;
-import net.minecraft.client.model.Vertex;
-import net.minecraft.util.math.Direction;
 
-public class Part extends ModelPart {
+import com.minelittlepony.mson.api.model.MsonPart;
 
-    protected final Model baseModel;
+@Deprecated
-
+public class Part extends ModelPart implements MsonPart {
-    protected int textureOffsetX;
-    protected int textureOffsetY;
-
-    protected float modelOffsetX;
-    protected float modelOffsetY;
-    protected float modelOffsetZ;
-
-    public boolean mirrory;
-    public boolean mirrorz;
 
     public Part(Model model) {
         super(model);
-        baseModel = model;
     }
 
     public Part(Model model, int texX, int texY) {
         super(model, texX, texY);
-        baseModel = model;
     }
 
-    /**
-     * Called to create a new instance of this renderer (used for child renderers)
-     */
-    protected Part copySelf() {
-        return new Part(baseModel, textureOffsetX, textureOffsetY);
-    }
-
-    @Override
-    public Part setTextureOffset(int x, int y) {
-        this.textureOffsetX = x;
-        this.textureOffsetY = y;
-        super.setTextureOffset(x, y);
-        return  this;
-    }
-
-    /**
-     * Flips the mirror flag. All faces are mirrored until this is called again.
-     */
-    public Part flip() {
-        return mirror(!mirror);
-    }
-
-    public Part mirror(boolean m) {
-        mirror = m;
-        return  this;
-    }
-
-    /**
-     * Sets the texture offset
-     */
-    public Part tex(int x, int y) {
-        return setTextureOffset(x, y);
-    }
-
-    /**
-     * Sets the texture size for this renderer.
-     */
-    public Part size(int w, int h) {
-        return (Part)setTextureSize(w, h);
-    }
-
-    /**
-     * Positions this model in space.
-     */
-    public Part at(float x, float y, float z) {
-        return at(this, x, y, z);
-    }
-
-    /**
-     * Sets an offset to be used on all shapes and children created through this renderer.
-     */
-    public Part offset(float x, float y, float z) {
-        modelOffsetX = x;
-        modelOffsetY = y;
-        modelOffsetZ = z;
-        return  this;
-    }
-
-    /**
-     * Adjusts the rotation center of the given renderer by the given amounts in each direction.
-     */
-    public static void shiftRotationPoint(ModelPart renderer, float x, float y, float z) {
-        renderer.pivotX += x;
-        renderer.pivotY += y;
-        renderer.pivotZ += z;
-    }
-
-    /**
-     * Sets this renderer's rotation angles.
-     */
-    public Part rotate(float x, float y, float z) {
-        pitch = x;
-        yaw = y;
-        roll = z;
-        return  this;
-    }
-
-    /**
-     * Positions a given model in space by setting its offset values divided
-     * by 16 to account for scaling applied inside the model.
-     */
-    public static <T extends ModelPart> T at(T renderer, float x, float y, float z) {
-        renderer.x = x / 16;
-        renderer.y = y / 16;
-        renderer.z = z / 16;
-        return renderer;
-    }
-
-    /**
-     * Rotates this model to align itself with the angles of another.
-     */
-    public void rotateTo(ModelPart other) {
-        rotate(other.pitch, other.yaw, other.roll);
-    }
-
-    /**
-     * Shifts this model to align its center with the center of another.
-     */
-    public Part rotateAt(ModelPart other) {
-        return around(other.pivotX, other.pivotY, other.pivotZ);
-    }
-
-    /**
-     * Sets the rotation point.
-     */
-    public Part around(float x, float y, float z) {
-        setPivot(x, y, z);
-        return  this;
-    }
-
-    /**
-     * Gets or creates a new child model based on its unique index.
-     * New children will be of the same type and inherit the same textures and offsets of the original.
-     */
-    public Part child(int index) {
-        if (children == null || index >= children.size()) {
-            return child();
-        }
-        return (Part)children.get(index);
-    }
-
-    /**
-     * Returns a brand new child under this renderer.
-     */
-    public Part child() {
-        Part copy = copySelf();
-        child(copy.offset(modelOffsetX, modelOffsetY, modelOffsetZ));
-        copy.textureHeight = textureHeight;
-        copy.textureWidth = textureWidth;
-        return copy;
-    }
-
-    /**
-     * Adds a new child renderer and returns itself for chaining.
-     */
-    public <K extends ModelPart> Part child(K child) {
-        addChild(child);
-        return  this;
-    }
-
-
-    /**
-     * Flips the Z bit. Any calls to add a plane will be mirrored until this is called again.
-     */
-    public Part flipZ() {
-        mirrorz = !mirrorz;
-        return  this;
-    }
-
-    /**
-     * Flips the Y bit. Any calls to add a plane will be mirrored until this is called again.
-     */
-    public Part flipY() {
-        mirrory = !mirrory;
-        return  this;
-    }
-
-    private Part addPlane(float offX, float offY, float offZ, int width, int height, int depth, float scale, Direction face) {
-        cuboids.add(new Plane(this, textureOffsetX, textureOffsetY, modelOffsetX + offX, modelOffsetY + offY, modelOffsetZ + offZ, width, height, depth, scale, face));
-        return  this;
-    }
-
-    public Part top(float offX, float offY, float offZ, int width, int depth, float scale) {
-        return addPlane(offX, offY, offZ, width, 0, depth, scale, Direction.UP);
-    }
-
-    public Part bottom(float offX, float offY, float offZ, int width, int depth, float scale) {
-        return addPlane(offX, offY, offZ, width, 0, depth, scale, Direction.DOWN);
-    }
-
-    public Part west(float offX, float offY, float offZ, int height, int depth, float scale) {
-        return addPlane(offX, offY, offZ, 0, height, depth, scale, Direction.WEST);
-    }
-
-    public Part east(float offX, float offY, float offZ, int height, int depth, float scale) {
-        return addPlane(offX, offY, offZ, 0, height, depth, scale, Direction.EAST);
-    }
-
-    public Part north(float offX, float offY, float offZ, int width, int height, float scale) {
-        return addPlane(offX, offY, offZ - scale * 2, width, height, 0, scale, Direction.NORTH);
-    }
-
-    public Part south(float offX, float offY, float offZ, int width, int height, float scale) {
-        return addPlane(offX, offY, offZ + scale * 2, width, height, 0, scale, Direction.SOUTH);
-    }
-
-    @Override
-    public Part addBox(String partName, float offX, float offY, float offZ, int width, int height, int depth, float unknown, int texX, int texY) {
-        partName = name + "." + partName;
-
-        setTextureOffset(texX, texY);
-        addBox(offX, offY, offZ, width, height, depth);
-        cuboids.get(cuboids.size() - 1).setName(partName);
-
-        return  this;
-    }
-
-    @Override
-    public Part addBox(float offX, float offY, float offZ, int width, int height, int depth) {
-        addCuboid(offX, offY, offZ, width, height, depth, 0);
-        return  this;
-    }
-
-    @Override
-    public Part addBox(float offX, float offY, float offZ, int width, int height, int depth, boolean mirrored) {
-        addCuboid(offX, offY, offZ, width, height, depth, 0, mirrored);
-        return this;
-    }
-
-    @Override
-    public void addCuboid(float offX, float offY, float offZ, int width, int height, int depth, float scaleFactor) {
-        addCuboid(offX, offY, offZ, width, height, depth, scaleFactor, mirror);
-    }
-
-    @Override
-    public void addCuboid(float offX, float offY, float offZ, int width, int height, int depth, float scaleFactor, boolean mirrored) {
-        createBox(offX, offY, offZ, width, height, depth, scaleFactor, mirrored);
-    }
-
-    /**
-     * Creates a textured box.
-     */
-    public Part box(float offX, float offY, float offZ, int width, int height, int depth, float scaleFactor) {
-        addCuboid(offX, offY, offZ, width, height, depth, scaleFactor, mirror);
-
-        return this;
-    }
-
-    public Part cone(float offX, float offY, float offZ, int width, int height, int depth, float scaleFactor) {
-        cuboids.add(new Cone(this, textureOffsetX, textureOffsetY, modelOffsetX + offX, modelOffsetY + offY, modelOffsetZ + offZ, width, height, depth, scaleFactor));
-
-        return this;
-    }
-
-    protected void createBox(float offX, float offY, float offZ, int width, int height, int depth, float scaleFactor, boolean mirrored) {
-        cuboids.add(new Box(this, textureOffsetX, textureOffsetY, modelOffsetX + offX, modelOffsetY + offY, modelOffsetZ + offZ, width, height, depth, scaleFactor, mirrored));
-    }
-
-    /**
-     * Creates a new vertex mapping the given (x, y, z) coordinates to a texture offset.
-     */
-    Vertex vert(float x, float y, float z, int texX, int texY) {
-        return new Vertex(x, y, z, texX, texY);
-    }
-
-    /**
-     * Creates a new quad with the given spacial vertices.
-     */
-    Quad quad(int startX, int width, int startY, int height, Vertex ...verts) {
-        return new Quad(verts,
-                startX,         startY,
-                startX + width, startY + height,
-                textureWidth, textureHeight);
-    }
 }

src/main/java/com/minelittlepony/client/util/render/Plane.java

@@ -1,82 +0,0 @@
-package com.minelittlepony.client.util.render;
-
-import net.minecraft.client.model.Box;
-import net.minecraft.client.model.Quad;
-import net.minecraft.client.model.Vertex;
-import net.minecraft.client.render.BufferBuilder;
-import net.minecraft.util.math.Direction;
-
-import javax.annotation.Nonnull;
-
-class Plane extends Box {
-
-    private Quad quad;
-
-    public Plane(Part renderer, int textureX, int textureY, float xMin, float yMin, float zMin, int w, int h, int d, float scale, Direction face) {
-        super(renderer, textureX, textureY, xMin, yMin, zMin, w, h, d, scale, false);
-
-        float xMax = xMin + w + scale;
-        float yMax = yMin + h + scale;
-        float zMax = zMin + d + scale;
-
-        xMin -= scale;
-        yMin -= scale;
-        zMin -= scale;
-
-        if (renderer.mirror) {
-            float v = xMax;
-            xMax = xMin;
-            xMin = v;
-        }
-
-        if (renderer.mirrory) {
-            float v = yMax;
-            yMax = yMin;
-            yMin = v;
-        }
-
-        if (renderer.mirrorz) {
-            float v = zMax;
-            zMax = zMin;
-            zMin = v;
-        }
-
-        // w:west e:east d:down u:up s:south n:north
-        Vertex wds = renderer.vert(xMin, yMin, zMin, 0, 0);
-        Vertex eds = renderer.vert(xMax, yMin, zMin, 0, 8);
-        Vertex eus = renderer.vert(xMax, yMax, zMin, 8, 8);
-        Vertex wus = renderer.vert(xMin, yMax, zMin, 8, 0);
-        Vertex wdn = renderer.vert(xMin, yMin, zMax, 0, 0);
-        Vertex edn = renderer.vert(xMax, yMin, zMax, 0, 8);
-        Vertex eun = renderer.vert(xMax, yMax, zMax, 8, 8);
-        Vertex wun = renderer.vert(xMin, yMax, zMax, 8, 0);
-
-        if (face == Direction.EAST) {
-            quad = renderer.quad(textureX, d, textureY, h, edn, eds, eus, eun);
-        }
-        if (face == Direction.WEST) {
-            quad = renderer.quad(textureX, d, textureY, h, wds, wdn, wun, wus);
-        }
-        if (face == Direction.UP) {
-            quad = renderer.quad(textureX, w, textureY, d, edn, wdn, wds, eds);
-        }
-        if (face == Direction.DOWN) {
-            quad = renderer.quad(textureX, w, textureY, d, eus, wus, wun, eun);
-        }
-        if (face == Direction.SOUTH) {
-            quad = renderer.quad(textureX, w, textureY, h, eds, wds, wus, eus);
-        }
-        if (face == Direction.NORTH) {
-            quad = renderer.quad(textureX, w, textureY, h, wdn, edn, eun, wun);
-        }
-
-        if (renderer.mirror || renderer.mirrory || renderer.mirrorz) {
-            quad.flip();
-        }
-    }
-
-    @Override
-    public void render(@Nonnull BufferBuilder buffer, float scale) {
-        quad.render(buffer, scale);
-    }
-}

src/main/java/com/minelittlepony/model/IModel.java

@@ -1,6 +1,7 @@
 package com.minelittlepony.model;
 
 import net.minecraft.client.render.entity.model.ModelWithArms;
+import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.util.math.MathHelper;
 
 import com.minelittlepony.model.armour.IEquestrianArmour;
@@ -10,17 +11,10 @@ import com.minelittlepony.pony.meta.Wearable;
 
 public interface IModel extends ModelWithArms {
 
-    /**
-     * Sets up this model's initial values, like a constructor...
-     * @param yOffset   YPosition for this model. Always 0.
-     * @param stretch   Scaling factor for this model. Ranges above or below 0 (no change).
-     */
-    void init(float yOffset, float stretch);
-
     /**
      * Applies a transform particular to a certain body part.
      */
-    void transform(BodyPart part);
+    void transform(BodyPart part, MatrixStack stack);
 
     /**
      * Gets the active scaling profile used to lay out this model's parts.

src/main/java/com/minelittlepony/model/IPart.java

@@ -1,17 +1,11 @@
 package com.minelittlepony.model;
 
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.util.math.MatrixStack;
+
 import java.util.UUID;
 
 public interface IPart extends PonyModelConstants {
-    /**
-     * Initialises all of the boxes in this modelpart.
-     * @param yOffset
-     * @param stretch
-     */
-    default void init(float yOffset, float stretch) {
-
-    }
-
     /**
      * Sets the model's various rotation angles.
      *
@@ -24,7 +18,7 @@ public interface IPart extends PonyModelConstants {
     /**
      * Renders this model component.
      */
-    void renderPart(float scale, UUID interpolatorId);
+    void renderPart(MatrixStack stack, VertexConsumer vertices, int overlayUv, int lightUv, float red, float green, float blue, float alpha, UUID interpolatorId);
 
     /**
      * Sets whether this part should be rendered.

src/main/java/com/minelittlepony/model/ModelAttributes.java

@@ -69,13 +69,13 @@ public class ModelAttributes<T extends LivingEntity> {
      */
     public UUID interpolatorId;
 
-    public int armWidth = 4;
+    @Deprecated public int armWidth = 4;
-    public int armDepth = 4;
+    @Deprecated public int armDepth = 4;
 
-    public int armLength = 12;
+    @Deprecated public int armLength = 12;
 
-    public float armRotationX = 3F;
+    @Deprecated public float armRotationX = 3F;
-    public float armRotationY = 8F;
+    @Deprecated public float armRotationY = 8F;
 
     /**
      * The actual, visible height of this model when rendered.

src/main/java/com/minelittlepony/model/capabilities/IModelWrapper.java

@@ -3,11 +3,6 @@ package com.minelittlepony.model.capabilities;
 import com.minelittlepony.pony.IPonyData;
 
 public interface IModelWrapper {
-    /**
-     * Initialises this wrapper's contained models.
-     */
-    void init();
-
     /**
      * Updates metadata values to this wrapper's contained models.
      */

src/main/resources/assets/minelittlepony/models/alex_pony.json

@@ -0,0 +1,8 @@
+{
+	"parent": "minelittlepony:steve_pony",
+	"locals": {
+		"arm_width": 3,
+		"arm_rotation_x": 2,
+		"arm_rotation_y": 8.5
+	}
+}

src/main/resources/assets/minelittlepony/models/components/pegasus_wings.json

@@ -0,0 +1,92 @@
+{
+	"left_wing": {
+		"type": "mson:slot",
+		"name": "wings",
+		"implementation": "com.minelittlepony.client.model.components.PegasusWings$Wing",
+		"content": {
+			"folded": {
+				"texture": {"u": 56, "v": 32},
+				"center": [0, 13, -2],
+				"rotate": [90, 0, 0],
+				"cubes": [
+					{"from": [4, 5, 2], "size": [2, 6, 2] },
+					{"from": [4, 5, 4], "size": [2, 8, 2] },
+					{"from": [4, 5, 6], "size": [2, 6, 2] }
+				]
+			},
+			"extended": {
+				"texture": {"u": 57, "v": 35},
+				"center": [4.5, 5.3, 6],
+				"rotate": [30, 0, 0],
+				"children": [
+					{ "cubes": [ {"from": [-0.5, 6,     0], "size": [1, 9, 2], "stretch":  0.1 } ] },
+					{ "cubes": [ {"from": [-0.5,-1,  -0.3], "size": [1, 8, 2], "stretch":  0.1 } ],  "rotate": [-0.85, 0, 0] },
+					{ "cubes": [ {"from": [-0.5, 1.8, 1.3], "size": [1, 8, 2], "stretch": -0.1 } ],  "rotate": [-0.75, 0, 0] },
+					{ "cubes": [ {"from": [-0.5, 5,     2], "size": [1, 8, 2] } ],                   "rotate": [-0.5 , 0, 0] },
+					{ "cubes": [ {"from": [-0.5, 0,  -0.2], "size": [1, 6, 2], "stretch":  0.3 } ] },
+					{ "cubes": [ {"from": [-0.5, 0,     0], "size": [1, 3, 2], "stretch":  0.19 } ], "rotate": [-0.85, 0, 0] }
+				]
+			}
+		}
+	},
+	"right_wing": {
+		"type": "mson:slot",
+		"name": "wings",
+		"implementation": "com.minelittlepony.client.model.components.PegasusWings$Wing",
+		"content": {
+			"folded": {
+				"texture": {"u": 56, "v": 16},
+				"center": [0, 13, -2],
+				"rotate": [90, 0, 0],
+				"cubes": [
+					{"from": [-6, 5, 2], "size": [2, 6, 2] },
+					{"from": [-6, 5, 4], "size": [2, 8, 2] },
+					{"from": [-6, 5, 6], "size": [2, 6, 2] }
+				]
+			},
+			"extended": {
+				"texture": {"u": 56, "v": 19},
+				"center": [-4.5, 5.3, 6],
+				"rotate": [-30, 0, 0],
+				"children": [
+					{ "cubes": [ {"from": [-0.5, 6,     0], "size": [1, 9, 2], "stretch":  0.1 } ] },
+					{ "cubes": [ {"from": [-0.5,-1,  -0.3], "size": [1, 8, 2], "stretch":  0.1 } ],  "rotate": [-0.85, 0, 0] },
+					{ "cubes": [ {"from": [-0.5, 1.8, 1.3], "size": [1, 8, 2], "stretch": -0.1 } ],  "rotate": [-0.75, 0, 0] },
+					{ "cubes": [ {"from": [-0.5, 5,     2], "size": [1, 8, 2] } ],                   "rotate": [-0.5 , 0, 0] },
+					{ "cubes": [ {"from": [-0.5, 0,  -0.2], "size": [1, 6, 2], "stretch":  0.3 } ] },
+					{ "cubes": [ {"from": [-0.5, 0,     0], "size": [1, 3, 2], "stretch":  0.19 } ], "rotate": [-0.85, 0, 0] }
+				]
+			}
+		}
+	},
+	"legacy_right_wing": {
+		"type": "mson:slot",
+		"name": "wings",
+		"implementation": "com.minelittlepony.client.model.components.PegasusWings$Wing",
+		"content": {
+			"folded": {
+				"texture": {"u": 56, "v": 16},
+				"center": [0, 13, -2],
+				"rotate": [90, 0, 0],
+				"cubes": [
+					{"from": [-6, 5, 2], "size": [2, 6, 2] },
+					{"from": [-6, 5, 4], "size": [2, 8, 2] },
+					{"from": [-6, 5, 6], "size": [2, 6, 2] }
+				]
+			},
+			"extended": {
+				"texture": {"u": 57, "v": 19},
+				"center": [-4.5, 5.3, 6],
+				"rotate": [-30, 0, 0],
+				"children": [
+					{ "cubes": [ {"from": [-0.5, 6,     0], "size": [1, 9, 2], "stretch":  0.1 } ],                           "mirror": true },
+					{ "cubes": [ {"from": [-0.5,-1,  -0.3], "size": [1, 8, 2], "stretch":  0.1 } ],  "rotate": [-0.85, 0, 0], "mirror": true },
+					{ "cubes": [ {"from": [-0.5, 1.8, 1.3], "size": [1, 8, 2], "stretch": -0.1 } ],  "rotate": [-0.75, 0, 0], "mirror": true },
+					{ "cubes": [ {"from": [-0.5, 5,     2], "size": [1, 8, 2] } ],                   "rotate": [-0.5 , 0, 0], "mirror": true },
+					{ "cubes": [ {"from": [-0.5, 0,  -0.2], "size": [1, 6, 2], "stretch":  0.3 } ] },
+					{ "cubes": [ {"from": [-0.5, 0,     0], "size": [1, 3, 2], "stretch":  0.19 } ], "rotate": [-0.85, 0, 0], "mirror": true }
+				]
+			}
+		}
+	}
+}

src/main/resources/assets/minelittlepony/models/enderman.json

@@ -0,0 +1,107 @@
+{
+	"parent": "minelittlepony:skeleton",
+	"locals": {
+		"arm_length": 30,
+		"arm_rotation_x": 3,
+		"arm_rotation_y": 14
+	},
+	"head": {
+		"offset": [ 0, -1, -2 ],
+		"center": [ 0, 0, -2 ],
+		"cubes": [
+			{ "from": [-4, -4, -4], "size": [ 8,  8,  8] },
+			{ "from": [-4, -6, 1], "size": [2, 2, 2], "texture": {"u": 12, "v": 16} },
+			{ "from": [ 2, -6, 1], "size": [2, 2, 2], "texture": {"u": 12, "v": 16}, "mirror": true }
+		],
+		"children": [
+			{
+				"type": "mson:slot",
+				"name": "snout",
+				"implementation": "com.minelittlepony.client.model.components.PonySnout",
+				"content: "minelitlepony:components/snout"
+			},
+			{
+				"type": "mson:slot",
+				"name": "ears",
+				"implementation": "com.minelittlepony.client.model.components.PonyEars",
+				"content": "minelittlepony:components/ears"
+			},
+			{
+				"name": "left_horn",
+				"texture": {"u": 0, "v": 52},
+				"rotate": [0.1, 0, -0.8],
+				"offset": [-2, -10, -3],
+				"cubes": [ {"size": [2, 6, 2]} ],
+				"children": [
+					{
+						"rotate": [0, 0, 0.9],
+						"center": [-3.9, -6, 0.001],
+						"cubes": [ {"size": [2, 6, 2]} ]
+					}
+				]
+			},
+			{
+				"name": "right_horn",
+				"texture": {"u": 8, "v": 52},
+				"rotate": [0.1, 0, 0.8],
+				"offset": [0, -10, -3],
+				"cubes": [ {"size": [2, 6, 2]} ],
+				"children": [
+					{
+						"rotate": [0, 0, -0.9],
+						"center": [3.9, -6, 0.001],
+						"cubes": [ {"size": [2, 6, 2]} ]
+					}
+				]
+			}
+		]
+	},
+	"helmet": {
+		"texture": { "u": 32, "v": 0 },
+		"offset": [0, -1, -2],
+		"center": [0, 0, -2],
+		"cubes": [
+			{ "from": [-4, -4, -4], "size": [ 8, 8, 8], "stretch": -0.5 }
+		]
+	},
+	"right_arm": {
+		"center": ["#arm_rotation_x_neg", "#arm_rotation_y", 0],
+		"texture": { "u": 0, "v": 20 },
+		"cubes": [
+			{
+				"from": [ "#arm_x_neg", 4, "#arm_z"],
+				"size": [ "#arm_width",  "#arm_length",  "#arm_depth" ]
+			}
+		]
+	},
+	"left_arm": {
+		"center": ["#arm_rotation_x", "#arm_rotation_y", 0],
+		"texture": { "u": 0, "v": 20 },
+		"cubes": [
+			{
+				"from": [ "#arm_x", 4, "#arm_z"],
+				"size": [ "#arm_width",  "#arm_length",  "#arm_depth" ]
+			}
+		]
+	},
+	"right_leg": {
+		"center": ["#arm_rotation_x_neg", 0, 0],
+		"texture": { "u": 0, "v": 20 },
+		"cubes": [
+			{
+				"from": [ "#arm_x_neg", 4, "#arm_z"],
+				"size": [ "#arm_width",  "#arm_length",  "#arm_depth" ]
+			}
+		]
+	},
+	"left_leg": {
+		"center": ["#arm_rotation_x", 0, 0],
+		"texture": { "u": 0, "v": 20 },
+		"cubes": [
+			{
+				"from": [ "#arm_x", 4, "#arm_z"],
+				"size": [ "#arm_width",  "#arm_length",  "#arm_depth" ]
+			}
+		]
+	},
+}

src/main/resources/assets/minelittlepony/models/races/alicorn.json

@@ -0,0 +1,9 @@
+{
+	"parent": "minelittlepony:races/unicorn",
+	"wings": {
+		"type": "mson:slot",
+		"name": "wings",
+		"implementation": "com.minelittlepony.client.model.components.PegasusWings",
+		"content: "minelitlepony:components/pegasus_wings"
+	}
+}