lauchmelder/BloodMagic
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Testing

Browse source
This commit is contained in:
WayofTime 2014-01-17 14:12:49 -05:00
commit 8601e9faff
498 changed files with 45817 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

182
BM_src/WayofTime/alchemicalWizardry/common/renderer/model/ModelBileDemon.java Normal file
View file

@ -0,0 +1,182 @@
package WayofTime.alchemicalWizardry.common.renderer.model;
import org.lwjgl.opengl.GL11;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.entity.Entity;
import net.minecraft.util.MathHelper;
public class ModelBileDemon extends ModelBase
{
//fields
ModelRenderer belly;
ModelRenderer chest;
ModelRenderer head;
ModelRenderer nose;
ModelRenderer leftHorn;
ModelRenderer leftArmSpacer;
ModelRenderer leftArm;
ModelRenderer leftChain;
ModelRenderer leftBall;
ModelRenderer rightHorn;
ModelRenderer rightChain;
ModelRenderer rightBall;
ModelRenderer rightArmSpacer;
ModelRenderer rightArm;
public ModelBileDemon()
{
textureWidth = 128;
textureHeight = 64;
belly = new ModelRenderer(this, 0, 31);
belly.addBox(-8F, -1F, -10F, 16, 15, 18);
belly.setRotationPoint(0F, 10F, 0F);
belly.setTextureSize(128, 64);
belly.mirror = true;
setRotation(belly, 0F, 0F, 0F);
chest = new ModelRenderer(this, 70, 46);
chest.addBox(-7F, -4F, -6F, 14, 4, 14);
chest.setRotationPoint(0F, 10F, 0F);
chest.setTextureSize(128, 64);
chest.mirror = true;
setRotation(chest, -0.1115358F, 0F, 0F);
head = new ModelRenderer(this, 0, 0);
head.addBox(-4F, -8F, -4F, 8, 8, 8);
head.setRotationPoint(0F, 6F, 3F);
head.setTextureSize(128, 64);
head.mirror = true;
setRotation(head, 0F, 0F, 0F);
nose = new ModelRenderer(this, 0, 0);
nose.addBox(-1F, -4F, -5F, 2, 1, 1);
nose.setRotationPoint(0F, 6F, 3F);
nose.setTextureSize(128, 64);
nose.mirror = true;
setRotation(nose, 0F, 0F, 0F);
leftHorn = new ModelRenderer(this, 93, 1);
leftHorn.addBox(4F, -7F, 0F, 16, 1, 1);
leftHorn.setRotationPoint(0F, 6F, 3F);
leftHorn.setTextureSize(128, 64);
leftHorn.mirror = true;
setRotation(leftHorn, 0F, 0F, 0F);
leftArmSpacer = new ModelRenderer(this, 80, 1);
leftArmSpacer.addBox(0F, -2F, -2F, 1, 4, 4);
leftArmSpacer.setRotationPoint(7F, 8F, 3F);
leftArmSpacer.setTextureSize(128, 64);
leftArmSpacer.mirror = true;
setRotation(leftArmSpacer, 0F, 0F, 0F);
leftArm = new ModelRenderer(this, 62, 1);
leftArm.addBox(1F, -2F, -2F, 4, 18, 4);
leftArm.setRotationPoint(7F, 8F, 3F);
leftArm.setTextureSize(128, 64);
leftArm.mirror = true;
setRotation(leftArm, 0F, 0F, 0F);
leftChain = new ModelRenderer(this, 95, 5);
leftChain.addBox(17F, -6F, 0F, 1, 6, 1);
leftChain.setRotationPoint(0F, 6F, 3F);
leftChain.setTextureSize(128, 64);
leftChain.mirror = true;
setRotation(leftChain, 0F, 0F, 0F);
leftBall = new ModelRenderer(this, 107, 4);
leftBall.addBox(15F, 0F, -2F, 5, 5, 5);
leftBall.setRotationPoint(0F, 6F, 3F);
leftBall.setTextureSize(128, 64);
leftBall.mirror = true;
setRotation(leftBall, 0F, 0F, 0F);
rightHorn = new ModelRenderer(this, 93, 1);
rightHorn.mirror = true;
rightHorn.addBox(-20F, -7F, 0F, 16, 1, 1);
rightHorn.setRotationPoint(0F, 6F, 3F);
rightHorn.setTextureSize(128, 64);
rightHorn.mirror = true;
setRotation(rightHorn, 0F, 0F, 0F);
rightHorn.mirror = false;
rightChain = new ModelRenderer(this, 95, 5);
rightChain.mirror = true;
rightChain.addBox(-18F, -6F, 0F, 1, 6, 1);
rightChain.setRotationPoint(0F, 6F, 3F);
rightChain.setTextureSize(128, 64);
rightChain.mirror = true;
setRotation(rightChain, 0F, 0F, 0F);
rightChain.mirror = false;
rightBall = new ModelRenderer(this, 107, 4);
rightBall.mirror = true;
rightBall.addBox(-20F, 0F, -2F, 5, 5, 5);
rightBall.setRotationPoint(0F, 6F, 3F);
rightBall.setTextureSize(128, 64);
rightBall.mirror = true;
setRotation(rightBall, 0F, 0F, 0F);
rightBall.mirror = false;
rightArmSpacer = new ModelRenderer(this, 80, 1);
rightArmSpacer.mirror = true;
rightArmSpacer.addBox(-1F, -2F, -2F, 1, 4, 4);
rightArmSpacer.setRotationPoint(-7F, 8F, 3F);
rightArmSpacer.setTextureSize(128, 64);
rightArmSpacer.mirror = true;
setRotation(rightArmSpacer, 0F, 0F, 0F);
rightArmSpacer.mirror = false;
rightArm = new ModelRenderer(this, 62, 1);
rightArm.mirror = true;
rightArm.addBox(-5F, -2F, -2F, 4, 18, 4);
rightArm.setRotationPoint(-7F, 8F, 3F);
rightArm.setTextureSize(128, 64);
rightArm.mirror = true;
setRotation(rightArm, 0F, 0F, 0F);
rightArm.mirror = false;
}
public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
{
super.render(entity, f, f1, f2, f3, f4, f5);
setRotationAngles(f, f1, f2, f3, f4, f5, entity);
float scale = 1.3f;
GL11.glScalef(scale, scale, scale);
GL11.glTranslatef(0.0f, -(6.0f / 16.0f), 0.0f);
belly.render(f5);
chest.render(f5);
head.render(f5);
nose.render(f5);
leftHorn.render(f5);
leftArmSpacer.render(f5);
leftArm.render(f5);
leftChain.render(f5);
leftBall.render(f5);
rightHorn.render(f5);
rightChain.render(f5);
rightBall.render(f5);
rightArmSpacer.render(f5);
rightArm.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
{
super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
this.head.rotateAngleX = f4 / (180F / (float)Math.PI);
this.head.rotateAngleY = f3 / (180F / (float)Math.PI);
this.rightArm.rotateAngleX = MathHelper.cos(f * 0.3662F + (float)Math.PI) * 1.0F * f1;
this.leftArm.rotateAngleX = MathHelper.cos(f * 0.3662F) * 1.0F * f1;
this.rightArmSpacer.rotateAngleX = MathHelper.cos(f * 0.3662F + (float)Math.PI) * 1.0F * f1;
this.leftArmSpacer.rotateAngleX = MathHelper.cos(f * 0.3662F) * 1.0F * f1;
this.leftBall.rotateAngleX = this.head.rotateAngleX;
this.leftBall.rotateAngleY = this.head.rotateAngleY;
this.rightBall.rotateAngleX = this.head.rotateAngleX;
this.rightBall.rotateAngleY = this.head.rotateAngleY;
this.leftChain.rotateAngleX = this.head.rotateAngleX;
this.leftChain.rotateAngleY = this.head.rotateAngleY;
this.rightChain.rotateAngleX = this.head.rotateAngleX;
this.rightChain.rotateAngleY = this.head.rotateAngleY;
this.leftHorn.rotateAngleX = this.head.rotateAngleX;
this.leftHorn.rotateAngleY = this.head.rotateAngleY;
this.rightHorn.rotateAngleX = this.head.rotateAngleX;
this.rightHorn.rotateAngleY = this.head.rotateAngleY;
this.nose.rotateAngleX = this.head.rotateAngleX;
this.nose.rotateAngleY = this.head.rotateAngleY;
}
}

72
BM_src/WayofTime/alchemicalWizardry/common/renderer/model/ModelBloodAltar.java Normal file
View file

@ -0,0 +1,72 @@
package WayofTime.alchemicalWizardry.common.renderer.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.client.model.AdvancedModelLoader;
import net.minecraftforge.client.model.IModelCustom;
import org.lwjgl.opengl.GL11;
import WayofTime.alchemicalWizardry.common.tileEntity.TEAltar;
import cpw.mods.fml.client.FMLClientHandler;
public class ModelBloodAltar extends ModelBase
{
private IModelCustom modelBloodAltar;
private IModelCustom modelBloodLevel; //TODO
public ModelBloodAltar()
{
modelBloodAltar = AdvancedModelLoader.loadModel("/assets/alchemicalwizardry/models/bloodaltar-fixeUV.obj");
modelBloodLevel = AdvancedModelLoader.loadModel("/assets/alchemicalwizardry/models/bloodlevel.obj");
}
public void renderBloodAltar()
{
modelBloodAltar.renderAll();
}
public void renderBloodLevel()
{
modelBloodLevel.renderAll();
}
public void renderBloodAltar(TEAltar altar, double x, double y, double z)
{
float scale = 0.1f;
// Push a blank matrix onto the stack
GL11.glPushMatrix();
// Move the object into the correct position on the block (because the OBJ's origin is the center of the object)
GL11.glTranslatef((float)x + 0.5f, (float)y , (float)z + 0.5f);
// Scale our object to about half-size in all directions (the OBJ file is a little large)
GL11.glScalef(scale, scale, scale);
// Bind the texture, so that OpenGL properly textures our block.
ResourceLocation test = new ResourceLocation("alchemicalwizardry:textures/models/altar.png");
//FMLClientHandler.instance().getClient().renderEngine.bindTexture("/mods/alchemicalwizardry/textures/models/altar.png");
FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
// Render the object, using modelTutBox.renderAll();
this.renderBloodAltar();
// Pop this matrix from the stack.
GL11.glPopMatrix();
}
public void renderBloodLevel(TEAltar altar, double x, double y, double z)
{
float scale = 0.1f;
// Push a blank matrix onto the stack
GL11.glPushMatrix();
float level = altar.getFluidAmount();
// Move the object into the correct position on the block (because the OBJ's origin is the center of the object)
GL11.glTranslatef((float)x + 0.5f, (float)y + 0.6499f + 0.12f * (level / altar.getCapacity()), (float)z + 0.5f);
// Scale our object to about half-size in all directions (the OBJ file is a little large)
GL11.glScalef(scale, scale, scale);
// Bind the texture, so that OpenGL properly textures our block.
ResourceLocation test = new ResourceLocation("alchemicalwizardry:textures/models/blood.png");
//FMLClientHandler.instance().getClient().renderEngine.bindTexture("/mods/alchemicalwizardry/textures/models/altar.png");
FMLClientHandler.instance().getClient().renderEngine.bindTexture(test);
// Render the object, using modelTutBox.renderAll();
this.renderBloodLevel();
// Pop this matrix from the stack.
GL11.glPopMatrix();
}
}

153
BM_src/WayofTime/alchemicalWizardry/common/renderer/model/ModelBoulderFist.java Normal file
View file

@ -0,0 +1,153 @@
package WayofTime.alchemicalWizardry.common.renderer.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.entity.Entity;
import net.minecraft.util.MathHelper;
public class ModelBoulderFist extends ModelBase
{
//fields
ModelRenderer leftFist;
ModelRenderer leftArm;
ModelRenderer body;
ModelRenderer leftLeg1;
ModelRenderer leftLeg2;
ModelRenderer leftFoot;
ModelRenderer rightFist;
ModelRenderer rightArm;
ModelRenderer rightLeg1;
ModelRenderer rightLeg2;
ModelRenderer rightFoot;
ModelRenderer head;
public ModelBoulderFist()
{
textureWidth = 64;
textureHeight = 64;
leftFist = new ModelRenderer(this, 33, 52);
leftFist.addBox(-1F, 12F, -3F, 6, 6, 6);
leftFist.setRotationPoint(5F, 6F, -6F);
leftFist.setTextureSize(64, 64);
leftFist.mirror = true;
setRotation(leftFist, 0F, 0F, 0F);
leftArm = new ModelRenderer(this, 48, 33);
leftArm.addBox(0F, -2F, -2F, 4, 14, 4);
leftArm.setRotationPoint(5F, 6F, -6F);
leftArm.setTextureSize(64, 64);
leftArm.mirror = true;
setRotation(leftArm, 0F, 0F, 0F);
body = new ModelRenderer(this, 0, 40);
body.addBox(-5F, -2F, -3F, 10, 18, 6);
body.setRotationPoint(0F, 6F, -6F);
body.setTextureSize(64, 64);
body.mirror = true;
setRotation(body, 1.22173F, 0F, 0F);
leftLeg1 = new ModelRenderer(this, 0, 25);
leftLeg1.addBox(0F, -1F, -1F, 4, 6, 2);
leftLeg1.setRotationPoint(5F, 11F, 7F);
leftLeg1.setTextureSize(64, 64);
leftLeg1.mirror = true;
setRotation(leftLeg1, -((float)Math.PI / 4F), 0F, 0F);
leftLeg2 = new ModelRenderer(this, 1, 25);
leftLeg2.addBox(0F, 5F, -1F, 4, 2, 12);
leftLeg2.setRotationPoint(5F, 11F, 7F);
leftLeg2.setTextureSize(64, 64);
leftLeg2.mirror = true;
setRotation(leftLeg2, -((float)Math.PI / 4F), 0F, 0F);
leftFoot = new ModelRenderer(this, 22, 25);
leftFoot.addBox(0F, 11F, -1F, 4, 2, 5);
leftFoot.setRotationPoint(5F, 11F, 7F);
leftFoot.setTextureSize(64, 64);
leftFoot.mirror = true;
setRotation(leftFoot, 0F, 0F, 0F);
rightFist = new ModelRenderer(this, 33, 52);
rightFist.mirror = true;
rightFist.addBox(-5F, 12F, -3F, 6, 6, 6);
rightFist.setRotationPoint(-5F, 6F, -6F);
rightFist.setTextureSize(64, 64);
rightFist.mirror = true;
setRotation(rightFist, 0F, 0F, 0F);
rightFist.mirror = false;
rightArm = new ModelRenderer(this, 48, 33);
rightArm.mirror = true;
rightArm.addBox(-4F, -2F, -2F, 4, 14, 4);
rightArm.setRotationPoint(-5F, 6F, -6F);
rightArm.setTextureSize(64, 64);
rightArm.mirror = true;
setRotation(rightArm, 0F, 0F, 0F);
rightArm.mirror = false;
rightLeg1 = new ModelRenderer(this, 0, 25);
rightLeg1.mirror = true;
rightLeg1.addBox(-4F, -1F, -1F, 4, 6, 2);
rightLeg1.setRotationPoint(-5F, 11F, 7F);
rightLeg1.setTextureSize(64, 64);
rightLeg1.mirror = true;
setRotation(rightLeg1, -((float)Math.PI / 4F), 0F, 0F);
rightLeg1.mirror = false;
rightLeg2 = new ModelRenderer(this, 1, 25);
rightLeg2.mirror = true;
rightLeg2.addBox(-4F, 5F, -1F, 4, 2, 12);
rightLeg2.setRotationPoint(-5F, 11F, 7F);
rightLeg2.setTextureSize(64, 64);
rightLeg2.mirror = true;
setRotation(rightLeg2, -((float)Math.PI / 4F), 0F, 0F);
rightLeg2.mirror = false;
rightFoot = new ModelRenderer(this, 22, 25);
rightFoot.mirror = true;
rightFoot.addBox(-4F, 11F, -1F, 4, 2, 5);
rightFoot.setRotationPoint(-5F, 11F, 7F);
rightFoot.setTextureSize(64, 64);
rightFoot.mirror = true;
setRotation(rightFoot, 0F, 0F, 0F);
rightFoot.mirror = false;
head = new ModelRenderer(this, 0, 0);
head.addBox(-3F, -5F, -5F, 6, 6, 6);
head.setRotationPoint(0F, 5F, -7F);
head.setTextureSize(64, 64);
head.mirror = true;
setRotation(head, 0F, 0F, 0F);
}
public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
{
super.render(entity, f, f1, f2, f3, f4, f5);
setRotationAngles(f, f1, f2, f3, f4, f5, entity);
leftFist.render(f5);
leftArm.render(f5);
body.render(f5);
leftLeg1.render(f5);
leftLeg2.render(f5);
leftFoot.render(f5);
rightFist.render(f5);
rightArm.render(f5);
rightLeg1.render(f5);
rightLeg2.render(f5);
rightFoot.render(f5);
head.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
{
super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
this.head.rotateAngleX = f4 / (180F / (float)Math.PI);
this.head.rotateAngleY = f3 / (180F / (float)Math.PI);
this.leftFoot.rotateAngleX = MathHelper.cos(f * 0.6662F) * 0.8F * f1;
this.rightFoot.rotateAngleX = MathHelper.cos(f * 0.6662F + (float)Math.PI) * 0.8F * f1;
this.leftLeg1.rotateAngleX = leftFoot.rotateAngleX - ((float)Math.PI / 4F);
this.rightLeg1.rotateAngleX = rightFoot.rotateAngleX - ((float)Math.PI / 4F);
this.leftLeg2.rotateAngleX = leftFoot.rotateAngleX - ((float)Math.PI / 4F);
this.rightLeg2.rotateAngleX = rightFoot.rotateAngleX - ((float)Math.PI / 4F);
this.rightArm.rotateAngleX = MathHelper.cos(f * 0.6662F + (float)Math.PI) * 0.9f * f1;
this.leftArm.rotateAngleX = MathHelper.cos(f * 0.6662F) * 0.9f * f1;
this.leftFist.rotateAngleX = leftArm.rotateAngleX;
this.rightFist.rotateAngleX = rightArm.rotateAngleX;
}
}

287
BM_src/WayofTime/alchemicalWizardry/common/renderer/model/ModelConduit.java Normal file
View file

@ -0,0 +1,287 @@
package WayofTime.alchemicalWizardry.common.renderer.model;
//Date: 11/26/2013 1:57:16 PM
//Template version 1.1
//Java generated by Techne
//Keep in mind that you still need to fill in some blanks
//- ZeuX
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.entity.Entity;
import net.minecraftforge.common.ForgeDirection;
public class ModelConduit extends ModelBase
{
//fields
ModelRenderer curvedInput;
ModelRenderer curvedOutput;
ModelRenderer straightBar1;
ModelRenderer curvedBar1;
ModelRenderer spacer1;
ModelRenderer straightBar2;
ModelRenderer curvedBar2;
ModelRenderer spacer2;
ModelRenderer straightBar3;
ModelRenderer curvedBar3;
ModelRenderer straightBar4;
ModelRenderer curvedBar4;
ModelRenderer spacer3;
ModelRenderer spacer4;
ModelRenderer spacer5;
ModelRenderer spacer6;
ModelRenderer spacer7;
ModelRenderer spacer8;
public ModelConduit()
{
textureWidth = 64;
textureHeight = 32;
curvedInput = new ModelRenderer(this, 0, 0);
curvedInput.addBox(-2F, -2F, -8F, 4, 4, 10);
curvedInput.setRotationPoint(0F, 16F, 0F);
curvedInput.setTextureSize(64, 32);
curvedInput.mirror = true;
setRotation(curvedInput, 0F, 0F, 0F);
curvedOutput = new ModelRenderer(this, 18, 0);
curvedOutput.addBox(2F, -2F, -2F, 6, 4, 4);
curvedOutput.setRotationPoint(0F, 16F, 0F);
curvedOutput.setTextureSize(64, 32);
curvedOutput.mirror = true;
setRotation(curvedOutput, 0F, 0F, 0F);
straightBar1 = new ModelRenderer(this, 0, 17);
straightBar1.addBox(-5F, 3F, -8F, 2, 2, 13);
straightBar1.setRotationPoint(0F, 16F, 0F);
straightBar1.setTextureSize(64, 32);
straightBar1.mirror = true;
setRotation(straightBar1, 0F, 0F, 0F);
curvedBar1 = new ModelRenderer(this, 29, 10);
curvedBar1.addBox(-5F, 3F, 3F, 13, 2, 2);
curvedBar1.setRotationPoint(0F, 16F, 0F);
curvedBar1.setTextureSize(64, 32);
curvedBar1.mirror = true;
setRotation(curvedBar1, 0F, 0F, 0F);
spacer1 = new ModelRenderer(this, 40, 0);
spacer1.addBox(-5.5F, 2.5F, 2.5F, 3, 3, 3);
spacer1.setRotationPoint(0F, 16F, 0F);
spacer1.setTextureSize(64, 32);
spacer1.mirror = true;
setRotation(spacer1, 0F, 0F, 0F);
straightBar2 = new ModelRenderer(this, 0, 17);
straightBar2.addBox(-5F, -5F, -8F, 2, 2, 13);
straightBar2.setRotationPoint(0F, 16F, 0F);
straightBar2.setTextureSize(64, 32);
straightBar2.mirror = true;
setRotation(straightBar2, 0F, 0F, 0F);
curvedBar2 = new ModelRenderer(this, 29, 10);
curvedBar2.addBox(-5F, -5F, 3F, 13, 2, 2);
curvedBar2.setRotationPoint(0F, 16F, 0F);
curvedBar2.setTextureSize(64, 32);
curvedBar2.mirror = true;
setRotation(curvedBar2, 0F, 0F, 0F);
spacer2 = new ModelRenderer(this, 40, 0);
spacer2.addBox(-5.5F, -5.5F, 2.5F, 3, 3, 3);
spacer2.setRotationPoint(0F, 16F, 0F);
spacer2.setTextureSize(64, 32);
spacer2.mirror = true;
setRotation(spacer2, 0F, 0F, 0F);
straightBar3 = new ModelRenderer(this, 0, 17);
straightBar3.addBox(3F, 3F, -8F, 2, 2, 13);
straightBar3.setRotationPoint(0F, 16F, 0F);
straightBar3.setTextureSize(64, 32);
straightBar3.mirror = true;
setRotation(straightBar3, 0F, 0F, 0F);
curvedBar3 = new ModelRenderer(this, 29, 10);
curvedBar3.addBox(-5F, 3F, -5F, 13, 2, 2);
curvedBar3.setRotationPoint(0F, 16F, 0F);
curvedBar3.setTextureSize(64, 32);
curvedBar3.mirror = true;
setRotation(curvedBar3, 0F, 0F, 0F);
straightBar4 = new ModelRenderer(this, 0, 17);
straightBar4.addBox(3F, -5F, -8F, 2, 2, 13);
straightBar4.setRotationPoint(0F, 16F, 0F);
straightBar4.setTextureSize(64, 32);
straightBar4.mirror = true;
setRotation(straightBar4, 0F, 0F, 0F);
curvedBar4 = new ModelRenderer(this, 29, 10);
curvedBar4.addBox(-5F, -5F, -5F, 13, 2, 2);
curvedBar4.setRotationPoint(0F, 16F, 0F);
curvedBar4.setTextureSize(64, 32);
curvedBar4.mirror = true;
setRotation(curvedBar4, 0F, 0F, 0F);
spacer3 = new ModelRenderer(this, 40, 0);
spacer3.addBox(2.5F, 2.5F, 2.5F, 3, 3, 3);
spacer3.setRotationPoint(0F, 16F, 0F);
spacer3.setTextureSize(64, 32);
spacer3.mirror = true;
setRotation(spacer3, 0F, 0F, 0F);
spacer4 = new ModelRenderer(this, 40, 0);
spacer4.addBox(2.5F, 2.5F, -5.5F, 3, 3, 3);
spacer4.setRotationPoint(0F, 16F, 0F);
spacer4.setTextureSize(64, 32);
spacer4.mirror = true;
setRotation(spacer4, 0F, 0F, 0F);
spacer5 = new ModelRenderer(this, 40, 0);
spacer5.addBox(-5.5F, 2.5F, -5.484F, 3, 3, 3);
spacer5.setRotationPoint(0F, 16F, 0F);
spacer5.setTextureSize(64, 32);
spacer5.mirror = true;
setRotation(spacer5, 0F, 0F, 0F);
spacer6 = new ModelRenderer(this, 40, 0);
spacer6.addBox(2.5F, -5.5F, 2.5F, 3, 3, 3);
spacer6.setRotationPoint(0F, 16F, 0F);
spacer6.setTextureSize(64, 32);
spacer6.mirror = true;
setRotation(spacer6, 0F, 0F, 0F);
spacer7 = new ModelRenderer(this, 40, 0);
spacer7.addBox(2.5F, -5.5F, -5.5F, 3, 3, 3);
spacer7.setRotationPoint(0F, 16F, 0F);
spacer7.setTextureSize(64, 32);
spacer7.mirror = true;
setRotation(spacer7, 0F, 0F, 0F);
spacer8 = new ModelRenderer(this, 40, 0);
spacer8.addBox(-5.5F, -5.5F, -5.5F, 3, 3, 3);
spacer8.setRotationPoint(0F, 16F, 0F);
spacer8.setTextureSize(64, 32);
spacer8.mirror = true;
setRotation(spacer8, 0F, 0F, 0F);
}
public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5, ForgeDirection input, ForgeDirection output)
{
super.render(entity, f, f1, f2, f3, f4, f5);
setRotationAngles(f, f1, f2, f3, f4, f5, entity);
float xInputRot = 0.0f;
float yInputRot = 0.0f;
float zInputRot = 0.0f;
float xOutputRot = 0.0f;
float yOutputRot = 0.0f;
float zOutputRot = 0.0f;
switch (input)
{
case NORTH:
xInputRot = 0.0f;
yInputRot = 0.0f;
zInputRot = 0.0f;
break;
case EAST:
xInputRot = 0.0f;
yInputRot = (float)(0.5f * Math.PI);
zInputRot = 0.0f;
break;
case SOUTH:
xInputRot = 0.0f;
yInputRot = (float)(1.0f * Math.PI);
zInputRot = 0.0f;
break;
case WEST:
xInputRot = 0.0f;
yInputRot = (float)(-0.5f * Math.PI);
zInputRot = 0.0f;
break;
case UP:
xInputRot = (float)(-0.5f * Math.PI);
yInputRot = 0.0f;
zInputRot = 0.0f;
break;
case DOWN:
xInputRot = (float)(0.5f * Math.PI);
yInputRot = 0.0f;
zInputRot = 0.0f;
break;
default:
break;
}
switch (output)
{
case NORTH:
xOutputRot = 0.0f;
yOutputRot = (float)(0.5f * Math.PI);
zOutputRot = 0.0f;
break;
case EAST:
xOutputRot = 0.0f;
yOutputRot = (float)(1.0f * Math.PI);
zOutputRot = 0.0f;
break;
case SOUTH:
xOutputRot = 0.0f;
yOutputRot = (float)(-0.5f * Math.PI);
zOutputRot = 0.0f;
break;
case WEST:
xOutputRot = 0.0f;
yOutputRot = 0.0f;
zOutputRot = 0.0f;
break;
case UP:
xOutputRot = 0.0f;
yOutputRot = 0.0f;
zOutputRot = (float)(-0.5f * Math.PI);
break;
case DOWN:
xOutputRot = 0.0f;
yOutputRot = 0.0f;
zOutputRot = (float)(0.5f * Math.PI);
break;
default:
break;
}
this.setRotation(curvedInput, xInputRot, yInputRot, zInputRot);
this.setRotation(curvedOutput, xOutputRot, yOutputRot, zOutputRot);
this.setRotation(straightBar1, xInputRot, yInputRot, zInputRot);
this.setRotation(curvedBar1, xOutputRot, yOutputRot, zOutputRot);
this.setRotation(straightBar2, xInputRot, yInputRot, zInputRot);
this.setRotation(curvedBar2, xOutputRot, yOutputRot, zOutputRot);
this.setRotation(straightBar3, xInputRot, yInputRot, zInputRot);
this.setRotation(curvedBar3, xOutputRot, yOutputRot, zOutputRot);
this.setRotation(straightBar4, xInputRot, yInputRot, zInputRot);
this.setRotation(curvedBar4, xOutputRot, yOutputRot, zOutputRot);
curvedInput.render(f5);
curvedOutput.render(f5);
//setRotation(curvedOutput,0F,-(float)(Math.PI/2),0F);
straightBar1.render(f5);
curvedBar1.render(f5);
spacer1.render(f5);
straightBar2.render(f5);
curvedBar2.render(f5);
spacer2.render(f5);
straightBar3.render(f5);
curvedBar3.render(f5);
straightBar4.render(f5);
curvedBar4.render(f5);
spacer3.render(f5);
spacer4.render(f5);
spacer5.render(f5);
spacer6.render(f5);
spacer7.render(f5);
spacer8.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
{
super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
}
}

81
BM_src/WayofTime/alchemicalWizardry/common/renderer/model/ModelElemental.java Normal file
View file

@ -0,0 +1,81 @@
package WayofTime.alchemicalWizardry.common.renderer.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.entity.Entity;
import net.minecraft.entity.monster.EntityBlaze;
import net.minecraft.world.World;
public class ModelElemental extends ModelBase
{
//fields
ModelRenderer body;
ModelRenderer Shape2;
ModelRenderer Shape1;
ModelRenderer Shape3;
public ModelElemental()
{
textureWidth = 64;
textureHeight = 32;
body = new ModelRenderer(this, 33, 0);
body.addBox(-3F, -3F, -3F, 6, 6, 6);
body.setRotationPoint(0F, 14F, 0F);
body.setTextureSize(64, 32);
body.mirror = true;
setRotation(body, 0F, 0F, 0F);
Shape2 = new ModelRenderer(this, 0, 0);
Shape2.addBox(-4F, -4F, -4F, 8, 8, 8);
Shape2.setRotationPoint(0F, 14F, 0F);
Shape2.setTextureSize(64, 32);
Shape2.mirror = true;
setRotation(Shape2, ((float)Math.PI / 4F), ((float)Math.PI / 4F), 0F);
Shape1 = new ModelRenderer(this, 0, 0);
Shape1.addBox(-4F, -4F, -4F, 8, 8, 8);
Shape1.setRotationPoint(0F, 14F, 0F);
Shape1.setTextureSize(64, 32);
Shape1.mirror = true;
setRotation(Shape1, 0F, ((float)Math.PI / 4F), ((float)Math.PI / 4F));
Shape3 = new ModelRenderer(this, 0, 0);
Shape3.addBox(-4F, -4F, -4F, 8, 8, 8);
Shape3.setRotationPoint(0F, 14F, 0F);
Shape3.setTextureSize(64, 32);
Shape3.mirror = true;
setRotation(Shape3, ((float)Math.PI / 4F), 0F, ((float)Math.PI / 4F));
}
public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
{
super.render(entity, f, f1, f2, f3, f4, f5);
setRotationAngles(f, f1, f2, f3, f4, f5, entity);
body.render(f5);
Shape2.render(f5);
Shape1.render(f5);
Shape3.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
{
super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
World world = entity.worldObj;
if (world == null)
{
return;
}
int ratio = 20;
float rot = (entity.worldObj.getWorldTime() % ratio) / ratio;
Shape1.rotateAngleX = f / 5;
Shape2.rotateAngleZ = f / 5;
Shape3.rotateAngleY = f / 5;
EntityBlaze d;
}
}

122
BM_src/WayofTime/alchemicalWizardry/common/renderer/model/ModelEnergyBazookaMainProjectile.java Normal file
View file

@ -0,0 +1,122 @@
package WayofTime.alchemicalWizardry.common.renderer.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.entity.Entity;
public class ModelEnergyBazookaMainProjectile extends ModelBase
{
//fields
ModelRenderer thirdWarHead;
ModelRenderer firstWarHead;
ModelRenderer secondWarHead;
ModelRenderer support1;
ModelRenderer mainBody;
ModelRenderer support2;
ModelRenderer support3;
ModelRenderer support4;
ModelRenderer base1;
ModelRenderer base2;
ModelRenderer base3;
public ModelEnergyBazookaMainProjectile()
{
textureWidth = 64;
textureHeight = 32;
thirdWarHead = new ModelRenderer(this, 43, 0);
thirdWarHead.addBox(-1F, -1F, -9F, 2, 2, 1);
thirdWarHead.setRotationPoint(0F, 0F, 0F);
thirdWarHead.setTextureSize(64, 32);
thirdWarHead.mirror = true;
setRotation(thirdWarHead, 0F, 0F, 0F);
firstWarHead = new ModelRenderer(this, 52, 0);
firstWarHead.addBox(-2F, -2F, -8F, 4, 4, 2);
firstWarHead.setRotationPoint(0F, 0F, 0F);
firstWarHead.setTextureSize(64, 32);
firstWarHead.mirror = true;
setRotation(firstWarHead, 0F, 0F, 0F);
secondWarHead = new ModelRenderer(this, 48, 8);
secondWarHead.addBox(-3F, -3F, -6F, 6, 6, 2);
secondWarHead.setRotationPoint(0F, 0F, 0F);
secondWarHead.setTextureSize(64, 32);
secondWarHead.mirror = true;
setRotation(secondWarHead, 0F, 0F, 0F);
support1 = new ModelRenderer(this, 0, 0);
support1.addBox(2F, 2F, -4F, 1, 1, 9);
support1.setRotationPoint(0F, 0F, 0F);
support1.setTextureSize(64, 32);
support1.mirror = true;
setRotation(support1, 0F, 0F, 0F);
mainBody = new ModelRenderer(this, 0, 19);
mainBody.addBox(-2F, -2F, -4F, 4, 4, 9);
mainBody.setRotationPoint(0F, 0F, 0F);
mainBody.setTextureSize(64, 32);
mainBody.mirror = true;
setRotation(mainBody, 0F, 0F, 0F);
support2 = new ModelRenderer(this, 0, 0);
support2.addBox(-3F, 2F, -4F, 1, 1, 9);
support2.setRotationPoint(0F, 0F, 0F);
support2.setTextureSize(64, 32);
support2.mirror = true;
setRotation(support2, 0F, 0F, 0F);
support3 = new ModelRenderer(this, 0, 0);
support3.addBox(-3F, -3F, -4F, 1, 1, 9);
support3.setRotationPoint(0F, 0F, 0F);
support3.setTextureSize(64, 32);
support3.mirror = true;
setRotation(support3, 0F, 0F, 0F);
support4 = new ModelRenderer(this, 0, 0);
support4.addBox(2F, -3F, -4F, 1, 1, 9);
support4.setRotationPoint(0F, 0F, 0F);
support4.setTextureSize(64, 32);
support4.mirror = true;
setRotation(support4, 0F, 0F, 0F);
base1 = new ModelRenderer(this, 28, 0);
base1.addBox(-3F, -3F, 5F, 6, 6, 1);
base1.setRotationPoint(0F, 0F, 0F);
base1.setTextureSize(64, 32);
base1.mirror = true;
setRotation(base1, 0F, 0F, 0F);
base2 = new ModelRenderer(this, 28, 9);
base2.addBox(-2F, -2F, 6F, 4, 4, 1);
base2.setRotationPoint(0F, 0F, 0F);
base2.setTextureSize(64, 32);
base2.mirror = true;
setRotation(base2, 0F, 0F, 0F);
base3 = new ModelRenderer(this, 28, 15);
base3.addBox(-3F, -3F, 7F, 6, 6, 1);
base3.setRotationPoint(0F, 0F, 0F);
base3.setTextureSize(64, 32);
base3.mirror = true;
setRotation(base3, 0F, 0F, 0F);
}
public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
{
super.render(entity, f, f1, f2, f3, f4, f5);
setRotationAngles(f, f1, f2, f3, f4, f5, entity);
thirdWarHead.render(f5);
firstWarHead.render(f5);
secondWarHead.render(f5);
support1.render(f5);
mainBody.render(f5);
support2.render(f5);
support3.render(f5);
support4.render(f5);
base1.render(f5);
base2.render(f5);
base3.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
{
super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
}
}

115
BM_src/WayofTime/alchemicalWizardry/common/renderer/model/ModelFallenAngel.java Normal file
View file

@ -0,0 +1,115 @@
package WayofTime.alchemicalWizardry.common.renderer.model;
import cpw.mods.fml.client.FMLClientHandler;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.entity.Entity;
import net.minecraft.util.MathHelper;
import net.minecraft.util.ResourceLocation;
public class ModelFallenAngel extends ModelBase
{
//fields
ModelRenderer leftWing;
ModelRenderer rightWing;
ModelRenderer head;
ModelRenderer body;
ModelRenderer rightarm;
ModelRenderer leftarm;
ModelRenderer rightleg;
ModelRenderer leftleg;
public ModelFallenAngel()
{
textureWidth = 64;
textureHeight = 32;
leftWing = new ModelRenderer(this, 33, 8);
leftWing.mirror = true;
leftWing.addBox(0F, 0F, 0F, 10, 7, 0);
leftWing.setRotationPoint(0F, 1F, 2F);
leftWing.setTextureSize(64, 32);
leftWing.mirror = true;
setRotation(leftWing, 0F, 0F, 0F);
rightWing = new ModelRenderer(this, 33, 8);
rightWing.addBox(-10F, 0F, 0F, 10, 7, 0);
rightWing.setRotationPoint(0F, 1F, 2F);
rightWing.setTextureSize(64, 32);
rightWing.mirror = true;
setRotation(rightWing, 0F, 0F, 0F);
rightWing.mirror = false;
head = new ModelRenderer(this, 0, 0);
head.addBox(-4F, -8F, -4F, 8, 8, 8);
head.setRotationPoint(0F, 0F, 0F);
head.setTextureSize(64, 32);
head.mirror = true;
setRotation(head, 0F, 0F, 0F);
body = new ModelRenderer(this, 16, 16);
body.addBox(-4F, 0F, -2F, 8, 12, 4);
body.setRotationPoint(0F, 0F, 0F);
body.setTextureSize(64, 32);
body.mirror = true;
setRotation(body, 0F, 0F, 0F);
rightarm = new ModelRenderer(this, 40, 16);
rightarm.addBox(-3F, -2F, -2F, 4, 12, 4);
rightarm.setRotationPoint(-5F, 2F, 0F);
rightarm.setTextureSize(64, 32);
rightarm.mirror = true;
setRotation(rightarm, 0F, 0F, 0F);
rightarm.mirror = false;
leftarm = new ModelRenderer(this, 40, 16);
leftarm.mirror = true;
leftarm.addBox(-1F, -2F, -2F, 4, 12, 4);
leftarm.setRotationPoint(5F, 2F, 0F);
leftarm.setTextureSize(64, 32);
leftarm.mirror = true;
setRotation(leftarm, 0F, 0F, 0F);
rightleg = new ModelRenderer(this, 0, 16);
rightleg.addBox(-2F, 0F, -2F, 4, 12, 4);
rightleg.setRotationPoint(-2F, 12F, 0F);
rightleg.setTextureSize(64, 32);
rightleg.mirror = true;
setRotation(rightleg, 0F, 0F, 0F);
rightleg.mirror = false;
leftleg = new ModelRenderer(this, 0, 16);
leftleg.mirror = true;
leftleg.addBox(-2F, 0F, -2F, 4, 12, 4);
leftleg.setRotationPoint(2F, 12F, 0F);
leftleg.setTextureSize(64, 32);
leftleg.mirror = true;
setRotation(leftleg, 0F, 0F, 0F);
}
public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
{
super.render(entity, f, f1, f2, f3, f4, f5);
setRotationAngles(f, f1, f2, f3, f4, f5, entity);
leftWing.render(f5);
rightWing.render(f5);
head.render(f5);
body.render(f5);
rightarm.render(f5);
leftarm.render(f5);
rightleg.render(f5);
leftleg.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
{
super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
this.head.rotateAngleX = f4 / (180F / (float)Math.PI);
this.head.rotateAngleY = f3 / (180F / (float)Math.PI);
this.leftleg.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
this.rightleg.rotateAngleX = MathHelper.cos(f * 0.6662F + (float)Math.PI) * 1.4F * f1;
this.rightarm.rotateAngleX = MathHelper.cos(f * 0.6662F + (float)Math.PI) * 1.4F * f1;
this.leftarm.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
this.rightWing.rotateAngleY = MathHelper.cos(0.1662F);
this.leftWing.rotateAngleY = MathHelper.cos(0.1662F + (float)Math.PI);
}
}

197
BM_src/WayofTime/alchemicalWizardry/common/renderer/model/ModelIceDemon.java Normal file
View file

@ -0,0 +1,197 @@
package WayofTime.alchemicalWizardry.common.renderer.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.entity.Entity;
import net.minecraft.util.MathHelper;
public class ModelIceDemon extends ModelBase
{
//fields
ModelRenderer head;
ModelRenderer leftHorn;
ModelRenderer rightHorn;
ModelRenderer body;
ModelRenderer leftArm;
ModelRenderer leftWrist;
ModelRenderer leftIcicle1;
ModelRenderer leftIcicle2;
ModelRenderer leftIcicle3;
ModelRenderer leftLeg;
ModelRenderer rightArm;
ModelRenderer rightWrist;
ModelRenderer rightIcicle1;
ModelRenderer rightIcicle2;
ModelRenderer rightIcicle3;
ModelRenderer rightLeg;
ModelRenderer Shape1;
public ModelIceDemon()
{
textureWidth = 64;
textureHeight = 64;
head = new ModelRenderer(this, 40, 0);
head.addBox(-3F, -8F, -3F, 6, 8, 6);
head.setRotationPoint(0F, -3F, 0F);
head.setTextureSize(64, 64);
head.mirror = true;
setRotation(head, 0F, 0F, 0F);
leftHorn = new ModelRenderer(this, 0, 0);
leftHorn.addBox(3F, -7F, 2F, 1, 1, 10);
leftHorn.setRotationPoint(0F, -3F, 0F);
leftHorn.setTextureSize(64, 64);
leftHorn.mirror = true;
setRotation(leftHorn, 0.4363323F, 0F, 0F);
rightHorn = new ModelRenderer(this, 0, 0);
rightHorn.mirror = true;
rightHorn.addBox(-4F, -7F, 2F, 1, 1, 10);
rightHorn.setRotationPoint(0F, -3F, 0F);
rightHorn.setTextureSize(64, 64);
rightHorn.mirror = true;
setRotation(rightHorn, 0.4363323F, 0F, 0F);
rightHorn.mirror = false;
body = new ModelRenderer(this, 40, 15);
body.addBox(-4F, 0F, -2F, 8, 13, 4);
body.setRotationPoint(0F, -3F, 0F);
body.setTextureSize(64, 64);
body.mirror = true;
setRotation(body, 0F, 0F, 0F);
leftArm = new ModelRenderer(this, 0, 48);
leftArm.addBox(0F, -2F, -2F, 4, 12, 4);
leftArm.setRotationPoint(4F, -1F, 0F);
leftArm.setTextureSize(64, 64);
leftArm.mirror = true;
setRotation(leftArm, 0F, 0F, 0F);
leftWrist = new ModelRenderer(this, 32, 57);
leftWrist.addBox(0F, 6F, -2.5F, 5, 2, 5);
leftWrist.setRotationPoint(4F, -1F, 0F);
leftWrist.setTextureSize(64, 64);
leftWrist.mirror = true;
setRotation(leftWrist, 0F, 0F, 0F);
leftIcicle1 = new ModelRenderer(this, 0, 0);
leftIcicle1.addBox(4.9F, 0F, -0.5F, 1, 6, 1);
leftIcicle1.setRotationPoint(4F, -1F, 0F);
leftIcicle1.setTextureSize(64, 64);
leftIcicle1.mirror = true;
setRotation(leftIcicle1, 0F, 0F, 0.1396263F);
leftIcicle2 = new ModelRenderer(this, 0, 0);
leftIcicle2.addBox(5F, 0F, 0F, 1, 6, 1);
leftIcicle2.setRotationPoint(4F, -1F, 0F);
leftIcicle2.setTextureSize(64, 64);
leftIcicle2.mirror = true;
setRotation(leftIcicle2, 0F, 0.5585054F, 0.1919862F);
leftIcicle3 = new ModelRenderer(this, 0, 0);
leftIcicle3.addBox(5F, 0F, -1F, 1, 6, 1);
leftIcicle3.setRotationPoint(4F, -1F, 0F);
leftIcicle3.setTextureSize(64, 64);
leftIcicle3.mirror = true;
setRotation(leftIcicle3, 0F, -0.5585054F, 0.1919862F);
leftLeg = new ModelRenderer(this, 16, 46);
leftLeg.addBox(-2F, 0F, -2F, 4, 14, 4);
leftLeg.setRotationPoint(2F, 10F, 0F);
leftLeg.setTextureSize(64, 64);
leftLeg.mirror = true;
setRotation(leftLeg, 0F, 0F, 0F);
rightArm = new ModelRenderer(this, 0, 48);
rightArm.mirror = true;
rightArm.addBox(-4F, -2F, -2F, 4, 12, 4);
rightArm.setRotationPoint(-4F, -1F, 0F);
rightArm.setTextureSize(64, 64);
rightArm.mirror = true;
setRotation(rightArm, 0F, 0F, 0F);
rightArm.mirror = false;
rightWrist = new ModelRenderer(this, 32, 57);
rightWrist.mirror = true;
rightWrist.addBox(-5F, 6F, -2.5F, 5, 2, 5);
rightWrist.setRotationPoint(-4F, -1F, 0F);
rightWrist.setTextureSize(64, 64);
rightWrist.mirror = true;
setRotation(rightWrist, 0F, 0F, 0F);
rightWrist.mirror = false;
rightIcicle1 = new ModelRenderer(this, 0, 0);
rightIcicle1.addBox(-5.9F, 0F, -0.5F, 1, 6, 1);
rightIcicle1.setRotationPoint(-4F, -1F, 0F);
rightIcicle1.setTextureSize(64, 64);
rightIcicle1.mirror = true;
setRotation(rightIcicle1, 0F, 0F, -0.1396263F);
rightIcicle2 = new ModelRenderer(this, 0, 0);
rightIcicle2.addBox(-6F, 0F, 0F, 1, 6, 1);
rightIcicle2.setRotationPoint(-4F, -1F, 0F);
rightIcicle2.setTextureSize(64, 64);
rightIcicle2.mirror = true;
setRotation(rightIcicle2, 0F, -0.5585054F, -0.1919862F);
rightIcicle3 = new ModelRenderer(this, 0, 0);
rightIcicle3.addBox(-6F, 0F, -1F, 1, 6, 1);
rightIcicle3.setRotationPoint(-4F, -1F, 0F);
rightIcicle3.setTextureSize(64, 64);
rightIcicle3.mirror = true;
setRotation(rightIcicle3, 0F, 0.5585054F, -0.1919862F);
rightLeg = new ModelRenderer(this, 16, 46);
rightLeg.mirror = true;
rightLeg.addBox(-2F, 0F, -2F, 4, 14, 4);
rightLeg.setRotationPoint(-2F, 10F, 0F);
rightLeg.setTextureSize(64, 64);
rightLeg.mirror = true;
setRotation(rightLeg, 0F, 0F, 0F);
rightLeg.mirror = false;
Shape1 = new ModelRenderer(this, 0, 12);
Shape1.addBox(-0.5F, 0F, -0.5F, 1, 10, 1);
Shape1.setRotationPoint(0F, 8F, 1.5F);
Shape1.setTextureSize(64, 64);
Shape1.mirror = true;
setRotation(Shape1, 0.5948578F, 0F, 0F);
}
public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
{
super.render(entity, f, f1, f2, f3, f4, f5);
setRotationAngles(f, f1, f2, f3, f4, f5, entity);
head.render(f5);
leftHorn.render(f5);
rightHorn.render(f5);
body.render(f5);
leftArm.render(f5);
leftWrist.render(f5);
leftIcicle1.render(f5);
leftIcicle2.render(f5);
leftIcicle3.render(f5);
leftLeg.render(f5);
rightArm.render(f5);
rightWrist.render(f5);
rightIcicle1.render(f5);
rightIcicle2.render(f5);
rightIcicle3.render(f5);
rightLeg.render(f5);
Shape1.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
{
super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
this.head.rotateAngleX = f4 / (180F / (float)Math.PI);
this.head.rotateAngleY = f3 / (180F / (float)Math.PI);
this.leftLeg.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
this.rightLeg.rotateAngleX = MathHelper.cos(f * 0.6662F + (float)Math.PI) * 1.4F * f1;
this.rightArm.rotateAngleX = MathHelper.cos(f * 0.6662F + (float)Math.PI) * 1.4F * f1;
this.leftArm.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
this.leftHorn.rotateAngleX = head.rotateAngleX + 0.4363323F;
this.leftHorn.rotateAngleY = head.rotateAngleY;
this.rightHorn.rotateAngleX = head.rotateAngleX + 0.4363323F;
this.rightHorn.rotateAngleY = head.rotateAngleY;
this.rightIcicle1.rotateAngleX = rightArm.rotateAngleX;
this.rightIcicle2.rotateAngleX = rightArm.rotateAngleX;
this.rightIcicle3.rotateAngleX = rightArm.rotateAngleX;
this.leftIcicle1.rotateAngleX = leftArm.rotateAngleX;
this.leftIcicle2.rotateAngleX = leftArm.rotateAngleX;
this.leftIcicle3.rotateAngleX = leftArm.rotateAngleX;
this.rightWrist.rotateAngleX = rightArm.rotateAngleX;
this.leftWrist.rotateAngleX = leftArm.rotateAngleX;
}
}

207
BM_src/WayofTime/alchemicalWizardry/common/renderer/model/ModelLowerGuardian.java Normal file
View file

@ -0,0 +1,207 @@
package WayofTime.alchemicalWizardry.common.renderer.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.util.MathHelper;
import WayofTime.alchemicalWizardry.common.entity.mob.EntityLowerGuardian;
public class ModelLowerGuardian extends ModelBase
{
//fields
ModelRenderer Body;
ModelRenderer Torso;
ModelRenderer Head;
ModelRenderer leftArm;
ModelRenderer rightArm;
ModelRenderer leftLeg;
ModelRenderer leftFoot;
ModelRenderer rightLeg;
ModelRenderer rightFoot;
ModelRenderer leftHorn;
ModelRenderer hornAppendage1;
ModelRenderer hornAppendage2;
ModelRenderer rightHorn;
ModelRenderer hornAppendage3;
ModelRenderer hornAppendage4;
public ModelLowerGuardian()
{
textureWidth = 64;
textureHeight = 64;
Body = new ModelRenderer(this, 0, 0);
Body.addBox(-8F, -7F, -4F, 16, 14, 8);
Body.setRotationPoint(0F, -3F, 0F);
Body.setTextureSize(64, 64);
Body.mirror = true;
setRotation(Body, 0F, 0F, 0F);
Torso = new ModelRenderer(this, 0, 25);
Torso.addBox(-4F, 0F, -3F, 8, 4, 6);
Torso.setRotationPoint(0F, 4F, 0F);
Torso.setTextureSize(64, 64);
Torso.mirror = true;
setRotation(Torso, 0F, 0F, 0F);
Head = new ModelRenderer(this, 29, 25);
Head.addBox(-4F, -8F, -4F, 8, 8, 8);
Head.setRotationPoint(0F, -10F, 0F);
Head.setTextureSize(64, 64);
Head.mirror = true;
setRotation(Head, 0F, 0F, 0F);
leftArm = new ModelRenderer(this, 17, 42);
leftArm.addBox(0F, -2F, -2F, 4, 18, 4);
leftArm.setRotationPoint(8F, -8F, 0F);
leftArm.setTextureSize(64, 64);
leftArm.mirror = true;
setRotation(leftArm, 0F, 0F, 0F);
rightArm = new ModelRenderer(this, 17, 42);
rightArm.mirror = true;
rightArm.addBox(-4F, -2F, -2F, 4, 18, 4);
rightArm.setRotationPoint(-8F, -8F, 0F);
rightArm.setTextureSize(64, 64);
rightArm.mirror = true;
setRotation(rightArm, 0F, 0F, 0F);
rightArm.mirror = false;
leftLeg = new ModelRenderer(this, 0, 42);
leftLeg.addBox(0F, -2F, -2F, 4, 17, 4);
leftLeg.setRotationPoint(4F, 6F, 0F);
leftLeg.setTextureSize(64, 64);
leftLeg.mirror = true;
setRotation(leftLeg, 0F, 0F, 0F);
leftFoot = new ModelRenderer(this, 34, 42);
leftFoot.addBox(0F, 15F, -6F, 4, 3, 8);
leftFoot.setRotationPoint(4F, 6F, 0F);
leftFoot.setTextureSize(64, 64);
leftFoot.mirror = true;
setRotation(leftFoot, 0F, 0F, 0F);
rightLeg = new ModelRenderer(this, 0, 42);
rightLeg.mirror = true;
rightLeg.addBox(-4F, -2F, -2F, 4, 17, 4);
rightLeg.setRotationPoint(-4F, 6F, 0F);
rightLeg.setTextureSize(64, 64);
rightLeg.mirror = true;
setRotation(rightLeg, 0F, 0F, 0F);
rightLeg.mirror = false;
rightFoot = new ModelRenderer(this, 34, 42);
rightFoot.mirror = true;
rightFoot.addBox(-4F, 15F, -6F, 4, 3, 8);
rightFoot.setRotationPoint(-4F, 6F, 0F);
rightFoot.setTextureSize(64, 64);
rightFoot.mirror = true;
setRotation(rightFoot, 0F, 0F, 0F);
rightFoot.mirror = false;
leftHorn = new ModelRenderer(this, 0, 0);
leftHorn.addBox(4F, -11F, 0F, 1, 6, 1);
leftHorn.setRotationPoint(0F, -10F, 0F);
leftHorn.setTextureSize(64, 64);
leftHorn.mirror = true;
setRotation(leftHorn, 0F, 0F, 0F);
hornAppendage1 = new ModelRenderer(this, 0, 0);
hornAppendage1.addBox(4F, -7F, -1F, 1, 1, 1);
hornAppendage1.setRotationPoint(0F, -10F, 0F);
hornAppendage1.setTextureSize(64, 64);
hornAppendage1.mirror = true;
setRotation(hornAppendage1, 0F, 0F, 0F);
hornAppendage2 = new ModelRenderer(this, 0, 0);
hornAppendage2.addBox(4F, -6F, 1F, 1, 1, 1);
hornAppendage2.setRotationPoint(0F, -10F, 0F);
hornAppendage2.setTextureSize(64, 64);
hornAppendage2.mirror = true;
setRotation(hornAppendage2, 0F, 0F, 0F);
rightHorn = new ModelRenderer(this, 0, 0);
rightHorn.mirror = true;
rightHorn.addBox(-5F, -11F, 0F, 1, 6, 1);
rightHorn.setRotationPoint(0F, -10F, 0F);
rightHorn.setTextureSize(64, 64);
rightHorn.mirror = true;
setRotation(rightHorn, 0F, 0F, 0F);
rightHorn.mirror = false;
hornAppendage3 = new ModelRenderer(this, 0, 0);
hornAppendage3.mirror = true;
hornAppendage3.addBox(-5F, -7F, -1F, 1, 1, 1);
hornAppendage3.setRotationPoint(0F, -10F, 0F);
hornAppendage3.setTextureSize(64, 64);
hornAppendage3.mirror = true;
setRotation(hornAppendage3, 0F, 0F, 0F);
hornAppendage3.mirror = false;
hornAppendage4 = new ModelRenderer(this, 0, 0);
hornAppendage4.mirror = true;
hornAppendage4.addBox(-5F, -6F, 1F, 1, 1, 1);
hornAppendage4.setRotationPoint(0F, -10F, 0F);
hornAppendage4.setTextureSize(64, 64);
hornAppendage4.mirror = true;
setRotation(hornAppendage4, 0F, 0F, 0F);
hornAppendage4.mirror = false;
}
public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
{
super.render(entity, f, f1, f2, f3, f4, f5);
setRotationAngles(f, f1, f2, f3, f4, f5, entity);
Body.render(f5);
Torso.render(f5);
Head.render(f5);
leftArm.render(f5);
rightArm.render(f5);
leftLeg.render(f5);
leftFoot.render(f5);
rightLeg.render(f5);
rightFoot.render(f5);
leftHorn.render(f5);
hornAppendage1.render(f5);
hornAppendage2.render(f5);
rightHorn.render(f5);
hornAppendage3.render(f5);
hornAppendage4.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
public void setLivingAnimations(EntityLivingBase par1EntityLivingBase, float par2, float par3, float par4)
{
EntityLowerGuardian entityLowerGuardian = (EntityLowerGuardian)par1EntityLivingBase;
int i = entityLowerGuardian.getAttackTimer();
if (i > 0)
{
this.rightLeg.rotateAngleX = -2.0F + 1.5F * this.func_78172_a((float)i - par4, 10.0F);
this.rightFoot.rotateAngleX = -2.0F + 1.5F * this.func_78172_a((float)i - par4, 10.0F);
//this.ironGolemLeftArm.rotateAngleX = -2.0F + 1.5F * this.func_78172_a((float)i - par4, 10.0F);
}
}
private float func_78172_a(float par1, float par2)
{
return (Math.abs(par1 % par2 - par2 * 0.5F) - par2 * 0.25F) / (par2 * 0.25F);
}
public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
{
super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
this.Head.rotateAngleX = f4 / (180F / (float)Math.PI);
this.Head.rotateAngleY = f3 / (180F / (float)Math.PI);
this.leftLeg.rotateAngleX = MathHelper.cos(f * 0.3662F) * 1.0F * f1;
this.rightLeg.rotateAngleX = MathHelper.cos(f * 0.3662F + (float)Math.PI) * 1.0F * f1;
this.leftFoot.rotateAngleX = MathHelper.cos(f * 0.3662F) * 1.0F * f1;
this.rightFoot.rotateAngleX = MathHelper.cos(f * 0.3662F + (float)Math.PI) * 1.0F * f1;
this.rightArm.rotateAngleX = MathHelper.cos(f * 0.3662F + (float)Math.PI) * 1.0F * f1;
this.leftArm.rotateAngleX = MathHelper.cos(f * 0.3662F) * 1.0F * f1;
this.hornAppendage1.rotateAngleX = this.Head.rotateAngleX;
this.hornAppendage1.rotateAngleY = this.Head.rotateAngleY;
this.hornAppendage2.rotateAngleX = this.Head.rotateAngleX;
this.hornAppendage2.rotateAngleY = this.Head.rotateAngleY;
this.hornAppendage3.rotateAngleX = this.Head.rotateAngleX;
this.hornAppendage3.rotateAngleY = this.Head.rotateAngleY;
this.hornAppendage4.rotateAngleX = this.Head.rotateAngleX;
this.hornAppendage4.rotateAngleY = this.Head.rotateAngleY;
this.leftHorn.rotateAngleX = this.Head.rotateAngleX;
this.leftHorn.rotateAngleY = this.Head.rotateAngleY;
this.rightHorn.rotateAngleX = this.Head.rotateAngleX;
this.rightHorn.rotateAngleY = this.Head.rotateAngleY;
}
}

90
BM_src/WayofTime/alchemicalWizardry/common/renderer/model/ModelMeteor.java Normal file
View file

@ -0,0 +1,90 @@
package WayofTime.alchemicalWizardry.common.renderer.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.entity.Entity;
public class ModelMeteor extends ModelBase
{
//fields
ModelRenderer Shape1;
ModelRenderer Shape2;
ModelRenderer Shape3;
ModelRenderer Shape4;
ModelRenderer Shape5;
ModelRenderer Shape6;
ModelRenderer Shape7;
public ModelMeteor()
{
textureWidth = 64;
textureHeight = 64;
Shape1 = new ModelRenderer(this, 0, 0);
Shape1.addBox(-8F, -8F, -8F, 16, 16, 16);
Shape1.setRotationPoint(0F, 0F, 0F);
Shape1.setTextureSize(64, 64);
Shape1.mirror = true;
setRotation(Shape1, 0F, 0F, 0F);
Shape2 = new ModelRenderer(this, 0, 32);
Shape2.addBox(3F, -10F, -1F, 12, 12, 12);
Shape2.setRotationPoint(0F, 0F, 0F);
Shape2.setTextureSize(64, 64);
Shape2.mirror = true;
setRotation(Shape2, 0F, 0F, 0F);
Shape3 = new ModelRenderer(this, 0, 32);
Shape3.addBox(0F, 0F, -10F, 12, 12, 12);
Shape3.setRotationPoint(0F, 0F, 0F);
Shape3.setTextureSize(64, 64);
Shape3.mirror = true;
setRotation(Shape3, 0F, 0F, 0F);
Shape4 = new ModelRenderer(this, 0, 32);
Shape4.addBox(1F, 2F, 2F, 12, 12, 12);
Shape4.setRotationPoint(0F, 0F, 0F);
Shape4.setTextureSize(64, 64);
Shape4.mirror = true;
setRotation(Shape4, 0F, 0F, 0F);
Shape5 = new ModelRenderer(this, 0, 32);
Shape5.addBox(-12F, -5F, 0F, 12, 12, 12);
Shape5.setRotationPoint(0F, 0F, 0F);
Shape5.setTextureSize(64, 64);
Shape5.mirror = true;
setRotation(Shape5, 0F, 0F, 0F);
Shape6 = new ModelRenderer(this, 0, 32);
Shape6.addBox(-13F, -2F, -11F, 12, 12, 12);
Shape6.setRotationPoint(0F, 0F, 0F);
Shape6.setTextureSize(64, 64);
Shape6.mirror = true;
setRotation(Shape6, 0F, 0F, 0F);
Shape7 = new ModelRenderer(this, 0, 32);
Shape7.addBox(-6F, -14F, -9F, 12, 12, 12);
Shape7.setRotationPoint(0F, 0F, 0F);
Shape7.setTextureSize(64, 64);
Shape7.mirror = true;
setRotation(Shape7, 0F, 0F, 0F);
}
public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
{
super.render(entity, f, f1, f2, f3, f4, f5);
setRotationAngles(f, f1, f2, f3, f4, f5, entity);
Shape1.render(f5);
Shape2.render(f5);
Shape3.render(f5);
Shape4.render(f5);
Shape5.render(f5);
Shape6.render(f5);
Shape7.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
{
super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
}
}

58
BM_src/WayofTime/alchemicalWizardry/common/renderer/model/ModelPedestal.java Normal file
View file

@ -0,0 +1,58 @@
package WayofTime.alchemicalWizardry.common.renderer.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.entity.Entity;
public class ModelPedestal extends ModelBase
{
//fields
ModelRenderer base;
ModelRenderer top;
ModelRenderer middle;
public ModelPedestal()
{
textureWidth = 64;
textureHeight = 32;
base = new ModelRenderer(this, 0, 0);
base.addBox(0F, 0F, 0F, 10, 1, 10);
base.setRotationPoint(-5F, 23F, -5F);
base.setTextureSize(64, 32);
base.mirror = true;
setRotation(base, 0F, 0F, 0F);
top = new ModelRenderer(this, 0, 19);
top.addBox(0F, 0F, 0F, 6, 1, 6);
top.setRotationPoint(-3F, 14F, -3F);
top.setTextureSize(64, 32);
top.mirror = true;
setRotation(top, 0F, 0F, 0F);
middle = new ModelRenderer(this, 50, 0);
middle.addBox(0F, 0F, 0F, 2, 8, 2);
middle.setRotationPoint(-1F, 15F, -1F);
middle.setTextureSize(64, 32);
middle.mirror = true;
setRotation(middle, 0F, 0F, 0F);
}
public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
{
super.render(entity, f, f1, f2, f3, f4, f5);
setRotationAngles(f, f1, f2, f3, f4, f5, entity);
base.render(f5);
top.render(f5);
middle.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
{
super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
}
}

90
BM_src/WayofTime/alchemicalWizardry/common/renderer/model/ModelPlinth.java Normal file
View file

@ -0,0 +1,90 @@
package WayofTime.alchemicalWizardry.common.renderer.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.entity.Entity;
public class ModelPlinth extends ModelBase
{
//fields
ModelRenderer base;
ModelRenderer table;
ModelRenderer pillar;
ModelRenderer edge1;
ModelRenderer edge2;
ModelRenderer edge3;
ModelRenderer edge4;
public ModelPlinth()
{
textureWidth = 64;
textureHeight = 64;
base = new ModelRenderer(this, 0, 16);
base.addBox(0F, 0F, 0F, 10, 2, 10);
base.setRotationPoint(-5F, 22F, -5F);
base.setTextureSize(64, 64);
base.mirror = true;
setRotation(base, 0F, 0F, 0F);
table = new ModelRenderer(this, 0, 0);
table.addBox(0F, 0F, 0F, 14, 1, 14);
table.setRotationPoint(-7F, 11F, -7F);
table.setTextureSize(64, 64);
table.mirror = true;
setRotation(table, 0F, 0F, 0F);
pillar = new ModelRenderer(this, 0, 32);
pillar.addBox(0F, 0F, 0F, 6, 10, 6);
pillar.setRotationPoint(-3F, 12F, -3F);
pillar.setTextureSize(64, 64);
pillar.mirror = true;
setRotation(pillar, 0F, 0F, 0F);
edge1 = new ModelRenderer(this, 0, 29);
edge1.addBox(0F, 0F, 0F, 14, 1, 1);
edge1.setRotationPoint(-7F, 10F, 6F);
edge1.setTextureSize(64, 64);
edge1.mirror = true;
setRotation(edge1, 0F, 0F, 0F);
edge2 = new ModelRenderer(this, 0, 29);
edge2.addBox(0F, 0F, 0F, 14, 1, 1);
edge2.setRotationPoint(-7F, 10F, -7F);
edge2.setTextureSize(64, 64);
edge2.mirror = true;
setRotation(edge2, 0F, 0F, 0F);
edge3 = new ModelRenderer(this, 25, 32);
edge3.addBox(0F, 0F, 0F, 1, 1, 12);
edge3.setRotationPoint(-7F, 10F, -6F);
edge3.setTextureSize(64, 64);
edge3.mirror = true;
setRotation(edge3, 0F, 0F, 0F);
edge4 = new ModelRenderer(this, 25, 32);
edge4.addBox(0F, 0F, 0F, 1, 1, 12);
edge4.setRotationPoint(6F, 10F, -6F);
edge4.setTextureSize(64, 64);
edge4.mirror = true;
setRotation(edge4, 0F, 0F, 0F);
}
public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
{
super.render(entity, f, f1, f2, f3, f4, f5);
setRotationAngles(f, f1, f2, f3, f4, f5, entity);
base.render(f5);
table.render(f5);
pillar.render(f5);
edge1.render(f5);
edge2.render(f5);
edge3.render(f5);
edge4.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
{
super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
}
}

86
BM_src/WayofTime/alchemicalWizardry/common/renderer/model/ModelShade.java Normal file
View file

@ -0,0 +1,86 @@
package WayofTime.alchemicalWizardry.common.renderer.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.entity.Entity;
public class ModelShade extends ModelBase
{
//fields
ModelRenderer body;
ModelRenderer tail1;
ModelRenderer leftArm;
ModelRenderer rightArm;
ModelRenderer tail2;
ModelRenderer head;
public ModelShade()
{
textureWidth = 64;
textureHeight = 64;
body = new ModelRenderer(this, 0, 45);
body.addBox(-6F, 0F, -3F, 12, 12, 6);
body.setRotationPoint(0F, -4F, 0F);
body.setTextureSize(64, 64);
body.mirror = true;
setRotation(body, 0F, 0F, 0F);
tail1 = new ModelRenderer(this, 37, 43);
tail1.addBox(-2F, 1F, -2F, 4, 6, 4);
tail1.setRotationPoint(0F, 8F, 0F);
tail1.setTextureSize(64, 64);
tail1.mirror = true;
setRotation(tail1, 0.122173F, 0F, 0F);
leftArm = new ModelRenderer(this, 0, 0);
leftArm.addBox(0F, -4F, -2F, 4, 20, 4);
leftArm.setRotationPoint(6F, -2F, 0F);
leftArm.setTextureSize(64, 64);
leftArm.mirror = true;
setRotation(leftArm, 0F, 0F, 0F);
rightArm = new ModelRenderer(this, 0, 0);
rightArm.mirror = true;
rightArm.addBox(-4F, -4F, -2F, 4, 20, 4);
rightArm.setRotationPoint(-6F, -2F, 0F);
rightArm.setTextureSize(64, 64);
rightArm.mirror = true;
setRotation(rightArm, 0F, 0F, 0F);
rightArm.mirror = false;
tail2 = new ModelRenderer(this, 37, 54);
tail2.addBox(-1.5F, 6F, -3F, 3, 6, 3);
tail2.setRotationPoint(0F, 8F, 0F);
tail2.setTextureSize(64, 64);
tail2.mirror = true;
setRotation(tail2, 0.4363323F, 0F, 0F);
head = new ModelRenderer(this, 17, 0);
head.addBox(-4F, -8F, -4F, 8, 8, 8);
head.setRotationPoint(0F, -4F, -1F);
head.setTextureSize(64, 64);
head.mirror = true;
setRotation(head, 0F, 0F, 0F);
}
public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
{
super.render(entity, f, f1, f2, f3, f4, f5);
setRotationAngles(f, f1, f2, f3, f4, f5, entity);
body.render(f5);
tail1.render(f5);
leftArm.render(f5);
rightArm.render(f5);
tail2.render(f5);
head.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
{
super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
this.head.rotateAngleX = f4 / (180F / (float)Math.PI);
this.head.rotateAngleY = f3 / (180F / (float)Math.PI);
}
}

127
BM_src/WayofTime/alchemicalWizardry/common/renderer/model/ModelSmallEarthGolem.java Normal file
View file

@ -0,0 +1,127 @@
package WayofTime.alchemicalWizardry.common.renderer.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.entity.Entity;
import net.minecraft.util.MathHelper;
public class ModelSmallEarthGolem extends ModelBase
{
//fields
ModelRenderer leftLeg;
ModelRenderer rightLeg;
ModelRenderer body;
ModelRenderer head;
ModelRenderer chest1;
ModelRenderer chest2;
ModelRenderer chest3;
ModelRenderer leftArm;
ModelRenderer rightArm;
ModelRenderer back1;
public ModelSmallEarthGolem()
{
textureWidth = 32;
textureHeight = 32;
leftLeg = new ModelRenderer(this, 13, 0);
leftLeg.addBox(-1F, 0F, -1F, 2, 5, 2);
leftLeg.setRotationPoint(1F, 19F, 0F);
leftLeg.setTextureSize(32, 32);
leftLeg.mirror = true;
setRotation(leftLeg, 0F, 0F, 0F);
rightLeg = new ModelRenderer(this, 13, 0);
rightLeg.mirror = true;
rightLeg.addBox(-1F, 0F, -1F, 2, 5, 2);
rightLeg.setRotationPoint(-1F, 19F, 0F);
rightLeg.setTextureSize(32, 32);
rightLeg.mirror = true;
setRotation(rightLeg, 0F, 0F, 0F);
rightLeg.mirror = false;
body = new ModelRenderer(this, 0, 7);
body.addBox(-2F, 0F, -1F, 4, 5, 2);
body.setRotationPoint(0F, 14F, 0F);
body.setTextureSize(32, 32);
body.mirror = true;
setRotation(body, 0F, 0F, 0F);
head = new ModelRenderer(this, 0, 0);
head.addBox(-1.5F, -3F, -2F, 3, 3, 3);
head.setRotationPoint(0F, 14F, 0F);
head.setTextureSize(32, 32);
head.mirror = true;
setRotation(head, 0F, 0F, 0F);
chest1 = new ModelRenderer(this, 22, 0);
chest1.addBox(-1F, 0.5F, -2F, 2, 3, 1);
chest1.setRotationPoint(0F, 14F, 0F);
chest1.setTextureSize(32, 32);
chest1.mirror = true;
setRotation(chest1, 0F, 0F, 0F);
chest2 = new ModelRenderer(this, 22, 5);
chest2.addBox(1F, 1.5F, -2F, 1, 1, 1);
chest2.setRotationPoint(0F, 14F, 0F);
chest2.setTextureSize(32, 32);
chest2.mirror = true;
setRotation(chest2, 0F, 0F, 0F);
chest3 = new ModelRenderer(this, 22, 5);
chest3.mirror = true;
chest3.addBox(-2F, 1.5F, -2F, 1, 1, 1);
chest3.setRotationPoint(0F, 14F, 0F);
chest3.setTextureSize(32, 32);
chest3.mirror = true;
setRotation(chest3, 0F, 0F, 0F);
chest3.mirror = false;
leftArm = new ModelRenderer(this, 13, 7);
leftArm.addBox(0F, -1F, -1F, 2, 5, 2);
leftArm.setRotationPoint(2F, 15F, 0F);
leftArm.setTextureSize(32, 32);
leftArm.mirror = true;
setRotation(leftArm, 0F, 0F, 0F);
rightArm = new ModelRenderer(this, 13, 7);
rightArm.mirror = true;
rightArm.addBox(-2F, -1F, -1F, 2, 5, 2);
rightArm.setRotationPoint(-2F, 15F, 0F);
rightArm.setTextureSize(32, 32);
rightArm.mirror = true;
setRotation(rightArm, 0F, 0F, 0F);
rightArm.mirror = false;
back1 = new ModelRenderer(this, 22, 8);
back1.addBox(-1.5F, 1.5F, 1F, 3, 1, 1);
back1.setRotationPoint(0F, 14F, 0F);
back1.setTextureSize(32, 32);
back1.mirror = true;
setRotation(back1, 0F, 0F, 0F);
}
public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
{
super.render(entity, f, f1, f2, f3, f4, f5);
setRotationAngles(f, f1, f2, f3, f4, f5, entity);
leftLeg.render(f5);
rightLeg.render(f5);
body.render(f5);
head.render(f5);
chest1.render(f5);
chest2.render(f5);
chest3.render(f5);
leftArm.render(f5);
rightArm.render(f5);
back1.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
{
super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
this.head.rotateAngleX = f4 / (180F / (float)Math.PI);
this.head.rotateAngleY = f3 / (180F / (float)Math.PI);
this.leftLeg.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
this.rightLeg.rotateAngleX = MathHelper.cos(f * 0.6662F + (float)Math.PI) * 1.4F * f1;
this.rightArm.rotateAngleX = MathHelper.cos(f * 0.6662F + (float)Math.PI) * 1.4F * f1;
this.leftArm.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
}
}

203
BM_src/WayofTime/alchemicalWizardry/common/renderer/model/ModelWingedFireDemon.java Normal file
View file

@ -0,0 +1,203 @@
package WayofTime.alchemicalWizardry.common.renderer.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.entity.Entity;
import net.minecraft.util.MathHelper;
public class ModelWingedFireDemon extends ModelBase
{
//fields
ModelRenderer leftLegPlate;
ModelRenderer leftLeg;
ModelRenderer codPiece;
ModelRenderer rightLegPlate;
ModelRenderer rightLeg;
ModelRenderer body;
ModelRenderer leftShoulder;
ModelRenderer leftArm;
ModelRenderer head;
ModelRenderer rightShoulder;
ModelRenderer rightArm;
ModelRenderer leftWing;
ModelRenderer rightWing;
ModelRenderer leftHorn1;
ModelRenderer rightHorn1;
ModelRenderer leftHorn2;
ModelRenderer rightHorn2;
public ModelWingedFireDemon()
{
textureWidth = 64;
textureHeight = 64;
leftLegPlate = new ModelRenderer(this, 40, 36);
leftLegPlate.addBox(0F, -3F, -3F, 6, 6, 6);
leftLegPlate.setRotationPoint(2F, 5F, 0F);
leftLegPlate.setTextureSize(64, 64);
leftLegPlate.mirror = true;
setRotation(leftLegPlate, 0F, 0F, 0F);
leftLeg = new ModelRenderer(this, 48, 16);
leftLeg.addBox(1F, 3F, -2F, 4, 16, 4);
leftLeg.setRotationPoint(2F, 5F, 0F);
leftLeg.setTextureSize(64, 64);
leftLeg.mirror = true;
setRotation(leftLeg, 0F, 0F, 0F);
codPiece = new ModelRenderer(this, 48, 0);
codPiece.addBox(-2F, 0F, -2F, 4, 6, 4);
codPiece.setRotationPoint(0F, 1F, 0F);
codPiece.setTextureSize(64, 64);
codPiece.mirror = true;
setRotation(codPiece, 0F, 0F, 0F);
rightLegPlate = new ModelRenderer(this, 40, 36);
rightLegPlate.mirror = true;
rightLegPlate.addBox(-6F, -3F, -3F, 6, 6, 6);
rightLegPlate.setRotationPoint(-2F, 5F, 0F);
rightLegPlate.setTextureSize(64, 64);
rightLegPlate.mirror = true;
setRotation(rightLegPlate, 0F, 0F, 0F);
rightLegPlate.mirror = false;
rightLeg = new ModelRenderer(this, 48, 16);
rightLeg.mirror = true;
rightLeg.addBox(-5F, 3F, -2F, 4, 16, 4);
rightLeg.setRotationPoint(-2F, 5F, 0F);
rightLeg.setTextureSize(64, 64);
rightLeg.mirror = true;
setRotation(rightLeg, 0F, 0F, 0F);
rightLeg.mirror = false;
body = new ModelRenderer(this, 0, 44);
body.addBox(-5F, -14F, -3F, 10, 14, 6);
body.setRotationPoint(0F, 1F, 0F);
body.setTextureSize(64, 64);
body.mirror = true;
setRotation(body, 0F, 0F, 0F);
leftShoulder = new ModelRenderer(this, 0, 29);
leftShoulder.addBox(0F, -5F, -4F, 8, 7, 8);
leftShoulder.setRotationPoint(5F, -10F, 0F);
leftShoulder.setTextureSize(64, 64);
leftShoulder.mirror = true;
setRotation(leftShoulder, 0F, 0F, 0F);
leftArm = new ModelRenderer(this, 32, 0);
leftArm.addBox(3F, 2F, -2F, 4, 12, 4);
leftArm.setRotationPoint(5F, -10F, 0F);
leftArm.setTextureSize(64, 64);
leftArm.mirror = true;
setRotation(leftArm, 0F, 0F, 0F);
head = new ModelRenderer(this, 32, 48);
head.addBox(-4F, -7F, -4F, 8, 8, 8);
head.setRotationPoint(0F, -14F, -1F);
head.setTextureSize(64, 64);
head.mirror = true;
setRotation(head, 0F, 0F, 0F);
rightShoulder = new ModelRenderer(this, 0, 29);
rightShoulder.mirror = true;
rightShoulder.mirror = true;
rightShoulder.addBox(-8F, -5F, -4F, 8, 7, 8);
rightShoulder.setRotationPoint(-5F, -10F, 0F);
rightShoulder.setTextureSize(64, 64);
rightShoulder.mirror = true;
setRotation(rightShoulder, 0F, 0F, 0F);
rightShoulder.mirror = false;
rightArm = new ModelRenderer(this, 32, 0);
rightArm.mirror = true;
rightArm.mirror = true;
rightArm.addBox(-7F, 2F, -2F, 4, 12, 4);
rightArm.setRotationPoint(-5F, -10F, 0F);
rightArm.setTextureSize(64, 64);
rightArm.mirror = true;
setRotation(rightArm, 0F, 0F, 0F);
rightArm.mirror = false;
leftWing = new ModelRenderer(this, 0, 0);
leftWing.addBox(0F, -2F, 0F, 16, 12, 0);
leftWing.setRotationPoint(0F, -11F, 3F);
leftWing.setTextureSize(64, 64);
leftWing.mirror = true;
setRotation(leftWing, 0F, -0.5061455F, 0F);
rightWing = new ModelRenderer(this, 0, 0);
rightWing.mirror = true;
rightWing.addBox(-16F, -2F, 0F, 16, 12, 0);
rightWing.setRotationPoint(0F, -11F, 3F);
rightWing.setTextureSize(64, 64);
rightWing.mirror = true;
setRotation(rightWing, 0F, 0.5061455F, 0F);
rightWing.mirror = false;
leftHorn1 = new ModelRenderer(this, 0, 12);
leftHorn1.addBox(4F, -9F, -1F, 1, 5, 1);
leftHorn1.setRotationPoint(0F, -14F, -1F);
leftHorn1.setTextureSize(64, 64);
leftHorn1.mirror = true;
setRotation(leftHorn1, 0F, 0F, 0F);
rightHorn1 = new ModelRenderer(this, 0, 12);
rightHorn1.mirror = true;
rightHorn1.addBox(-5F, -9F, -1F, 1, 5, 1);
rightHorn1.setRotationPoint(0F, -14F, -1F);
rightHorn1.setTextureSize(64, 64);
rightHorn1.mirror = true;
setRotation(rightHorn1, 0F, 0F, 0F);
rightHorn1.mirror = false;
leftHorn2 = new ModelRenderer(this, 4, 12);
leftHorn2.addBox(4F, -10F, 0F, 1, 5, 1);
leftHorn2.setRotationPoint(0F, -14F, -1F);
leftHorn2.setTextureSize(64, 64);
leftHorn2.mirror = true;
setRotation(leftHorn2, 0F, 0F, 0F);
rightHorn2 = new ModelRenderer(this, 4, 12);
rightHorn2.mirror = true;
rightHorn2.addBox(-5F, -10F, 0F, 1, 5, 1);
rightHorn2.setRotationPoint(0F, -14F, -1F);
rightHorn2.setTextureSize(64, 64);
rightHorn2.mirror = true;
setRotation(rightHorn2, 0F, 0F, 0F);
rightHorn2.mirror = false;
}
public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
{
super.render(entity, f, f1, f2, f3, f4, f5);
setRotationAngles(f, f1, f2, f3, f4, f5, entity);
leftLegPlate.render(f5);
leftLeg.render(f5);
codPiece.render(f5);
rightLegPlate.render(f5);
rightLeg.render(f5);
body.render(f5);
leftShoulder.render(f5);
leftArm.render(f5);
head.render(f5);
rightShoulder.render(f5);
rightArm.render(f5);
leftWing.render(f5);
rightWing.render(f5);
leftHorn1.render(f5);
rightHorn1.render(f5);
leftHorn2.render(f5);
rightHorn2.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
{
super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
this.head.rotateAngleX = f4 / (180F / (float)Math.PI);
this.head.rotateAngleY = f3 / (180F / (float)Math.PI);
this.leftHorn1.rotateAngleX = head.rotateAngleX;
this.leftHorn1.rotateAngleY = head.rotateAngleY;
this.leftHorn2.rotateAngleX = head.rotateAngleX;
this.leftHorn2.rotateAngleY = head.rotateAngleY;
this.rightHorn1.rotateAngleX = head.rotateAngleX;
this.rightHorn1.rotateAngleY = head.rotateAngleY;
this.rightHorn2.rotateAngleX = head.rotateAngleX;
this.rightHorn2.rotateAngleY = head.rotateAngleY;
this.leftLeg.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
this.rightLeg.rotateAngleX = MathHelper.cos(f * 0.6662F + (float)Math.PI) * 1.0F * f1;
this.rightArm.rotateAngleX = MathHelper.cos(f * 0.6662F + (float)Math.PI) * 1.0F * f1;
this.leftArm.rotateAngleX = MathHelper.cos(f * 0.6662F) * 1.4F * f1;
this.leftShoulder.rotateAngleX = this.leftArm.rotateAngleX;
this.rightShoulder.rotateAngleX = this.rightArm.rotateAngleX;
}
}

138
BM_src/WayofTime/alchemicalWizardry/common/renderer/model/ModelWritingTable.java Normal file
View file

@ -0,0 +1,138 @@
package WayofTime.alchemicalWizardry.common.renderer.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.entity.Entity;
public class ModelWritingTable extends ModelBase
{
//fields
ModelRenderer base;
ModelRenderer support;
ModelRenderer appendage1;
ModelRenderer appendage2;
ModelRenderer appendage3;
ModelRenderer appendage4;
ModelRenderer appendage5;
ModelRenderer outputPad;
ModelRenderer input1;
ModelRenderer input5;
ModelRenderer input4;
ModelRenderer input3;
ModelRenderer Shape1;
public ModelWritingTable()
{
textureWidth = 64;
textureHeight = 64;
base = new ModelRenderer(this, 0, 0);
base.addBox(0F, 0F, 0F, 16, 2, 16);
base.setRotationPoint(-8F, 22F, -8F);
base.setTextureSize(64, 32);
base.mirror = true;
setRotation(base, 0F, 0F, 0F);
support = new ModelRenderer(this, 0, 0);
support.addBox(0F, 0F, 0F, 2, 12, 2);
support.setRotationPoint(-1F, 10F, -1F);
support.setTextureSize(64, 32);
support.mirror = true;
setRotation(support, 0F, 0F, 0F);
appendage1 = new ModelRenderer(this, 48, 0);
appendage1.addBox(1F, 0F, 0F, 7, 11, 0);
appendage1.setRotationPoint(0F, 10F, 0F);
appendage1.setTextureSize(64, 32);
appendage1.mirror = true;
setRotation(appendage1, 0F, 0F, 0F);
appendage2 = new ModelRenderer(this, 48, 0);
appendage2.addBox(1F, 0F, 0F, 7, 11, 0);
appendage2.setRotationPoint(0F, 10F, 0F);
appendage2.setTextureSize(64, 32);
appendage2.mirror = true;
setRotation(appendage2, 0F, ((float)Math.PI * 2F / 5F), 0F);
appendage3 = new ModelRenderer(this, 48, 0);
appendage3.addBox(1F, 0F, 0F, 7, 11, 0);
appendage3.setRotationPoint(0F, 10F, 0F);
appendage3.setTextureSize(64, 32);
appendage3.mirror = true;
setRotation(appendage3, 0F, 2.513274F, 0F);
appendage4 = new ModelRenderer(this, 48, 0);
appendage4.addBox(1F, 0F, 0F, 7, 11, 0);
appendage4.setRotationPoint(0F, 10F, 0F);
appendage4.setTextureSize(64, 32);
appendage4.mirror = true;
setRotation(appendage4, 0F, -2.513274F, 0F);
appendage5 = new ModelRenderer(this, 48, 0);
appendage5.addBox(1F, 0F, 0F, 7, 11, 0);
appendage5.setRotationPoint(0F, 10F, 0F);
appendage5.setTextureSize(64, 32);
appendage5.mirror = true;
setRotation(appendage5, 0F, -((float)Math.PI * 2F / 5F), 0F);
outputPad = new ModelRenderer(this, 0, 20);
outputPad.addBox(0F, 0F, 0F, 4, 1, 4);
outputPad.setRotationPoint(-2F, 9F, -2F);
outputPad.setTextureSize(64, 64);
outputPad.mirror = true;
setRotation(outputPad, 0F, 0F, 0F);
input1 = new ModelRenderer(this, 0, 20);
input1.addBox(4F, 0F, -2F, 4, 1, 4);
input1.setRotationPoint(0F, 21F, 0F);
input1.setTextureSize(64, 64);
input1.mirror = true;
setRotation(input1, 0F, 0F, 0F);
input5 = new ModelRenderer(this, 0, 20);
input5.addBox(0F, 0F, 0F, 4, 1, 4);
input5.setRotationPoint(0F, 21F, -8F);
input5.setTextureSize(64, 64);
input5.mirror = true;
setRotation(input5, 0F, 0F, 0F);
input4 = new ModelRenderer(this, 0, 20);
input4.addBox(-7F, 0F, -6F, 4, 1, 4);
input4.setRotationPoint(0F, 21F, 0F);
input4.setTextureSize(64, 64);
input4.mirror = true;
setRotation(input4, 0F, 0F, 0F);
input3 = new ModelRenderer(this, 0, 20);
input3.addBox(-7F, 0F, 2F, 4, 1, 4);
input3.setRotationPoint(0F, 21F, 0F);
input3.setTextureSize(64, 64);
input3.mirror = true;
setRotation(input3, 0F, 0F, 0F);
Shape1 = new ModelRenderer(this, 0, 20);
Shape1.addBox(0F, 0F, 4F, 4, 1, 4);
Shape1.setRotationPoint(0F, 21F, 0F);
Shape1.setTextureSize(64, 64);
Shape1.mirror = true;
setRotation(Shape1, 0F, 0F, 0F);
}
public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5)
{
super.render(entity, f, f1, f2, f3, f4, f5);
setRotationAngles(f, f1, f2, f3, f4, f5, entity);
base.render(f5);
support.render(f5);
appendage1.render(f5);
appendage2.render(f5);
appendage3.render(f5);
appendage4.render(f5);
appendage5.render(f5);
outputPad.render(f5);
input1.render(f5);
input5.render(f5);
input4.render(f5);
input3.render(f5);
Shape1.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity)
{
super.setRotationAngles(f, f1, f2, f3, f4, f5, entity);
}
}