mirror of
https://github.com/MineLittlePony/MineLittlePony.git
synced 2024-12-02 16:58:00 +01:00
734 lines
30 KiB
Java
734 lines
30 KiB
Java
package com.minelittlepony.model.ponies;
|
|
|
|
import com.minelittlepony.model.AbstractPonyModel;
|
|
import com.minelittlepony.model.BodyPart;
|
|
import com.minelittlepony.model.armour.ModelPonyArmor;
|
|
import com.minelittlepony.model.armour.PonyArmor;
|
|
import com.minelittlepony.model.components.PegasusWings;
|
|
import com.minelittlepony.model.components.PonySnout;
|
|
import com.minelittlepony.model.components.PonyTail;
|
|
import com.minelittlepony.model.components.UnicornHorn;
|
|
import com.minelittlepony.render.plane.PlaneRenderer;
|
|
|
|
import net.minecraft.client.model.ModelRenderer;
|
|
import net.minecraft.client.renderer.GlStateManager;
|
|
import net.minecraft.entity.Entity;
|
|
import net.minecraft.entity.EntityLivingBase;
|
|
import net.minecraft.util.EnumHandSide;
|
|
import net.minecraft.util.math.MathHelper;
|
|
|
|
import static net.minecraft.client.renderer.GlStateManager.popMatrix;
|
|
import static net.minecraft.client.renderer.GlStateManager.pushMatrix;
|
|
import static com.minelittlepony.model.PonyModelConstants.*;
|
|
|
|
public class ModelPlayerPony extends AbstractPonyModel {
|
|
|
|
private final boolean smallArms;
|
|
public boolean rainboom;
|
|
|
|
public ModelRenderer bipedCape;
|
|
|
|
public PlaneRenderer[] Bodypiece;
|
|
public PlaneRenderer BodypieceNeck;
|
|
|
|
public ModelRenderer unicornArmRight, unicornArmLeft;
|
|
|
|
public PonyTail Tail;
|
|
public PonySnout snout;
|
|
public UnicornHorn horn;
|
|
public PegasusWings wings;
|
|
|
|
public ModelPlayerPony(boolean smallArms) {
|
|
super(smallArms);
|
|
this.smallArms = smallArms;
|
|
}
|
|
|
|
@Override
|
|
public PonyArmor createArmour() {
|
|
return new PonyArmor(new ModelPonyArmor(), new ModelPonyArmor());
|
|
}
|
|
|
|
@Override
|
|
public void init(float yOffset, float stretch) {
|
|
super.init(yOffset, stretch);
|
|
snout = new PonySnout(this, yOffset, stretch);
|
|
horn = new UnicornHorn(this, yOffset, stretch);
|
|
wings = new PegasusWings(this, yOffset, stretch);
|
|
}
|
|
|
|
@Override
|
|
public void setRotationAngles(float limbSwing, float limbSwingAmount, float ageInTicks, float netHeadYaw, float headPitch, float scaleFactor, Entity entityIn) {
|
|
super.setRotationAngles(limbSwing, limbSwingAmount, ageInTicks, netHeadYaw, headPitch, scaleFactor, entityIn);
|
|
|
|
this.checkRainboom(entityIn, limbSwingAmount);
|
|
this.rotateHead(netHeadYaw, headPitch);
|
|
|
|
float bodySwingRotation = 0.0F;
|
|
if (this.swingProgress > -9990.0F && !this.metadata.hasMagic()) {
|
|
bodySwingRotation = MathHelper.sin(MathHelper.sqrt(this.swingProgress) * 3.1415927F * 2.0F) * 0.2F;
|
|
}
|
|
|
|
rotateLook(limbSwing, limbSwingAmount, bodySwingRotation, ageInTicks);
|
|
|
|
this.setLegs(limbSwing, limbSwingAmount, ageInTicks, entityIn);
|
|
this.holdItem(limbSwingAmount);
|
|
this.swingItem(entityIn, this.swingProgress);
|
|
if (this.isSneak && !this.isFlying && !this.rainboom) {
|
|
this.adjustBody(BODY_ROTATE_ANGLE_X_SNEAK, BODY_RP_Y_SNEAK, BODY_RP_Z_SNEAK);
|
|
this.sneakLegs();
|
|
this.setHead(0.0F, 6.0F, -2.0F);
|
|
} else if (this.isRiding) {
|
|
this.adjustBodyRiding();
|
|
this.bipedLeftLeg.rotationPointZ = 15;
|
|
this.bipedLeftLeg.rotationPointY = 10;
|
|
this.bipedLeftLeg.rotateAngleX = (float) (Math.PI * -0.25);
|
|
this.bipedLeftLeg.rotateAngleY = (float) (Math.PI * -0.2);
|
|
|
|
this.bipedRightLeg.rotationPointZ = 15;
|
|
this.bipedRightLeg.rotationPointY = 10;
|
|
this.bipedRightLeg.rotateAngleX = (float) (Math.PI * -0.25);
|
|
this.bipedRightLeg.rotateAngleY = (float) (Math.PI * 0.2);
|
|
|
|
this.bipedLeftArm.rotateAngleZ = (float) (Math.PI * -0.06);
|
|
this.bipedRightArm.rotateAngleZ = (float) (Math.PI * 0.06);
|
|
} else {
|
|
|
|
this.adjustBody(BODY_ROTATE_ANGLE_X_NOTSNEAK, BODY_RP_Y_NOTSNEAK, BODY_RP_Z_NOTSNEAK);
|
|
|
|
this.bipedRightLeg.rotationPointY = FRONT_LEG_RP_Y_NOTSNEAK;
|
|
this.bipedLeftLeg.rotationPointY = FRONT_LEG_RP_Y_NOTSNEAK;
|
|
this.swingArms(ageInTicks);
|
|
this.setHead(0.0F, 0.0F, 0.0F);
|
|
}
|
|
|
|
if (this.isSleeping) {
|
|
this.ponySleep();
|
|
}
|
|
|
|
this.aimBow(leftArmPose, rightArmPose, ageInTicks);
|
|
|
|
this.fixSpecialRotations();
|
|
this.fixSpecialRotationPoints(limbSwing);
|
|
|
|
animateWears();
|
|
|
|
this.bipedCape.rotationPointY = isSneak ? 2 : isRiding ? -4 : 0;
|
|
|
|
this.snout.setGender(this.metadata.getGender());
|
|
this.wings.setRotationAngles(limbSwing, limbSwingAmount, ageInTicks, netHeadYaw, headPitch, scaleFactor, entityIn);
|
|
}
|
|
|
|
protected void adjustBodyRiding() {
|
|
this.adjustBodyComponents(BODY_ROTATE_ANGLE_X_RIDING, BODY_RP_Y_RIDING, BODY_RP_Z_RIDING);
|
|
this.adjustNeck(BODY_ROTATE_ANGLE_X_NOTSNEAK, BODY_RP_Y_NOTSNEAK, BODY_RP_Z_NOTSNEAK);
|
|
this.setHead(0.0F, 0.0F, 0.0F);
|
|
}
|
|
|
|
protected void rotateLook(float limbSwing, float limbSwingAmount, float bodySwing, float ticks) {
|
|
this.Tail.setRotationAndAngles(rainboom, limbSwing, limbSwingAmount, bodySwing, ticks);
|
|
|
|
for (PlaneRenderer i : this.Bodypiece) {
|
|
i.rotateAngleY = bodySwing * 0.2F;
|
|
}
|
|
|
|
this.bipedBody.rotateAngleY = bodySwing * 0.2F;
|
|
this.BodypieceNeck.rotateAngleY = bodySwing * 0.2F;
|
|
this.bipedHead.offsetY = 0f;
|
|
this.bipedHead.offsetZ = 0f;
|
|
this.bipedHeadwear.offsetY = 0f;
|
|
this.bipedHeadwear.offsetZ = 0f;
|
|
}
|
|
|
|
private void animateWears() {
|
|
copyModelAngles(bipedLeftArm, bipedLeftArmwear);
|
|
copyModelAngles(bipedRightArm, bipedRightArmwear);
|
|
copyModelAngles(bipedLeftLeg, bipedLeftLegwear);
|
|
copyModelAngles(bipedRightLeg, bipedRightLegwear);
|
|
copyModelAngles(bipedBody, bipedBodyWear);
|
|
}
|
|
|
|
protected void checkRainboom(Entity entity, float swing) {
|
|
boolean flying = this.metadata.getRace().hasWings() && this.isFlying
|
|
|| entity instanceof EntityLivingBase && ((EntityLivingBase) entity).isElytraFlying();
|
|
|
|
this.rainboom = flying && swing >= 0.9999F;
|
|
}
|
|
|
|
protected void setHead(float posX, float posY, float posZ) {
|
|
this.bipedHead.setRotationPoint(posX, posY, posZ);
|
|
this.bipedHeadwear.setRotationPoint(posX, posY, posZ);
|
|
}
|
|
|
|
protected void rotateHead(float horz, float vert) {
|
|
float headRotateAngleY;
|
|
float headRotateAngleX;
|
|
if (this.isSleeping) {
|
|
headRotateAngleY = 1.4F;
|
|
headRotateAngleX = 0.1F;
|
|
} else {
|
|
headRotateAngleY = horz / 57.29578F;
|
|
headRotateAngleX = vert / 57.29578F;
|
|
}
|
|
|
|
final float max = (float) (0.5f - Math.toRadians(this.motionPitch));
|
|
final float min = (float) (-1.25f - Math.toRadians(this.motionPitch));
|
|
headRotateAngleX = Math.min(headRotateAngleX, max);
|
|
headRotateAngleX = Math.max(headRotateAngleX, min);
|
|
this.bipedHead.rotateAngleY = headRotateAngleY;
|
|
this.bipedHead.rotateAngleX = headRotateAngleX;
|
|
this.bipedHeadwear.rotateAngleY = headRotateAngleY;
|
|
this.bipedHeadwear.rotateAngleX = headRotateAngleX;
|
|
}
|
|
|
|
protected void setLegs(float move, float swing, float tick, Entity entity) {
|
|
this.rotateLegs(move, swing, tick, entity);
|
|
this.adjustLegs();
|
|
}
|
|
|
|
public boolean isFlying(Entity entity) {
|
|
return (isFlying && metadata.getRace().hasWings()) ||
|
|
(entity instanceof EntityLivingBase && ((EntityLivingBase) entity).isElytraFlying());
|
|
}
|
|
|
|
protected void rotateLegs(float move, float swing, float tick, Entity entity) {
|
|
float leftArm, rightArm,
|
|
leftLeg, rightLeg;
|
|
|
|
|
|
if (isFlying(entity)) {
|
|
if (this.rainboom) {
|
|
rightArm = leftArm = ROTATE_270;
|
|
rightLeg = leftLeg = ROTATE_90;
|
|
} else {
|
|
rightArm = leftArm = MathHelper.sin(-swing / 2);
|
|
rightLeg = leftLeg = MathHelper.sin(swing / 2);
|
|
}
|
|
|
|
steveRightArm.rotateAngleY = bipedRightArm.rotateAngleY = 0.2F;
|
|
bipedLeftArm.rotateAngleY = bipedRightLeg.rotateAngleY = -0.2F;
|
|
|
|
this.bipedLeftLeg.rotateAngleY = 0.2F;
|
|
|
|
} else {
|
|
float PI = (float)Math.PI;
|
|
float pi = PI * (float) Math.pow(swing, 16);
|
|
|
|
float mve = move * 0.6662F; // magic number ahoy
|
|
float srt = swing / 4;
|
|
|
|
leftArm = MathHelper.cos(mve + pi) * srt;
|
|
rightArm = MathHelper.cos(mve + PI + pi / 2) * srt;
|
|
|
|
leftLeg = MathHelper.cos(mve + PI - (pi * 0.4f)) * srt;
|
|
rightLeg = MathHelper.cos(mve + pi * 0.2f) * srt;
|
|
|
|
this.steveRightArm.rotateAngleY = this.bipedRightArm.rotateAngleY = 0;
|
|
|
|
this.bipedLeftArm.rotateAngleY = 0;
|
|
this.bipedRightLeg.rotateAngleY = 0;
|
|
this.bipedLeftLeg.rotateAngleY = 0;
|
|
|
|
this.unicornArmRight.rotateAngleY = 0;
|
|
this.unicornArmLeft.rotateAngleY = 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
this.steveLeftArm.rotateAngleX = this.bipedLeftArm.rotateAngleX = leftArm;
|
|
this.steveRightArm.rotateAngleX = this.bipedRightArm.rotateAngleX = rightArm;
|
|
|
|
this.bipedLeftArm.rotateAngleZ = 0;
|
|
this.steveRightArm.rotateAngleZ = this.bipedRightArm.rotateAngleZ = 0;
|
|
|
|
this.bipedLeftLeg.rotateAngleX = leftLeg;
|
|
this.bipedRightLeg.rotateAngleX = rightLeg;
|
|
|
|
this.unicornArmRight.rotateAngleX = 0;
|
|
this.unicornArmLeft.rotateAngleX = 0;
|
|
this.unicornArmRight.rotateAngleZ = 0;
|
|
this.unicornArmLeft.rotateAngleZ = 0;
|
|
}
|
|
|
|
private float getLegOutset() {
|
|
if (isSleeping) return 2.6f;
|
|
if (isSneak && !isFlying) return smallArms ? 1 : 0;
|
|
return 4;
|
|
}
|
|
|
|
protected void adjustLegs() {
|
|
float sin = MathHelper.sin(bipedBody.rotateAngleY) * 5;
|
|
float cos = MathHelper.cos(bipedBody.rotateAngleY) * 5;
|
|
|
|
float spread = rainboom ? 2 : 1;
|
|
|
|
steveRightArm.rotationPointZ = bipedRightArm.rotationPointZ = spread + sin;
|
|
|
|
bipedLeftArm.rotationPointZ = spread - sin;
|
|
steveRightArm.rotationPointZ = -cos;
|
|
|
|
float legOutset = getLegOutset();
|
|
float rpxl = cos + 1 - legOutset;
|
|
float rpxr = legOutset - cos - 1;
|
|
|
|
bipedRightArm.rotationPointX = rpxr;
|
|
bipedRightLeg.rotationPointX = rpxr;
|
|
bipedLeftArm.rotationPointX = rpxl;
|
|
bipedLeftLeg.rotationPointX = rpxl;
|
|
|
|
// Push the front legs back apart if we're a thin pony
|
|
if (smallArms) {
|
|
bipedLeftArm.rotationPointX--;
|
|
bipedLeftArm.rotationPointX += 2;
|
|
}
|
|
|
|
bipedRightArm.rotateAngleY += bipedBody.rotateAngleY;
|
|
bipedLeftArm.rotateAngleY += bipedBody.rotateAngleY;
|
|
|
|
bipedRightArm.rotationPointY = bipedLeftArm.rotationPointY = 8;
|
|
bipedRightLeg.rotationPointZ = bipedLeftLeg.rotationPointZ = 10;
|
|
}
|
|
|
|
|
|
|
|
protected void holdItem(float swing) {
|
|
if (!this.rainboom && !this.metadata.hasMagic()) {
|
|
boolean bothHoovesAreOccupied = this.leftArmPose == ArmPose.ITEM && this.rightArmPose == ArmPose.ITEM;
|
|
alignArmForAction(bipedLeftArm, leftArmPose, bothHoovesAreOccupied, swing);
|
|
alignArmForAction(bipedRightArm, rightArmPose, bothHoovesAreOccupied, swing);
|
|
} else if (this.metadata.hasMagic()) {
|
|
if (this.leftArmPose == ArmPose.BLOCK) blockArm(unicornArmLeft);
|
|
if (this.rightArmPose == ArmPose.BLOCK) blockArm(unicornArmRight);
|
|
}
|
|
|
|
this.horn.setUsingMagic(this.leftArmPose != ArmPose.EMPTY || this.rightArmPose != ArmPose.EMPTY);
|
|
}
|
|
|
|
private void alignArmForAction(ModelRenderer arm, ArmPose pose, boolean both, float swing) {
|
|
switch (pose) {
|
|
case ITEM:
|
|
float swag = 1;
|
|
if (!isFlying && both) {
|
|
swag = (float) (1 - Math.pow(swing, 2));
|
|
}
|
|
float mult = 0.5f + (1 - swag)/2;
|
|
arm.rotateAngleX = this.bipedLeftArm.rotateAngleX * mult - ((float) Math.PI / 10) * swag;
|
|
case EMPTY:
|
|
arm.rotateAngleY = 0;
|
|
break;
|
|
case BLOCK:
|
|
arm.rotateAngleX = arm.rotateAngleX / 2 - 0.9424779F;
|
|
arm.rotateAngleY = (float) (Math.PI / 6);
|
|
break;
|
|
default:
|
|
}
|
|
}
|
|
|
|
private void blockArm(ModelRenderer arm) {
|
|
arm.rotateAngleX = arm.rotateAngleX * 0.5F - 0.9424779F;
|
|
arm.rotateAngleY = (float) (Math.PI / 6);
|
|
}
|
|
|
|
protected void swingItem(Entity entity, float swingProgress) {
|
|
if (swingProgress > -9990.0F && !this.isSleeping) {
|
|
float f16 = 1.0F - swingProgress;
|
|
f16 *= f16 * f16;
|
|
f16 = 1.0F - f16;
|
|
float f22 = MathHelper.sin(f16 * 3.1415927F);
|
|
float f28 = MathHelper.sin(swingProgress * 3.1415927F);
|
|
float f33 = f28 * -(this.bipedHead.rotateAngleX - 0.7F) * 0.75F;
|
|
|
|
EnumHandSide mainSide = this.getMainHand(entity);
|
|
|
|
boolean mainRight = mainSide == EnumHandSide.RIGHT;
|
|
ArmPose mainPose = mainRight ? this.rightArmPose : this.leftArmPose;
|
|
|
|
if (this.metadata.hasMagic() && mainPose != ArmPose.EMPTY) {
|
|
swingArm(mainRight ? this.unicornArmRight : this.unicornArmLeft, f22, f33, f28);
|
|
} else {
|
|
swingArm(this.getArmForSide(mainSide), f22, f33, f28);
|
|
swingArm(mainRight ? this.steveRightArm : this.steveLeftArm, f22, f33, f28);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void swingArm(ModelRenderer arm, float f22, float f33, float f28) {
|
|
arm.rotateAngleX = (float) (arm.rotateAngleX - (f22 * 1.2D + f33));
|
|
arm.rotateAngleY += this.bipedBody.rotateAngleY * 2.0F;
|
|
arm.rotateAngleZ = f28 * -0.4F;
|
|
}
|
|
|
|
protected void swingArms(float tick) {
|
|
float cos = MathHelper.cos(tick * 0.09F) * 0.05F + 0.05F;
|
|
float sin = MathHelper.sin(tick * 0.067F) * 0.05F;
|
|
|
|
if (this.rightArmPose != ArmPose.EMPTY && !this.isSleeping) {
|
|
|
|
if (this.metadata.hasMagic()) {
|
|
this.unicornArmRight.rotateAngleZ += cos;
|
|
this.unicornArmRight.rotateAngleX += sin;
|
|
} else {
|
|
this.bipedRightArm.rotateAngleZ += cos;
|
|
this.steveRightArm.rotateAngleZ += cos;
|
|
|
|
this.bipedRightArm.rotateAngleX += sin;
|
|
this.steveRightArm.rotateAngleX += sin;
|
|
}
|
|
}
|
|
if (this.leftArmPose != ArmPose.EMPTY && !this.isSleeping) {
|
|
if (this.metadata.hasMagic()) {
|
|
this.unicornArmLeft.rotateAngleZ += cos;
|
|
this.unicornArmLeft.rotateAngleX += sin;
|
|
} else {
|
|
this.bipedLeftArm.rotateAngleZ += cos;
|
|
this.steveLeftArm.rotateAngleZ += cos;
|
|
|
|
this.bipedLeftArm.rotateAngleX += sin;
|
|
this.steveLeftArm.rotateAngleX += sin;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void adjustBody(float rotateAngleX, float rotationPointY, float rotationPointZ) {
|
|
this.adjustBodyComponents(rotateAngleX, rotationPointY, rotationPointZ);
|
|
this.adjustNeck(rotateAngleX, rotationPointY, rotationPointZ);
|
|
}
|
|
|
|
protected void adjustBodyComponents(float rotateAngleX, float rotationPointY, float rotationPointZ) {
|
|
this.bipedBody.rotateAngleX = rotateAngleX;
|
|
this.bipedBody.rotationPointY = rotationPointY;
|
|
this.bipedBody.rotationPointZ = rotationPointZ;
|
|
|
|
for (PlaneRenderer i : Bodypiece) {
|
|
i.rotateAngleX = rotateAngleX;
|
|
i.rotationPointY = rotationPointY;
|
|
i.rotationPointZ = rotationPointZ;
|
|
}
|
|
}
|
|
|
|
protected void adjustNeck(float rotateAngleX, float rotationPointY, float rotationPointZ) {
|
|
BodypieceNeck.setRotationPoint(NECK_ROT_X + rotateAngleX, rotationPointY, rotationPointZ);
|
|
}
|
|
|
|
protected void sneakLegs() {
|
|
this.steveRightArm.rotateAngleX += SNEAK_LEG_X_ROTATION_ADJUSTMENT;
|
|
|
|
this.unicornArmRight.rotateAngleX += SNEAK_LEG_X_ROTATION_ADJUSTMENT;
|
|
this.unicornArmLeft.rotateAngleX += SNEAK_LEG_X_ROTATION_ADJUSTMENT;
|
|
|
|
this.bipedRightArm.rotateAngleX -= SNEAK_LEG_X_ROTATION_ADJUSTMENT;
|
|
this.bipedLeftArm.rotateAngleX -= SNEAK_LEG_X_ROTATION_ADJUSTMENT;
|
|
|
|
this.bipedLeftLeg.rotationPointY = this.bipedRightLeg.rotationPointY = FRONT_LEG_RP_Y_SNEAK;
|
|
}
|
|
|
|
protected void ponySleep() {
|
|
this.bipedRightArm.rotateAngleX = ROTATE_270;
|
|
this.bipedLeftArm.rotateAngleX = ROTATE_270;
|
|
this.bipedRightLeg.rotateAngleX = ROTATE_90;
|
|
this.bipedLeftLeg.rotateAngleX = ROTATE_90;
|
|
|
|
float headPosX, headPosY, headPosZ;
|
|
|
|
if (this.isSneak) {
|
|
headPosY = 2;
|
|
headPosZ = -1;
|
|
headPosX = 1;
|
|
} else {
|
|
headPosY = 2;
|
|
headPosZ = 1;
|
|
headPosX = 1;
|
|
}
|
|
|
|
this.setHead(headPosX, headPosY, headPosZ);
|
|
shiftRotationPoint(this.bipedRightArm, 0.0F, 2.0F, 6.0F);
|
|
shiftRotationPoint(this.bipedLeftArm, 0.0F, 2.0F, 6.0F);
|
|
shiftRotationPoint(this.bipedRightLeg, 0.0F, 2.0F, -8.0F);
|
|
shiftRotationPoint(this.bipedLeftLeg, 0.0F, 2.0F, -8.0F);
|
|
}
|
|
|
|
protected void aimBow(ArmPose leftArm, ArmPose rightArm, float tick) {
|
|
if (leftArm == ArmPose.BOW_AND_ARROW || rightArm == ArmPose.BOW_AND_ARROW) {
|
|
|
|
if (this.metadata.hasMagic()) {
|
|
if (rightArm == ArmPose.BOW_AND_ARROW) aimBowPony(unicornArmRight, tick, true);
|
|
if (leftArm == ArmPose.BOW_AND_ARROW) aimBowPony(unicornArmLeft, tick, false);
|
|
} else {
|
|
if (rightArm == ArmPose.BOW_AND_ARROW) aimBowPony(bipedRightArm, tick, false);
|
|
if (leftArm == ArmPose.BOW_AND_ARROW) aimBowPony(bipedLeftArm, tick, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void aimBowPony(ModelRenderer arm, float tick, boolean shift) {
|
|
arm.rotateAngleZ = 0.0F;
|
|
arm.rotateAngleY = -0.06F + this.bipedHead.rotateAngleY;
|
|
arm.rotateAngleX = ROTATE_270 + this.bipedHead.rotateAngleX;
|
|
arm.rotateAngleZ += MathHelper.cos(tick * 0.09F) * 0.05F + 0.05F;
|
|
arm.rotateAngleX += MathHelper.sin(tick * 0.067F) * 0.05F;
|
|
if (shift) shiftRotationPoint(arm, 0.0F, 0.0F, 1.0F);
|
|
}
|
|
|
|
protected void fixSpecialRotations() {
|
|
this.Bodypiece[9].rotateAngleX += 0.5F;
|
|
this.Bodypiece[10].rotateAngleX += 0.5F;
|
|
this.Bodypiece[11].rotateAngleX += 0.5F;
|
|
this.Bodypiece[12].rotateAngleX += 0.5F;
|
|
this.Bodypiece[13].rotateAngleX += 0.5F;
|
|
}
|
|
|
|
protected void fixSpecialRotationPoints(float move) {
|
|
}
|
|
|
|
@Override
|
|
public void render(Entity entityIn, float limbSwing, float limbSwingAmount, float ageInTicks, float netHeadYaw, float headPitch, float scale) {
|
|
|
|
pushMatrix();
|
|
this.transform(BodyPart.HEAD);
|
|
this.renderHead(entityIn, limbSwing, limbSwingAmount, ageInTicks, netHeadYaw, headPitch, scale);
|
|
popMatrix();
|
|
|
|
pushMatrix();
|
|
this.transform(BodyPart.NECK);
|
|
this.renderNeck();
|
|
popMatrix();
|
|
|
|
pushMatrix();
|
|
this.transform(BodyPart.BODY);
|
|
this.renderBody(entityIn, limbSwing, limbSwingAmount, ageInTicks, netHeadYaw, headPitch, scale);
|
|
this.Tail.render(this.metadata.getTail(), this.scale);
|
|
popMatrix();
|
|
|
|
pushMatrix();
|
|
this.transform(BodyPart.LEGS);
|
|
this.renderLegs();
|
|
popMatrix();
|
|
}
|
|
|
|
protected void renderHead(Entity entityIn, float limbSwing, float limbSwingAmount, float ageInTicks, float netHeadYaw, float headPitch, float scale) {
|
|
this.bipedHead.render(this.scale);
|
|
this.bipedHeadwear.render(this.scale);
|
|
this.bipedHead.postRender(scale);
|
|
this.horn.render(entityIn, limbSwing, limbSwingAmount, ageInTicks, netHeadYaw, headPitch, scale);
|
|
|
|
}
|
|
|
|
protected void renderNeck() {
|
|
GlStateManager.scale(0.9, 0.9, 0.9);
|
|
this.BodypieceNeck.render(this.scale);
|
|
}
|
|
|
|
protected void renderBody(Entity entityIn, float limbSwing, float limbSwingAmount, float ageInTicks, float netHeadYaw, float headPitch, float scale) {
|
|
this.bipedBody.render(this.scale);
|
|
if (this.textureHeight == 64) {
|
|
this.bipedBodyWear.render(this.scale);
|
|
}
|
|
for (PlaneRenderer aBodypiece : this.Bodypiece) {
|
|
aBodypiece.render(this.scale);
|
|
}
|
|
this.bipedBody.postRender(scale);
|
|
this.wings.render(entityIn, limbSwing, limbSwingAmount, ageInTicks, netHeadYaw, headPitch, this.scale);
|
|
}
|
|
|
|
protected void renderLegs() {
|
|
if (!this.isSneak) {
|
|
this.bipedBody.postRender(this.scale);
|
|
}
|
|
|
|
this.bipedLeftArm.render(this.scale);
|
|
this.bipedRightArm.render(this.scale);
|
|
this.bipedLeftLeg.render(this.scale);
|
|
this.bipedRightLeg.render(this.scale);
|
|
|
|
if (this.textureHeight == 64) {
|
|
this.bipedLeftArmwear.render(this.scale);
|
|
this.bipedRightArmwear.render(this.scale);
|
|
this.bipedLeftLegwear.render(this.scale);
|
|
this.bipedRightLegwear.render(this.scale);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void initTextures() {
|
|
this.boxList.clear();
|
|
this.Bodypiece = new PlaneRenderer[14];
|
|
this.initHeadTextures();
|
|
this.initBodyTextures();
|
|
this.initLegTextures();
|
|
this.Tail = new PonyTail(this);
|
|
}
|
|
|
|
protected void initHeadTextures() {
|
|
this.bipedCape = new ModelRenderer(this, 0, 0).setTextureSize(64, 32);
|
|
this.bipedHead = new ModelRenderer(this, 0, 0);
|
|
this.bipedHeadwear = new ModelRenderer(this, 32, 0);
|
|
}
|
|
|
|
protected void initBodyTextures() {
|
|
this.bipedBody = new ModelRenderer(this, 16, 16);
|
|
|
|
if (this.textureHeight == 64) {
|
|
this.bipedBodyWear = new ModelRenderer(this, 16, 32);
|
|
}
|
|
|
|
this.Bodypiece[0] = new PlaneRenderer(this, 24, 0);
|
|
this.Bodypiece[0].mirrorz = true;
|
|
|
|
this.Bodypiece[1] = new PlaneRenderer(this, 24, 0);
|
|
|
|
this.Bodypiece[2] = new PlaneRenderer(this, 32, 20);
|
|
this.Bodypiece[2].mirrorz = true;
|
|
|
|
this.Bodypiece[3] = new PlaneRenderer(this, 56, 0);
|
|
|
|
this.Bodypiece[4] = new PlaneRenderer(this, 4, 0);
|
|
this.Bodypiece[4].mirrorz = true;
|
|
|
|
this.Bodypiece[5] = new PlaneRenderer(this, 4, 0);
|
|
|
|
this.Bodypiece[6] = new PlaneRenderer(this, 36, 16);
|
|
this.Bodypiece[7] = new PlaneRenderer(this, 36, 16);
|
|
this.Bodypiece[8] = new PlaneRenderer(this, 36, 16);
|
|
|
|
this.Bodypiece[11] = new PlaneRenderer(this, 32, 0);
|
|
this.Bodypiece[11].mirror = true;
|
|
|
|
this.Bodypiece[9] = new PlaneRenderer(this, 32, 0);
|
|
this.Bodypiece[10] = new PlaneRenderer(this, 32, 0);
|
|
this.Bodypiece[12] = new PlaneRenderer(this, 32, 0);
|
|
this.Bodypiece[13] = new PlaneRenderer(this, 32, 0);
|
|
|
|
this.BodypieceNeck = new PlaneRenderer(this, 0, 16);
|
|
|
|
}
|
|
|
|
protected void initLegTextures() {
|
|
this.bipedRightArm = new ModelRenderer(this, 40, 16);
|
|
this.bipedRightLeg = new ModelRenderer(this, 0, 16);
|
|
|
|
this.bipedLeftArm = new ModelRenderer(this, 32, 48);
|
|
this.bipedLeftLeg = new ModelRenderer(this, 16, 48);
|
|
|
|
this.bipedRightArmwear = new ModelRenderer(this, 40, 32);
|
|
this.bipedRightLegwear = new ModelRenderer(this, 0, 32);
|
|
|
|
this.bipedLeftArmwear = new ModelRenderer(this, 48, 48);
|
|
this.bipedLeftLegwear = new ModelRenderer(this, 0, 48);
|
|
|
|
this.unicornArmRight = new ModelRenderer(this, 40, 32).setTextureSize(64, 64);
|
|
this.unicornArmLeft = new ModelRenderer(this, 40, 32).setTextureSize(64, 64);
|
|
|
|
this.boxList.remove(this.steveRightArm);
|
|
this.boxList.remove(this.unicornArmRight);
|
|
}
|
|
|
|
@Override
|
|
protected void initPositions(float yOffset, float stretch) {
|
|
this.initHeadPositions(yOffset, stretch);
|
|
this.initBodyPositions(yOffset, stretch);
|
|
this.initLegPositions(yOffset, stretch);
|
|
this.Tail.init(yOffset, stretch);
|
|
}
|
|
|
|
protected void initHeadPositions(float yOffset, float stretch) {
|
|
this.bipedCape.addBox(-5.0F, 0.0F, -1.0F, 10, 16, 1, stretch);
|
|
this.bipedHead.addBox(-4.0F + HEAD_CENTRE_X, -4 + HEAD_CENTRE_Y, -4.0F + HEAD_CENTRE_Z, 8, 8, 8, stretch);
|
|
this.bipedHead.setRotationPoint(HEAD_RP_X, HEAD_RP_Y + yOffset, HEAD_RP_Z - 2);
|
|
// set ears
|
|
this.bipedHead.setTextureOffset(12, 16);
|
|
this.bipedHead.addBox(-4.0F + HEAD_CENTRE_X, -6.0F + HEAD_CENTRE_Y, 1.0F + HEAD_CENTRE_Z, 2, 2, 2, stretch);
|
|
this.bipedHead.mirror = true;
|
|
this.bipedHead.addBox(2.0F + HEAD_CENTRE_X, -6.0F + HEAD_CENTRE_Y, 1.0F + HEAD_CENTRE_Z, 2, 2, 2, stretch);
|
|
|
|
this.bipedHeadwear.addBox(-4.0F + HEAD_CENTRE_X, -4.0F + HEAD_CENTRE_Y, -4.0F + HEAD_CENTRE_Z, 8, 8, 8, stretch + 0.5F);
|
|
this.bipedHeadwear.setRotationPoint(HEAD_RP_X, HEAD_RP_Y + yOffset, HEAD_RP_Z - 2);
|
|
}
|
|
|
|
protected void initBodyPositions(float yOffset, float stretch) {
|
|
this.bipedBody.addBox(-4.0F, 4.0F, -2.0F, 8, 8, 4, stretch);
|
|
this.bipedBody.setRotationPoint(HEAD_RP_X, HEAD_RP_Y + yOffset, HEAD_RP_Z);
|
|
this.bipedBodyWear.addBox(-4.0F, 4.0F, -2.0F, 8, 8, 4, stretch + 0.25F);
|
|
this.bipedBodyWear.setRotationPoint(HEAD_RP_X, HEAD_RP_Y + yOffset, HEAD_RP_Z);
|
|
|
|
this.Bodypiece[0].addWestPlane(-4.0F + BODY_CENTRE_X, -4.0F + BODY_CENTRE_Y, -4.0F + BODY_CENTRE_Z, 8, 8, stretch);
|
|
this.Bodypiece[1].addEastPlane(4.0F + BODY_CENTRE_X, -4.0F + BODY_CENTRE_Y, -4.0F + BODY_CENTRE_Z, 8, 8, stretch);
|
|
this.Bodypiece[2].addTopPlane(-4.0F + BODY_CENTRE_X, -4.0F + BODY_CENTRE_Y, -4.0F + BODY_CENTRE_Z, 8, 12, stretch);
|
|
this.Bodypiece[3].addBottomPlane(-4.0F + BODY_CENTRE_X, 4.0F + BODY_CENTRE_Y, -4.0F + BODY_CENTRE_Z, 8, 8, stretch);
|
|
this.Bodypiece[4].addWestPlane(-4.0F + BODY_CENTRE_X, -4.0F + BODY_CENTRE_Y, 4.0F + BODY_CENTRE_Z, 8, 4, stretch);
|
|
this.Bodypiece[5].addEastPlane(4.0F + BODY_CENTRE_X, -4.0F + BODY_CENTRE_Y, 4.0F + BODY_CENTRE_Z, 8, 4, stretch);
|
|
this.Bodypiece[6].addBackPlane(-4.0F + BODY_CENTRE_X, -4.0F + BODY_CENTRE_Y, 8.0F + BODY_CENTRE_Z, 8, 4, stretch);
|
|
this.Bodypiece[7].addBackPlane(-4.0F + BODY_CENTRE_X, 0.0F + BODY_CENTRE_Y, 8.0F + BODY_CENTRE_Z, 8, 4, stretch);
|
|
this.Bodypiece[8].addBottomPlane(-4.0F + BODY_CENTRE_X, 4.0F + BODY_CENTRE_Y, 4.0F + BODY_CENTRE_Z, 8, 4, stretch);
|
|
this.Bodypiece[9].addTopPlane(-1.0F + BODY_CENTRE_X, 2.0F + BODY_CENTRE_Y, 2.0F + BODY_CENTRE_Z, 2, 6, stretch);
|
|
this.Bodypiece[10].addBottomPlane(-1.0F + BODY_CENTRE_X, 4.0F + BODY_CENTRE_Y, 2.0F + BODY_CENTRE_Z, 2, 6, stretch);
|
|
this.Bodypiece[11].addWestPlane(-1.0F + BODY_CENTRE_X, 2.0F + BODY_CENTRE_Y, 2.0F + BODY_CENTRE_Z, 2, 6, stretch);
|
|
this.Bodypiece[12].addEastPlane(1.0F + BODY_CENTRE_X, 2.0F + BODY_CENTRE_Y, 2.0F + BODY_CENTRE_Z, 2, 6, stretch);
|
|
this.Bodypiece[13].addBackPlane(-1.0F + BODY_CENTRE_X, 2.0F + BODY_CENTRE_Y, 8.0F + BODY_CENTRE_Z, 2, 2, stretch);
|
|
|
|
for (int i = 0; i < this.Bodypiece.length; i++) {
|
|
this.Bodypiece[i].setRotationPoint(HEAD_RP_X, HEAD_RP_Y + yOffset, HEAD_RP_Z);
|
|
}
|
|
|
|
this.BodypieceNeck.addBackPlane(-2.0F + BODY_CENTRE_X, -6.8F + BODY_CENTRE_Y, -8.8F + BODY_CENTRE_Z, 4, 4, stretch);
|
|
this.BodypieceNeck.addBackPlane(-2.0F + BODY_CENTRE_X, -6.8F + BODY_CENTRE_Y, -4.8F + BODY_CENTRE_Z, 4, 4, stretch);
|
|
this.BodypieceNeck.addEastPlane(2.0F + BODY_CENTRE_X, -6.8F + BODY_CENTRE_Y, -8.8F + BODY_CENTRE_Z, 4, 4, stretch);
|
|
this.BodypieceNeck.addWestPlane(-2.0F + BODY_CENTRE_X, -6.8F + BODY_CENTRE_Y, -8.8F + BODY_CENTRE_Z, 4, 4, stretch);
|
|
|
|
this.BodypieceNeck.setRotationPoint(HEAD_RP_X, HEAD_RP_Y + yOffset, HEAD_RP_Z);
|
|
this.BodypieceNeck.rotateAngleX = NECK_ROT_X;
|
|
}
|
|
|
|
protected void initLegPositions(float yOffset, float stretch) {
|
|
int armWidth = smallArms ? 3 : 4;
|
|
float rarmY = smallArms ? 8.5f : 8;
|
|
float rarmX = smallArms ? 2 : 3;
|
|
|
|
float armX = THIRDP_ARM_CENTRE_X - 2;
|
|
float armY = THIRDP_ARM_CENTRE_Y - 6;
|
|
float armZ = THIRDP_ARM_CENTRE_Z - 2;
|
|
|
|
this.bipedLeftArm .addBox(armX, armY, armZ, armWidth, 12, 4, stretch);
|
|
this.bipedRightArm.addBox(armX, armY, armZ, armWidth, 12, 4, stretch);
|
|
|
|
this.bipedLeftLeg .addBox(armX, armY, armZ, 4, 12, 4, stretch);
|
|
this.bipedRightLeg.addBox(armX, armY, armZ, 4, 12, 4, stretch);
|
|
|
|
this.bipedLeftArm .setRotationPoint( rarmX, yOffset + rarmY, 0);
|
|
this.bipedRightArm.setRotationPoint(-rarmX, yOffset + rarmY, 0);
|
|
|
|
this.bipedLeftLeg .setRotationPoint( rarmX, yOffset, 0);
|
|
this.bipedRightLeg.setRotationPoint(-rarmX, yOffset, 0);
|
|
|
|
if (bipedLeftArmwear != null) {
|
|
this.bipedLeftArmwear.addBox(armX, armY, armZ, 3, 12, 4, stretch + 0.25f);
|
|
this.bipedLeftArmwear.setRotationPoint(3, yOffset + rarmY, 0);
|
|
}
|
|
|
|
if (bipedRightArmwear != null) {
|
|
this.bipedRightArmwear.addBox(armX, armY, armZ, armWidth, 12, 4, stretch + 0.25f);
|
|
this.bipedRightArmwear.setRotationPoint(-3, yOffset + rarmY, 0);
|
|
}
|
|
|
|
if (this.bipedLeftLegwear != null) {
|
|
this.bipedLeftLegwear.addBox(armX, armY, armZ, 4, 12, 4, stretch + 0.25f);
|
|
this.bipedRightLegwear.setRotationPoint(3, yOffset, 0);
|
|
}
|
|
|
|
if (bipedRightLegwear != null) {
|
|
this.bipedRightLegwear.addBox(armX, armY, armZ, 4, 12, 4, stretch + 0.25f);
|
|
this.bipedRightLegwear.setRotationPoint(-3, yOffset, 0);
|
|
}
|
|
|
|
this.unicornArmLeft .addBox(FIRSTP_ARM_CENTRE_X - 2, armY, armZ, 4, 12, 4, stretch + .25f);
|
|
this.unicornArmRight.addBox(FIRSTP_ARM_CENTRE_X - 2, armY, armZ, 4, 12, 4, stretch + .25f);
|
|
|
|
this.unicornArmLeft .setRotationPoint(5, yOffset + 2, 0);
|
|
this.unicornArmRight.setRotationPoint(-5, yOffset + 2, 0);
|
|
}
|
|
|
|
@Override
|
|
public void renderCape(float scale) {
|
|
this.bipedCape.render(scale);
|
|
}
|
|
}
|