Anvilcraft/resonant-induction
2
1
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Moved all renderers to new render system

Browse source
This commit is contained in:
Calclavia 2014-01-15 21:23:17 +08:00
parent c1f3dcc75e
commit 6e0bcfccd3
42 changed files with 71 additions and 3432 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/main/java/resonantinduction/core/prefab/tile/TileEntityFilterable.java
View file

@ -90,7 +90,7 @@ public abstract class TileEntityFilterable extends TileAssembly implements IRota
@Override
public ForgeDirection getDirection()
{
return ForgeDirection.getOrientation(this.getBlockMetadata());
return ForgeDirection.getOrientation(getBlockType() != null ? getBlockMetadata() : 0);
}
@Override

2
src/main/java/resonantinduction/old/client/model/ModelArmbot.java → src/main/java/resonantinduction/electrical/armbot/ModelArmbot.java
View file

@ -1,4 +1,4 @@
package resonantinduction.old.client.model;
package resonantinduction.electrical.armbot;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;

1
src/main/java/resonantinduction/electrical/armbot/RenderArmbot.java
View file

@ -18,7 +18,6 @@ import net.minecraft.world.IBlockAccess;
import org.lwjgl.opengl.GL11;
import resonantinduction.core.Reference;
import resonantinduction.old.client.model.ModelArmbot;
import universalelectricity.api.vector.Vector3;
import calclavia.lib.render.RenderUtility;
import calclavia.lib.render.block.ICustomBlockRenderer;

21
src/main/java/resonantinduction/mechanical/ClientProxy.java
View file

@ -7,25 +7,22 @@ import resonantinduction.mechanical.fluid.pipe.TilePipe;
import resonantinduction.mechanical.fluid.tank.ItemTankRenderer;
import resonantinduction.mechanical.fluid.tank.RenderTank;
import resonantinduction.mechanical.fluid.tank.TileTank;
import resonantinduction.mechanical.render.MechanicalBlockRenderingHandler;
import cpw.mods.fml.client.registry.ClientRegistry;
import cpw.mods.fml.client.registry.RenderingRegistry;
public class ClientProxy extends CommonProxy
{
@Override
public void preInit()
{
RenderingRegistry.registerBlockHandler(MechanicalBlockRenderingHandler.INSTANCE);
}
@Override
public void init()
{
MinecraftForgeClient.registerItemRenderer(Mechanical.blockTank.blockID, new ItemTankRenderer());
MinecraftForgeClient.registerItemRenderer(Mechanical.blockPipe.blockID, new ItemPipeRenderer());
MinecraftForgeClient.registerItemRenderer(Mechanical.blockReleaseValve.blockID, new ItemPipeRenderer());
ClientRegistry.bindTileEntitySpecialRenderer(TilePipe.class, new RenderPipe());
ClientRegistry.bindTileEntitySpecialRenderer(TileTank.class, RenderTank.INSTANCE);
}
public void init()
{
MinecraftForgeClient.registerItemRenderer(Mechanical.blockTank.blockID, new ItemTankRenderer());
MinecraftForgeClient.registerItemRenderer(Mechanical.blockPipe.blockID, new ItemPipeRenderer());
MinecraftForgeClient.registerItemRenderer(Mechanical.blockReleaseValve.blockID, new ItemPipeRenderer());
ClientRegistry.bindTileEntitySpecialRenderer(TilePipe.class, new RenderPipe());
ClientRegistry.bindTileEntitySpecialRenderer(TileTank.class, RenderTank.INSTANCE);
}
}

6
src/main/java/resonantinduction/mechanical/belt/BlockConveyorBelt.java
View file

@ -15,8 +15,8 @@ import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraftforge.common.ForgeDirection;
import resonantinduction.core.prefab.block.BlockRI;
import resonantinduction.core.render.RIBlockRenderingHandler;
import resonantinduction.mechanical.belt.TileConveyorBelt.SlantType;
import resonantinduction.mechanical.render.MechanicalBlockRenderingHandler;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@ -242,7 +242,7 @@ public class BlockConveyorBelt extends BlockRI
public void onEntityCollidedWithBlock(World world, int x, int y, int z, Entity entity)
{
TileEntity tileEntity = world.getBlockTileEntity(x, y, z);
if (tileEntity instanceof TileConveyorBelt)
{
TileConveyorBelt tile = (TileConveyorBelt) tileEntity;
@ -339,7 +339,7 @@ public class BlockConveyorBelt extends BlockRI
@Override
public int getRenderType()
{
return MechanicalBlockRenderingHandler.ID;
return RIBlockRenderingHandler.ID;
}
@Override

29
src/main/java/resonantinduction/mechanical/belt/RenderConveyorBelt.java
View file

@ -1,18 +1,23 @@
package resonantinduction.mechanical.belt;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.IBlockAccess;
import org.lwjgl.opengl.GL11;
import resonantinduction.core.Reference;
import resonantinduction.mechanical.belt.TileConveyorBelt.SlantType;
import calclavia.lib.render.block.ICustomBlockRenderer;
import cpw.mods.fml.client.FMLClientHandler;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class RenderConveyorBelt extends TileEntitySpecialRenderer
public class RenderConveyorBelt extends TileEntitySpecialRenderer implements ICustomBlockRenderer
{
public static final ModelConveyorBelt MODEL = new ModelConveyorBelt();
public static final ModelAngledBelt MODEL2 = new ModelAngledBelt();
@ -126,6 +131,28 @@ public class RenderConveyorBelt extends TileEntitySpecialRenderer
int ent = tileEntity.worldObj.getBlockId(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord);
GL11.glPopMatrix();
}
@Override
public void renderInventory(Block block, int metadata, int modelID, RenderBlocks renderer)
{
}
@Override
public boolean renderStatic(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer)
{
return false;
}
@Override
public void renderDynamic(TileEntity tile, Block block, int metadata, int modelID, RenderBlocks renderer)
{
GL11.glPushMatrix();
GL11.glTranslatef(0.0F, 1.3F, 0.0F);
GL11.glRotatef(180f, 0f, 0f, 1f);
FMLClientHandler.instance().getClient().renderEngine.bindTexture(new ResourceLocation(Reference.DOMAIN, Reference.MODEL_PATH + "belt/frame0.png"));
MODEL.render(0.0625F, 0, false, false, false, false);
GL11.glPopMatrix();
}
}

4
src/main/java/resonantinduction/mechanical/fluid/pipe/BlockPipe.java
View file

@ -13,8 +13,8 @@ import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraftforge.common.ForgeDirection;
import net.minecraftforge.fluids.FluidTank;
import resonantinduction.core.render.RIBlockRenderingHandler;
import resonantinduction.mechanical.fluid.prefab.BlockFluidNetwork;
import resonantinduction.mechanical.render.MechanicalBlockRenderingHandler;
import universalelectricity.api.vector.Vector3;
import calclavia.lib.render.ColorCode;
import calclavia.lib.render.ColorCode.IColorCoded;
@ -75,7 +75,7 @@ public class BlockPipe extends BlockFluidNetwork
@SideOnly(Side.CLIENT)
public int getRenderType()
{
return MechanicalBlockRenderingHandler.ID;
return RIBlockRenderingHandler.ID;
}
@Override

4
src/main/java/resonantinduction/mechanical/fluid/pump/BlockPump.java
View file

@ -10,8 +10,8 @@ import net.minecraft.util.MovingObjectPosition;
import net.minecraft.world.World;
import net.minecraftforge.common.ForgeDirection;
import resonantinduction.core.prefab.block.BlockRI;
import resonantinduction.core.render.RIBlockRenderingHandler;
import resonantinduction.mechanical.Mechanical;
import resonantinduction.mechanical.render.MechanicalBlockRenderingHandler;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@ -41,7 +41,7 @@ public class BlockPump extends BlockRI
@SideOnly(Side.CLIENT)
public int getRenderType()
{
return MechanicalBlockRenderingHandler.ID;
return RIBlockRenderingHandler.ID;
}
@Override

7
src/main/java/resonantinduction/mechanical/fluid/pump/RenderPump.java
View file

@ -7,7 +7,7 @@ import net.minecraft.util.ResourceLocation;
import org.lwjgl.opengl.GL11;
import resonantinduction.core.Reference;
import resonantinduction.old.client.model.ModelPump;
import resonantinduction.mechanical.fluid.tank.ModelPump;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@ -20,12 +20,13 @@ public class RenderPump extends TileEntitySpecialRenderer
@Override
public void renderTileEntityAt(TileEntity t, double d, double d1, double d2, float f)
{
int meta = t.worldObj.getBlockMetadata(t.xCoord, t.yCoord, t.zCoord);
int meta = t.getBlockType() != null ? t.getBlockMetadata() : 0;
bindTexture(TEXTURE);
GL11.glPushMatrix();
GL11.glTranslatef((float) d + 0.5F, (float) d1 + 1.5F, (float) d2 + 0.5F);
GL11.glScalef(1.0F, -1F, -1F);
switch (meta)
{
case 2:
@ -41,6 +42,7 @@ public class RenderPump extends TileEntitySpecialRenderer
GL11.glRotatef(270f, 0f, 1f, 0f);
break;
}
MODEL.render(0.0625F);
if (t instanceof TilePump)
@ -51,5 +53,4 @@ public class RenderPump extends TileEntitySpecialRenderer
GL11.glPopMatrix();
}
}

4
src/main/java/resonantinduction/mechanical/fluid/tank/BlockTank.java
View file

@ -10,11 +10,11 @@ import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.MovingObjectPosition;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import resonantinduction.core.render.RIBlockRenderingHandler;
import resonantinduction.mechanical.fluid.pipe.FluidContainerMaterial;
import resonantinduction.mechanical.fluid.pipe.ItemBlockFluidContainer;
import resonantinduction.mechanical.fluid.pipe.TilePipe;
import resonantinduction.mechanical.fluid.prefab.BlockFluidNetwork;
import resonantinduction.mechanical.render.MechanicalBlockRenderingHandler;
import universalelectricity.api.vector.Vector3;
import calclavia.lib.utility.FluidUtility;
import calclavia.lib.utility.WorldUtility;
@ -47,7 +47,7 @@ public class BlockTank extends BlockFluidNetwork
@SideOnly(Side.CLIENT)
public int getRenderType()
{
return MechanicalBlockRenderingHandler.ID;
return RIBlockRenderingHandler.ID;
}
@Override

2
src/main/java/resonantinduction/old/client/model/ModelPump.java → src/main/java/resonantinduction/mechanical/fluid/tank/ModelPump.java
View file

@ -4,7 +4,7 @@
// Keep in mind that you still need to fill in some blanks
// - ZeuX
package resonantinduction.old.client.model;
package resonantinduction.mechanical.fluid.tank;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;

6
src/main/java/resonantinduction/old/client/model/ModelTankSide.java → src/main/java/resonantinduction/mechanical/fluid/tank/ModelTank.java
View file

@ -4,7 +4,7 @@
// Keep in mind that you still need to fill in some blanks
// - ZeuX
package resonantinduction.old.client.model;
package resonantinduction.mechanical.fluid.tank;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
@ -12,7 +12,7 @@ import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class ModelTankSide extends ModelBase
public class ModelTank extends ModelBase
{
ModelRenderer botSiding;
@ -33,7 +33,7 @@ public class ModelTankSide extends ModelBase
ModelRenderer rightTopSide;
ModelRenderer rightSide;
public ModelTankSide()
public ModelTank()
{
textureWidth = 128;
textureHeight = 128;

3
src/main/java/resonantinduction/mechanical/fluid/tank/RenderTank.java
View file

@ -11,7 +11,6 @@ import org.lwjgl.opengl.GL11;
import resonantinduction.core.render.RenderFluidHelper;
import resonantinduction.electrical.Electrical;
import resonantinduction.mechanical.Mechanical;
import resonantinduction.old.client.model.ModelTankSide;
import calclavia.lib.render.RenderUtility;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@ -20,7 +19,7 @@ import cpw.mods.fml.relauncher.SideOnly;
public class RenderTank extends TileEntitySpecialRenderer
{
public static final RenderTank INSTANCE = new RenderTank();
public final ModelTankSide model = new ModelTankSide();
public final ModelTank model = new ModelTank();
@Override
public void renderTileEntityAt(TileEntity tileEntity, double x, double y, double z, float var8)

4
src/main/java/resonantinduction/mechanical/logistic/BlockManipulator.java
View file

@ -6,7 +6,7 @@ import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.ChatMessageComponent;
import net.minecraft.world.World;
import resonantinduction.core.prefab.block.BlockImprintable;
import resonantinduction.mechanical.render.MechanicalBlockRenderingHandler;
import resonantinduction.core.render.RIBlockRenderingHandler;
import universalelectricity.api.UniversalElectricity;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@ -89,7 +89,7 @@ public class BlockManipulator extends BlockImprintable
@Override
public int getRenderType()
{
return MechanicalBlockRenderingHandler.ID;
return RIBlockRenderingHandler.ID;
}
@Override

4
src/main/java/resonantinduction/mechanical/logistic/BlockRejector.java
View file

@ -6,7 +6,7 @@ import net.minecraft.util.Icon;
import net.minecraft.world.World;
import resonantinduction.core.Reference;
import resonantinduction.core.prefab.block.BlockImprintable;
import resonantinduction.mechanical.render.MechanicalBlockRenderingHandler;
import resonantinduction.core.render.RIBlockRenderingHandler;
import universalelectricity.api.UniversalElectricity;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@ -31,7 +31,7 @@ public class BlockRejector extends BlockImprintable
@Override
public int getRenderType()
{
return MechanicalBlockRenderingHandler.ID;
return RIBlockRenderingHandler.ID;
}
@Override

2
src/main/java/resonantinduction/old/client/model/ModelManipulator.java → src/main/java/resonantinduction/mechanical/logistic/ModelManipulator.java
View file

@ -1,4 +1,4 @@
package resonantinduction.old.client.model;
package resonantinduction.mechanical.logistic;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;

2
src/main/java/resonantinduction/old/client/model/ModelRejectorPiston.java → src/main/java/resonantinduction/mechanical/logistic/ModelRejectorPiston.java
View file

@ -4,7 +4,7 @@
// Keep in mind that you still need to fill in some blanks
// - ZeuX
package resonantinduction.old.client.model;
package resonantinduction.mechanical.logistic;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;

16
src/main/java/resonantinduction/mechanical/logistic/RenderDetector.java
View file

@ -1,15 +1,15 @@
package resonantinduction.mechanical.logistic;
import static calclavia.lib.render.ModelUtility.drawCuboid;
import static calclavia.lib.render.ModelUtility.setGlobalTextureResolution;
import static calclavia.lib.render.ModelUtility.setTextureClip;
import static calclavia.lib.render.ModelUtility.setTextureOffset;
import static calclavia.lib.render.ModelUtility.setTextureSubResolution;
import static org.lwjgl.opengl.GL11.glPopMatrix;
import static org.lwjgl.opengl.GL11.glPushMatrix;
import static org.lwjgl.opengl.GL11.glTranslated;
import static resonantinduction.old.client.model.ModelHelper.drawCuboid;
import static resonantinduction.old.client.model.ModelHelper.setGlobalTextureResolution;
import static resonantinduction.old.client.model.ModelHelper.setTextureClip;
import static resonantinduction.old.client.model.ModelHelper.setTextureSubResolution;
import net.minecraft.tileentity.TileEntity;
import resonantinduction.core.render.RenderImprintable;
import resonantinduction.old.client.model.ModelHelper;
import universalelectricity.api.vector.Vector3;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@ -42,13 +42,13 @@ public class RenderDetector extends RenderImprintable
setGlobalTextureResolution(128, 128);
setTextureClip(false);
ModelHelper.setTextureOffset(0, 64);
setTextureOffset(0, 64);
setTextureSubResolution(64, 64);
drawCuboid(0.45f, 12f / 16f, 0.45f, 2f / 16f, 4f / 16f, 2f / 16f); // stand
ModelHelper.setTextureOffset(0, 0);
setTextureOffset(0, 0);
setTextureSubResolution(128, 64);
drawCuboid(0.25f, 0.25f, 0.25f, 8f / 16f, 8f / 16f, 8f / 16f); // block
ModelHelper.setTextureOffset(64, 64);
setTextureOffset(64, 64);
setTextureSubResolution(64, 32);
drawCuboid(0.375f, 0.25f - (1f / 16f), 0.375f, 4f / 16f, 1f / 16f, 4f / 16f); // lens

1
src/main/java/resonantinduction/mechanical/logistic/RenderManipulator.java
View file

@ -7,7 +7,6 @@ import org.lwjgl.opengl.GL11;
import resonantinduction.core.Reference;
import resonantinduction.core.render.RenderImprintable;
import resonantinduction.old.client.model.ModelManipulator;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;

1
src/main/java/resonantinduction/mechanical/logistic/RenderRejector.java
View file

@ -7,7 +7,6 @@ import org.lwjgl.opengl.GL11;
import resonantinduction.core.Reference;
import resonantinduction.core.render.RenderImprintable;
import resonantinduction.old.client.model.ModelRejectorPiston;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;

172
src/main/java/resonantinduction/mechanical/render/MechanicalBlockRenderingHandler.java
View file

@ -1,172 +0,0 @@
package resonantinduction.mechanical.render;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.IBlockAccess;
import org.lwjgl.opengl.GL11;
import resonantinduction.core.Reference;
import resonantinduction.mechanical.Mechanical;
import resonantinduction.mechanical.belt.ModelConveyorBelt;
import resonantinduction.mechanical.fluid.pump.RenderPump;
import resonantinduction.mechanical.logistic.RenderManipulator;
import resonantinduction.mechanical.logistic.RenderRejector;
import resonantinduction.old.client.model.ModelCrusher;
import resonantinduction.old.client.model.ModelGrinder;
import cpw.mods.fml.client.FMLClientHandler;
import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
import cpw.mods.fml.client.registry.RenderingRegistry;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class MechanicalBlockRenderingHandler implements ISimpleBlockRenderingHandler
{
public static MechanicalBlockRenderingHandler INSTANCE = new MechanicalBlockRenderingHandler();
public static final int ID = RenderingRegistry.getNextAvailableRenderId();
private ModelConveyorBelt modelConveyorBelt = new ModelConveyorBelt();
private ModelCrusher modelCrushor = new ModelCrusher();
private ModelGrinder grinderModel = new ModelGrinder();
@Override
public void renderInventoryBlock(Block block, int metadata, int modelID, RenderBlocks renderer)
{
if (block == Mechanical.blockConveyorBelt)
{
GL11.glPushMatrix();
GL11.glTranslatef(0.0F, 1.3F, 0.0F);
GL11.glRotatef(180f, 0f, 0f, 1f);
FMLClientHandler.instance().getClient().renderEngine.bindTexture(new ResourceLocation(Reference.DOMAIN, Reference.MODEL_PATH + "belt/frame0.png"));
modelConveyorBelt.render(0.0625F, 0, false, false, false, false);
GL11.glPopMatrix();
}
else if (block == Mechanical.blockPump)
{
GL11.glTranslatef(0.0F, 1.3F, 0.0F);
GL11.glRotatef(180f, 0f, 0f, 1f);
FMLClientHandler.instance().getClient().renderEngine.bindTexture(RenderPump.TEXTURE);
RenderPump.MODEL.render(0.0725F);
RenderPump.MODEL.renderMotion(0.0725F, 0);
}
if (block == Mechanical.blockManipulator)
{
FMLClientHandler.instance().getClient().renderEngine.bindTexture(RenderManipulator.TEXTURE_INPUT);
GL11.glPushMatrix();
GL11.glTranslatef(0.6F, 1.5F, 0.6F);
GL11.glRotatef(180f, 0f, 0f, 1f);
GL11.glRotatef(-90f, 0f, 1f, 0f);
RenderManipulator.MODEL.render(0.0625F, true, 0);
GL11.glPopMatrix();
}
if (block == Mechanical.blockRejector)
{
FMLClientHandler.instance().getClient().renderEngine.bindTexture(RenderRejector.TEXTURE);
GL11.glPushMatrix();
GL11.glTranslatef(0.6F, 1.5F, 0.6F);
GL11.glRotatef(180f, 0f, 0f, 1f);
GL11.glRotatef(-90f, 0f, 1f, 0f);
RenderRejector.MODEL.render(0.0625F);
RenderRejector.MODEL.renderPiston(0.0625F, 1);
GL11.glPopMatrix();
}
/*
* if (RecipeLoader.blockPumpMachine != null && block.blockID ==
* RecipeLoader.blockPumpMachine.blockID && metadata < 4)
* {
* GL11.glTranslatef(0.0F, 1.1F, 0.0F);
* GL11.glRotatef(180f, 0f, 0f, 1f);
* FMLClientHandler.instance().getClient().renderEngine.bindTexture(new
* ResourceLocation(Reference.DOMAIN, Reference.MODEL_DIRECTORY + "pumps/WaterPump.png"));
* modelPump.render(0.0725F);
* modelPump.renderMotion(0.0725F, 0);
* }
* else if (RecipeLoader.blockSink != null && block.blockID ==
* RecipeLoader.blockSink.blockID)
* {
* GL11.glTranslatef(0.0F, .8F, 0.0F);
* GL11.glRotatef(180f, 0f, 0f, 1f);
* FMLClientHandler.instance().getClient().renderEngine.bindTexture(new
* ResourceLocation(Reference.DOMAIN, Reference.MODEL_DIRECTORY + "Sink.png"));
* sink.render(0.0565F);
* }
* else if (RecipeLoader.blockRod != null && block.blockID == RecipeLoader.blockRod.blockID)
* {
* GL11.glTranslatef(0.0F, 1.5F, 0.0F);
* GL11.glRotatef(180f, 0f, 0f, 1f);
* FMLClientHandler.instance().getClient().renderEngine.bindTexture(new
* ResourceLocation(Reference.DOMAIN, Reference.MODEL_DIRECTORY +
* "mechanical/GearRod.png"));
* modelRod.render(0.0825F, 0);
* }
* else if (RecipeLoader.blockConPump != null && block.blockID ==
* RecipeLoader.blockConPump.blockID && metadata < 4)
* {
* GL11.glTranslatef(0.0F, 1.2F, 0.0F);
* GL11.glRotatef(180f, 0f, 0f, 1f);
* FMLClientHandler.instance().getClient().renderEngine.bindTexture(new
* ResourceLocation(Reference.DOMAIN, Reference.MODEL_DIRECTORY + "ConstructionPump.png"));
* conPump.render(0.0725F);
* conPump.renderMotor(0.0725F);
* }
* else if (RecipeLoader.frackingPipe != null && block.blockID ==
* RecipeLoader.frackingPipe.blockID)
* {
* FMLClientHandler.instance().getClient().renderEngine.bindTexture(RenderFrackingPipe.TEXTURE
* );
* GL11.glTranslatef(0, 1F, 0);
* GL11.glScalef(1.0F, -1F, -1F);
* RenderFrackingPipe.model.renderAll();
* }
* GL11.glPopMatrix();
*/
/*
* else if (RecipeLoader.blockArmbot != null && block.blockID ==
* RecipeLoader.blockArmbot.blockID)
* {
* FMLClientHandler.instance().getClient().renderEngine.bindTexture(new
* ResourceLocation(Reference.DOMAIN, Reference.MODEL_DIRECTORY + RenderArmbot.TEXTURE));
* GL11.glPushMatrix();
* GL11.glTranslatef(0.4f, 0.8f, 0f);
* GL11.glScalef(0.7f, 0.7f, 0.7f);
* GL11.glRotatef(180f, 0f, 0f, 1f);
* GL11.glRotatef(-90f, 0f, 1f, 0f);
* RenderArmbot.MODEL.render(0.0625F, 0, 0);
* GL11.glPopMatrix();
* }
*/
/*
* else if (RecipeLoader.blockSteamGen != null && block.blockID ==
* RecipeLoader.blockSteamGen.blockID)
* {
* ModelMachine model = RenderSteamGen.getModel(metadata);
* FMLClientHandler.instance().getClient().renderEngine.bindTexture(RenderSteamGen.getTexture
* (metadata));
* GL11.glTranslatef(0.0F, 1.1F, 0.0F);
* GL11.glRotatef(180f, 0f, 0f, 1f);
* model.render(0.0625F);
* }
*/
}
@Override
public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer)
{
return false;
}
@Override
public boolean shouldRender3DInInventory()
{
return true;
}
@Override
public int getRenderId()
{
return ID;
}
}

140
src/main/java/resonantinduction/old/client/model/ModelAdvancedHopper.java
View file

@ -1,140 +0,0 @@
// Date: 11/13/2013 7:19:55 PM
// Template version 1.1
// Java generated by Techne
// Keep in mind that you still need to fill in some blanks
// - ZeuX
package resonantinduction.old.client.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraftforge.common.ForgeDirection;
public class ModelAdvancedHopper extends ModelBase
{
// fields
ModelRenderer bottomConnection;
ModelRenderer center;
ModelRenderer top;
ModelRenderer top2;
ModelRenderer top3;
ModelRenderer top4;
ModelRenderer top5;
ModelRenderer frontConnection;
ModelRenderer backConnection;
ModelRenderer leftConnection;
ModelRenderer rightConnection;
public ModelAdvancedHopper()
{
textureWidth = 128;
textureHeight = 128;
bottomConnection = new ModelRenderer(this, 18, 0);
bottomConnection.addBox(-2F, 0F, -2F, 4, 4, 4);
bottomConnection.setRotationPoint(0F, 20F, 0F);
bottomConnection.setTextureSize(128, 128);
bottomConnection.mirror = true;
setRotation(bottomConnection, 0F, 0.7853982F, 0F);
center = new ModelRenderer(this, 45, 0);
center.addBox(-4F, 0F, -4F, 8, 6, 8);
center.setRotationPoint(0F, 14F, 0F);
center.setTextureSize(128, 128);
center.mirror = true;
setRotation(center, 0F, 0F, 0F);
top = new ModelRenderer(this, 0, 33);
top.addBox(-8F, -4F, -8F, 16, 6, 2);
top.setRotationPoint(0F, 12F, 0F);
top.setTextureSize(128, 128);
top.mirror = true;
setRotation(top, 0F, 0F, 0F);
top2 = new ModelRenderer(this, 0, 62);
top2.addBox(-8F, -4F, 6F, 16, 6, 2);
top2.setRotationPoint(0F, 12F, 0F);
top2.setTextureSize(128, 128);
top2.mirror = true;
setRotation(top2, 0F, 0F, 0F);
top3 = new ModelRenderer(this, 0, 42);
top3.addBox(-8F, -4F, -6F, 2, 6, 12);
top3.setRotationPoint(0F, 12F, 0F);
top3.setTextureSize(128, 128);
top3.mirror = true;
setRotation(top3, 0F, 0F, 0F);
top4 = new ModelRenderer(this, 30, 42);
top4.addBox(6F, -4F, -6F, 2, 6, 12);
top4.setRotationPoint(0F, 12F, 0F);
top4.setTextureSize(128, 128);
top4.mirror = true;
setRotation(top4, 0F, 0F, 0F);
top5 = new ModelRenderer(this, 61, 44);
top5.addBox(-6F, 0F, -6F, 12, 1, 12);
top5.setRotationPoint(0F, 13F, 0F);
top5.setTextureSize(128, 128);
top5.mirror = true;
setRotation(top5, 0F, 0F, 0F);
frontConnection = new ModelRenderer(this, 0, 0);
frontConnection.addBox(-2F, -2F, -4F, 4, 5, 4);
frontConnection.setRotationPoint(0F, 16F, -4F);
frontConnection.setTextureSize(128, 128);
frontConnection.mirror = true;
setRotation(frontConnection, 0F, 0F, 0F);
backConnection = new ModelRenderer(this, 0, 0);
backConnection.addBox(-2F, -2F, 0F, 4, 5, 4);
backConnection.setRotationPoint(0F, 16F, 4F);
backConnection.setTextureSize(128, 128);
backConnection.mirror = true;
setRotation(backConnection, 0F, 0F, 0F);
leftConnection = new ModelRenderer(this, 0, 0);
leftConnection.addBox(0F, -2F, -2F, 4, 5, 4);
leftConnection.setRotationPoint(4F, 16F, 0F);
leftConnection.setTextureSize(128, 128);
leftConnection.mirror = true;
setRotation(leftConnection, 0F, 0F, 0F);
rightConnection = new ModelRenderer(this, 0, 0);
rightConnection.addBox(-4F, -3F, -2F, 4, 5, 4);
rightConnection.setRotationPoint(-4F, 17F, 0F);
rightConnection.setTextureSize(128, 128);
rightConnection.mirror = true;
setRotation(rightConnection, 0F, 0F, 0F);
}
public void render(float f5)
{
center.render(f5);
top.render(f5);
top2.render(f5);
top3.render(f5);
top4.render(f5);
top5.render(f5);
}
public void render(float f5, ForgeDirection side)
{
switch (side)
{
case NORTH:
frontConnection.render(f5);
break;
case SOUTH:
backConnection.render(f5);
break;
case EAST:
leftConnection.render(f5);
break;
case WEST:
rightConnection.render(f5);
break;
case DOWN:
bottomConnection.render(f5);
break;
}
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
}

108
src/main/java/resonantinduction/old/client/model/ModelCopperWire.java
View file

@ -1,108 +0,0 @@
package resonantinduction.old.client.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraftforge.common.ForgeDirection;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class ModelCopperWire extends ModelBase
{
// fields
ModelRenderer Middle;
ModelRenderer Right;
ModelRenderer Left;
ModelRenderer Back;
ModelRenderer Front;
ModelRenderer Top;
ModelRenderer Bottom;
public ModelCopperWire()
{
textureWidth = 64;
textureHeight = 32;
Middle = new ModelRenderer(this, 0, 0);
Middle.addBox(-1F, -1F, -1F, 4, 4, 4);
Middle.setRotationPoint(-1F, 15F, -1F);
Middle.setTextureSize(64, 32);
Middle.mirror = true;
setRotation(Middle, 0F, 0F, 0F);
Right = new ModelRenderer(this, 21, 0);
Right.addBox(0F, 0F, 0F, 6, 4, 4);
Right.setRotationPoint(2F, 14F, -2F);
Right.setTextureSize(64, 32);
Right.mirror = true;
setRotation(Right, 0F, 0F, 0F);
Left = new ModelRenderer(this, 21, 0);
Left.addBox(0F, 0F, 0F, 6, 4, 4);
Left.setRotationPoint(-8F, 14F, -2F);
Left.setTextureSize(64, 32);
Left.mirror = true;
setRotation(Left, 0F, 0F, 0F);
Back = new ModelRenderer(this, 0, 11);
Back.addBox(0F, 0F, 0F, 4, 4, 6);
Back.setRotationPoint(-2F, 14F, 2F);
Back.setTextureSize(64, 32);
Back.mirror = true;
setRotation(Back, 0F, 0F, 0F);
Front = new ModelRenderer(this, 0, 11);
Front.addBox(0F, 0F, 0F, 4, 4, 6);
Front.setRotationPoint(-2F, 14F, -8F);
Front.setTextureSize(64, 32);
Front.mirror = true;
setRotation(Front, 0F, 0F, 0F);
Top = new ModelRenderer(this, 21, 11);
Top.addBox(0F, 0F, 0F, 4, 6, 4);
Top.setRotationPoint(-2F, 8F, -2F);
Top.setTextureSize(64, 32);
Top.mirror = true;
setRotation(Top, 0F, 0F, 0F);
Bottom = new ModelRenderer(this, 21, 11);
Bottom.addBox(0F, 0F, 0F, 4, 6, 4);
Bottom.setRotationPoint(-2F, 18F, -2F);
Bottom.setTextureSize(64, 32);
Bottom.mirror = true;
setRotation(Bottom, 0F, 0F, 0F);
}
public void renderSide(int i)
{
this.renderSide(ForgeDirection.getOrientation(i));
}
public void renderSide(ForgeDirection side)
{
switch (side)
{
case UP:
Top.render(0.0625F);
break;
case DOWN:
Bottom.render(0.0625F);
break;
case NORTH:
Back.render(0.0625F);
break;
case SOUTH:
Front.render(0.0625F);
break;
case WEST:
Left.render(0.0625F);
break;
case EAST:
Right.render(0.0625F);
break;
default:
Middle.render(0.0625F);
break;
}
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
}

173
src/main/java/resonantinduction/old/client/model/ModelCrusher.java
View file

@ -1,173 +0,0 @@
// Date: 9/13/2013 10:47:00 PM
// Template version 1.1
// Java generated by Techne
// Keep in mind that you still need to fill in some blanks
// - ZeuX
package resonantinduction.old.client.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
public class ModelCrusher extends ModelBase
{
// fields
ModelRenderer base;
ModelRenderer front;
ModelRenderer back;
ModelRenderer leftSide;
ModelRenderer leftSide2;
ModelRenderer rightSide;
ModelRenderer rightSide2;
ModelRenderer leftCrusher;
ModelRenderer rightCrusher;
ModelRenderer leftPiston;
ModelRenderer rightPiston;
ModelRenderer buttonA;
ModelRenderer buttonB;
ModelRenderer top;
public ModelCrusher()
{
textureWidth = 128;
textureHeight = 128;
base = new ModelRenderer(this, 0, 110);
base.addBox(-8F, 0F, -8F, 16, 2, 16);
base.setRotationPoint(0F, 22F, 0F);
base.setTextureSize(128, 128);
base.mirror = true;
setRotation(base, 0F, 0F, 0F);
front = new ModelRenderer(this, 0, 30);
front.addBox(0F, 0F, 0F, 14, 5, 2);
front.setRotationPoint(-7F, 17F, -7F);
front.setTextureSize(128, 128);
front.mirror = true;
setRotation(front, 0F, 0F, 0F);
back = new ModelRenderer(this, 0, 50);
back.addBox(0F, 0F, 0F, 14, 5, 2);
back.setRotationPoint(-7F, 17F, 5F);
back.setTextureSize(128, 128);
back.mirror = true;
setRotation(back, 0F, 0F, 0F);
leftSide = new ModelRenderer(this, 104, 0);
leftSide.addBox(0F, 0F, 0F, 2, 12, 8);
leftSide.setRotationPoint(-7F, 10F, -4F);
leftSide.setTextureSize(128, 128);
leftSide.mirror = true;
setRotation(leftSide, 0F, 0F, 0F);
leftSide2 = new ModelRenderer(this, 104, 23);
leftSide2.addBox(0F, 0F, 0F, 1, 11, 7);
leftSide2.setRotationPoint(-8F, 11.33333F, -3.5F);
leftSide2.setTextureSize(128, 128);
leftSide2.mirror = true;
setRotation(leftSide2, 0F, 0F, 0F);
rightSide = new ModelRenderer(this, 80, 0);
rightSide.addBox(0F, 0F, 0F, 2, 12, 8);
rightSide.setRotationPoint(5F, 10F, -4F);
rightSide.setTextureSize(128, 128);
rightSide.mirror = true;
setRotation(rightSide, 0F, 0F, 0F);
rightSide2 = new ModelRenderer(this, 80, 23);
rightSide2.addBox(0F, 0F, 0F, 1, 11, 7);
rightSide2.setRotationPoint(7F, 11.33333F, -3.5F);
rightSide2.setTextureSize(128, 128);
rightSide2.mirror = true;
setRotation(rightSide2, 0F, 0F, 0F);
leftCrusher = new ModelRenderer(this, 104, 45);
leftCrusher.addBox(-1F, 0F, 0F, 2, 10, 10);
leftCrusher.setRotationPoint(-3F, 11F, -5F);
leftCrusher.setTextureSize(128, 128);
leftCrusher.mirror = true;
setRotation(leftCrusher, 0F, 0F, 0F);
rightCrusher = new ModelRenderer(this, 77, 45);
rightCrusher.addBox(1F, 0F, 0F, 2, 10, 10);
rightCrusher.setRotationPoint(1F, 11F, -5F);
rightCrusher.setTextureSize(128, 128);
rightCrusher.mirror = true;
setRotation(rightCrusher, 0F, 0F, 0F);
leftPiston = new ModelRenderer(this, 104, 68);
leftPiston.addBox(0F, 0F, 0F, 4, 4, 4);
leftPiston.setRotationPoint(-6F, 14F, -2F);
leftPiston.setTextureSize(128, 128);
leftPiston.mirror = true;
setRotation(leftPiston, 0F, 0F, 0F);
rightPiston = new ModelRenderer(this, 80, 68);
rightPiston.addBox(-2F, 0F, 0F, 4, 4, 4);
rightPiston.setRotationPoint(4F, 14F, -2F);
rightPiston.setTextureSize(128, 128);
rightPiston.mirror = true;
setRotation(rightPiston, 0F, 0F, 0F);
buttonA = new ModelRenderer(this, 0, 20);
buttonA.addBox(0F, 0F, 0F, 3, 2, 1);
buttonA.setRotationPoint(5F, 14F, 4F);
buttonA.setTextureSize(128, 128);
buttonA.mirror = true;
setRotation(buttonA, 0F, 0F, 0F);
buttonB = new ModelRenderer(this, 0, 25);
buttonB.addBox(0F, 0F, 0F, 3, 2, 1);
buttonB.setRotationPoint(-8F, 14F, -5F);
buttonB.setTextureSize(128, 128);
buttonB.mirror = true;
setRotation(buttonB, 0F, 0F, 0F);
top = new ModelRenderer(this, 0, 68);
top.addBox(0F, 0F, 0F, 12, 2, 6);
top.setRotationPoint(-6F, 9F, -3F);
top.setTextureSize(128, 128);
top.mirror = true;
setRotation(top, 0F, 0F, 0F);
}
public void renderBody(float f5)
{
base.render(f5);
front.render(f5);
back.render(f5);
leftSide.render(f5);
leftSide2.render(f5);
rightSide.render(f5);
rightSide2.render(f5);
buttonA.render(f5);
buttonB.render(f5);
top.render(f5);
leftPiston.render(f5);
rightPiston.render(f5);
}
public void renderPiston(float f5, int pos)
{
leftCrusher.setRotationPoint(-3F, 11F, -5F);
rightCrusher.setRotationPoint(1F, 11F, -5F);
if (pos > 8)
{
pos = 8;
}
if (pos < 0)
{
pos = 0;
}
float delta = pos / 4;
if (delta < 0)
{
delta = 0;
}
if (delta > 2)
{
delta = 2;
}
leftCrusher.setRotationPoint(-3F + delta, 11F, -5F);
rightCrusher.setRotationPoint(1F - delta, 11F, -5F);
leftCrusher.render(f5);
rightCrusher.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
}

89
src/main/java/resonantinduction/old/client/model/ModelElecFurnace.java
View file

@ -1,89 +0,0 @@
// Date: 9/21/2013 11:03:18 PM
// Template version 1.1
// Java generated by Techne
// Keep in mind that you still need to fill in some blanks
// - ZeuX
package resonantinduction.old.client.model;
import net.minecraft.client.model.ModelRenderer;
public class ModelElecFurnace extends ModelMachine
{
// fields
ModelRenderer body;
ModelRenderer top;
ModelRenderer bot;
ModelRenderer door;
ModelRenderer tube1;
ModelRenderer tube2;
ModelRenderer tube3;
public ModelElecFurnace()
{
textureWidth = 128;
textureHeight = 128;
body = new ModelRenderer(this, 0, 25);
body.addBox(-7.5F, 0F, -7.5F, 15, 12, 10);
body.setRotationPoint(0F, 10F, 1F);
body.setTextureSize(128, 128);
body.mirror = true;
setRotation(body, 0F, 0F, 0F);
top = new ModelRenderer(this, 0, 0);
top.addBox(-8F, 0F, -8F, 16, 2, 15);
top.setRotationPoint(0F, 8F, 1F);
top.setTextureSize(128, 128);
top.mirror = true;
setRotation(top, 0F, 0F, 0F);
bot = new ModelRenderer(this, 0, 56);
bot.addBox(-8F, 0F, -8F, 16, 2, 15);
bot.setRotationPoint(0F, 22F, 1F);
bot.setTextureSize(128, 128);
bot.mirror = true;
setRotation(bot, 0F, 0F, 0F);
door = new ModelRenderer(this, 0, 81);
door.addBox(-6F, 1F, -8.5F, 12, 10, 1);
door.setRotationPoint(0F, 10F, 1F);
door.setTextureSize(128, 128);
door.mirror = true;
setRotation(door, 0F, 0F, 0F);
tube1 = new ModelRenderer(this, 0, 99);
tube1.addBox(-7.5F, 0F, -7.5F, 3, 12, 4);
tube1.setRotationPoint(1F, 10F, 11F);
tube1.setTextureSize(128, 128);
tube1.mirror = true;
setRotation(tube1, 0F, 0F, 0F);
tube2 = new ModelRenderer(this, 34, 99);
tube2.addBox(-7.5F, 0F, -7.5F, 3, 12, 4);
tube2.setRotationPoint(11F, 10F, 11F);
tube2.setTextureSize(128, 128);
tube2.mirror = true;
setRotation(tube2, 0F, 0F, 0F);
tube3 = new ModelRenderer(this, 15, 99);
tube3.addBox(-7.5F, 0F, -7.5F, 5, 12, 4);
tube3.setRotationPoint(5F, 10F, 11F);
tube3.setTextureSize(128, 128);
tube3.mirror = true;
setRotation(tube3, 0F, 0F, 0F);
}
@Override
public void render(float f5)
{
body.render(f5);
top.render(f5);
bot.render(f5);
door.render(f5);
tube1.render(f5);
tube2.render(f5);
tube3.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
}

102
src/main/java/resonantinduction/old/client/model/ModelEngine.java
View file

@ -1,102 +0,0 @@
// Date: 8/24/2012 1:44:37 PM
// Template version 1.1
// Java generated by Techne
// Keep in mind that you still need to fill in some blanks
// - ZeuX
package resonantinduction.old.client.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class ModelEngine extends ModelBase
{
// fields
ModelRenderer Base;
ModelRenderer top;
ModelRenderer TopPiston;
ModelRenderer BottomPiston;
ModelRenderer center;
ModelRenderer C1;
ModelRenderer C2;
public ModelEngine()
{
textureWidth = 64;
textureHeight = 64;
Base = new ModelRenderer(this, 0, 20);
Base.addBox(-6F, 0F, -6F, 12, 8, 12);
Base.setRotationPoint(0F, 16F, 0F);
Base.setTextureSize(64, 64);
Base.mirror = true;
setRotation(Base, 0F, 0F, 0F);
top = new ModelRenderer(this, 0, 0);
top.addBox(-6F, 0F, -6F, 12, 8, 12);
top.setRotationPoint(0F, -8F, 0F);
top.setTextureSize(64, 64);
top.mirror = true;
setRotation(top, 0F, 0F, 0F);
TopPiston = new ModelRenderer(this, 0, 52);
TopPiston.addBox(-2F, 0F, -2F, 4, 8, 4);
TopPiston.setRotationPoint(0F, 0F, 0F);
TopPiston.setTextureSize(64, 64);
TopPiston.mirror = true;
setRotation(TopPiston, 0F, 0F, 0F);
BottomPiston = new ModelRenderer(this, 16, 52);
BottomPiston.addBox(-2F, 0F, -2F, 4, 8, 4);
BottomPiston.setRotationPoint(0F, 8F, 0F);
BottomPiston.setTextureSize(64, 64);
BottomPiston.mirror = true;
setRotation(BottomPiston, 0F, 0F, 0F);
center = new ModelRenderer(this, 32, 52);
center.addBox(-3F, 0F, -3F, 6, 6, 6);
// center.setRotationPoint(0F, 5F, 0F);
center.setTextureSize(64, 64);
center.mirror = true;
setRotation(center, 0F, 0F, 0F);
C1 = new ModelRenderer(this, 0, 41);
C1.addBox(-2F, -3F, 0F, 4, 6, 3);
C1.setRotationPoint(0F, 8F, 3F);
C1.setTextureSize(64, 64);
C1.mirror = true;
setRotation(C1, 0F, 0F, 0F);
C2 = new ModelRenderer(this, 15, 41);
C2.addBox(-2F, -3F, -3F, 4, 6, 3);
C2.setRotationPoint(0F, 8F, -3F);
C2.setTextureSize(64, 64);
C2.mirror = true;
setRotation(C2, 0F, 0F, 0F);
}
public void renderBot(float f5)
{
Base.render(f5);
BottomPiston.render(f5);
}
public void renderTop(float f5)
{
top.render(f5);
TopPiston.render(f5);
C1.render(f5);
C2.render(f5);
}
public void renderMid(float f5, float p)
{
center.setRotationPoint(0F, p, 0F);
center.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
}

97
src/main/java/resonantinduction/old/client/model/ModelFrackingPipe.java
View file

@ -1,97 +0,0 @@
package resonantinduction.old.client.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.entity.Entity;
public class ModelFrackingPipe extends ModelBase
{
ModelRenderer Back;
ModelRenderer Top;
ModelRenderer Left;
ModelRenderer Right;
ModelRenderer Front;
ModelRenderer Bottom;
ModelRenderer Pipe;
public ModelFrackingPipe()
{
textureWidth = 128;
textureHeight = 64;
Back = new ModelRenderer(this, 35, 18);
Back.addBox(0F, 0F, 0F, 14, 14, 1);
Back.setRotationPoint(-7F, 9F, 7F);
Back.setTextureSize(128, 64);
Back.mirror = true;
setRotation(Back, 0F, 0F, 0F);
Top = new ModelRenderer(this, 0, 0);
Top.addBox(0F, 0F, 0F, 16, 1, 16);
Top.setRotationPoint(-8F, 8F, -8F);
Top.setTextureSize(128, 64);
Top.mirror = true;
setRotation(Top, 0F, 0F, 0F);
Left = new ModelRenderer(this, 0, 18);
Left.addBox(0F, 0F, 0F, 1, 14, 16);
Left.setRotationPoint(-8F, 9F, -8F);
Left.setTextureSize(128, 64);
Left.mirror = true;
setRotation(Left, 0F, 0F, 0F);
Right = new ModelRenderer(this, 0, 18);
Right.addBox(0F, 0F, 0F, 1, 14, 16);
Right.setRotationPoint(7F, 9F, -8F);
Right.setTextureSize(128, 64);
Right.mirror = true;
setRotation(Right, 0F, 0F, 0F);
Front = new ModelRenderer(this, 35, 18);
Front.addBox(0F, 0F, 0F, 14, 14, 1);
Front.setRotationPoint(-7F, 9F, -8F);
Front.setTextureSize(128, 64);
Front.mirror = true;
setRotation(Front, 0F, 0F, 0F);
Bottom = new ModelRenderer(this, 0, 0);
Bottom.addBox(0F, 0F, 0F, 16, 1, 16);
Bottom.setRotationPoint(-8F, 23F, -8F);
Bottom.setTextureSize(128, 64);
Bottom.mirror = true;
setRotation(Bottom, 0F, 0F, 0F);
Pipe = new ModelRenderer(this, 35, 34);
Pipe.addBox(0F, 0F, 0F, 6, 14, 6);
Pipe.setRotationPoint(-3F, 9F, -3F);
Pipe.setTextureSize(128, 64);
Pipe.mirror = true;
setRotation(Pipe, 0F, 0F, 0F);
}
@Override
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);
}
public void renderAll()
{
Back.render(0.0625F);
Top.render(0.0625F);
Left.render(0.0625F);
Right.render(0.0625F);
Front.render(0.0625F);
Bottom.render(0.0625F);
Pipe.render(0.0625F);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
@Override
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);
}
}

69
src/main/java/resonantinduction/old/client/model/ModelFurnace.java
View file

@ -1,69 +0,0 @@
// Date: 8/14/2012 3:02:31 AM
// Template version 1.1
// Java generated by Techne
// Keep in mind that you still need to fill in some blanks
// - ZeuX
package resonantinduction.old.client.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class ModelFurnace extends ModelBase
{
// fields
ModelRenderer Body;
ModelRenderer top;
ModelRenderer bottom;
ModelRenderer Shape1;
public ModelFurnace()
{
textureWidth = 256;
textureHeight = 256;
Body = new ModelRenderer(this, 0, 0);
Body.addBox(-8F, -8F, -8F, 14, 14, 12);
Body.setRotationPoint(1F, 18F, 1F);
Body.setTextureSize(64, 32);
Body.mirror = true;
setRotation(Body, 0F, 0F, 0F);
top = new ModelRenderer(this, 80, 20);
top.addBox(-8F, 0F, -8F, 16, 2, 16);
top.setRotationPoint(0F, 8F, 0F);
top.setTextureSize(64, 32);
top.mirror = true;
setRotation(top, 0F, 0F, 0F);
bottom = new ModelRenderer(this, 80, 0);
bottom.addBox(-8F, 22F, -8F, 16, 2, 16);
bottom.setRotationPoint(0F, 0F, 0F);
bottom.setTextureSize(64, 32);
bottom.mirror = true;
setRotation(bottom, 0F, 0F, 0F);
Shape1 = new ModelRenderer(this, 0, 27);
Shape1.addBox(-4F, -4F, 0F, 10, 8, 1);
Shape1.setRotationPoint(-1F, 16F, 5F);
Shape1.setTextureSize(64, 32);
Shape1.mirror = true;
setRotation(Shape1, 0F, 0F, 0F);
}
public void genRender(float f5)
{
Body.render(f5);
top.render(f5);
bottom.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;
}
}

386
src/main/java/resonantinduction/old/client/model/ModelGearPiston.java
View file

@ -1,386 +0,0 @@
// Date: 10/1/2012 12:32:21 AM
// Template version 1.1
// Java generated by Techne
// Keep in mind that you still need to fill in some blanks
// - ZeuX
package resonantinduction.old.client.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class ModelGearPiston extends ModelBase
{
// fields
ModelRenderer PistonCover;
ModelRenderer RSpiston;
ModelRenderer LSpiston;
ModelRenderer RodPiston;
ModelRenderer Base;
ModelRenderer Front;
ModelRenderer BackCC;
ModelRenderer RightPipe;
ModelRenderer FrontCC;
ModelRenderer LeftCC;
ModelRenderer FrontPipe;
ModelRenderer Right;
ModelRenderer RightCC;
ModelRenderer Back;
ModelRenderer BackPipe;
ModelRenderer Left;
ModelRenderer LeftPipe;
ModelRenderer RigthF4;
ModelRenderer LeftF4;
ModelRenderer LeftF3;
ModelRenderer LeftF2;
ModelRenderer LeftF1;
ModelRenderer RigthF3;
ModelRenderer RigthF2;
ModelRenderer RigthF1;
ModelRenderer RigthGCC;
ModelRenderer RightSlide;
ModelRenderer midRod;
ModelRenderer RightRod2;
ModelRenderer LeftGCC;
ModelRenderer LeftRod2;
ModelRenderer LeftSlide2;
public ModelGearPiston()
{
textureWidth = 128;
textureHeight = 128;
PistonCover = new ModelRenderer(this, 13, 31);
PistonCover.addBox(0F, -9F, -3F, 6, 10, 6);
PistonCover.setRotationPoint(-3F, 20F, 0F);
PistonCover.setTextureSize(128, 128);
PistonCover.mirror = true;
setRotation(PistonCover, 0F, 0F, 0F);
RSpiston = new ModelRenderer(this, 0, 32);
RSpiston.addBox(-3F, -2F, -2F, 1, 7, 4);
RSpiston.setRotationPoint(1F, 3F, 0F);
RSpiston.setTextureSize(128, 128);
RSpiston.mirror = true;
setRotation(RSpiston, 0F, 0F, 0F);
LSpiston = new ModelRenderer(this, 0, 32);
LSpiston.addBox(-1F, -2F, -2F, 1, 7, 4);
LSpiston.setRotationPoint(2F, 3F, 0F);
LSpiston.setTextureSize(128, 128);
LSpiston.mirror = true;
setRotation(LSpiston, 0F, 0F, 0F);
RodPiston = new ModelRenderer(this, 0, 59);
RodPiston.addBox(-1F, -2F, -1.5F, 2, 13, 3);
RodPiston.setRotationPoint(0F, 8F, 0F);
RodPiston.setTextureSize(128, 128);
RodPiston.mirror = true;
setRotation(RodPiston, 0F, 0F, 0F);
Base = new ModelRenderer(this, 12, 49);
Base.addBox(0F, 0F, 0F, 10, 5, 10);
Base.setRotationPoint(-5F, 19F, -5F);
Base.setTextureSize(128, 128);
Base.mirror = true;
setRotation(Base, 0F, 0F, 0F);
Front = new ModelRenderer(this, 28, 68);
Front.addBox(-3F, 0F, 0F, 6, 12, 1);
Front.setRotationPoint(0F, 12F, -7F);
Front.setTextureSize(128, 128);
Front.mirror = true;
setRotation(Front, 0F, 0F, 0F);
BackCC = new ModelRenderer(this, 43, 68);
BackCC.addBox(-2F, -2F, 1F, 4, 4, 1);
BackCC.setRotationPoint(0F, 16F, 6F);
BackCC.setTextureSize(128, 128);
BackCC.mirror = true;
setRotation(BackCC, 0F, 0F, 0F);
RightPipe = new ModelRenderer(this, 12, 87);
RightPipe.addBox(0F, 0F, -2F, 2, 10, 4);
RightPipe.setRotationPoint(-6F, 14F, 0F);
RightPipe.setTextureSize(128, 128);
RightPipe.mirror = true;
setRotation(RightPipe, 0F, 0F, 0F);
FrontCC = new ModelRenderer(this, 43, 68);
FrontCC.addBox(-2F, -2F, -1F, 4, 4, 1);
FrontCC.setRotationPoint(0F, 16F, -7F);
FrontCC.setTextureSize(128, 128);
FrontCC.mirror = true;
setRotation(FrontCC, 0F, 0F, 0F);
LeftCC = new ModelRenderer(this, 43, 74);
LeftCC.addBox(0F, -2F, -2F, 1, 4, 4);
LeftCC.setRotationPoint(7F, 16F, 0F);
LeftCC.setTextureSize(128, 128);
LeftCC.mirror = true;
setRotation(LeftCC, 0F, 0F, 0F);
FrontPipe = new ModelRenderer(this, 28, 82);
FrontPipe.addBox(-2F, 0F, 0F, 4, 10, 2);
FrontPipe.setRotationPoint(0F, 14F, -6F);
FrontPipe.setTextureSize(128, 128);
FrontPipe.mirror = true;
setRotation(FrontPipe, 0F, 0F, 0F);
Right = new ModelRenderer(this, 12, 68);
Right.addBox(0F, 0F, -3F, 1, 12, 6);
Right.setRotationPoint(-7F, 12F, 0F);
Right.setTextureSize(128, 128);
Right.mirror = true;
setRotation(Right, 0F, 0F, 0F);
RightCC = new ModelRenderer(this, 43, 74);
RightCC.addBox(-1F, -2F, -2F, 1, 4, 4);
RightCC.setRotationPoint(-7F, 16F, 0F);
RightCC.setTextureSize(128, 128);
RightCC.mirror = true;
setRotation(RightCC, 0F, 0F, 0F);
Back = new ModelRenderer(this, 28, 68);
Back.addBox(-3F, 0F, 0F, 6, 12, 1);
Back.setRotationPoint(0F, 12F, 6F);
Back.setTextureSize(128, 128);
Back.mirror = true;
setRotation(Back, 0F, 0F, 0F);
BackPipe = new ModelRenderer(this, 28, 82);
BackPipe.addBox(-2F, 0F, -2F, 4, 10, 2);
BackPipe.setRotationPoint(0F, 14F, 6F);
BackPipe.setTextureSize(128, 128);
BackPipe.mirror = true;
setRotation(BackPipe, 0F, 0F, 0F);
Left = new ModelRenderer(this, 12, 68);
Left.addBox(0F, 0F, -3F, 1, 12, 6);
Left.setRotationPoint(6F, 12F, 0F);
Left.setTextureSize(128, 128);
Left.mirror = true;
setRotation(Left, 0F, 0F, 0F);
LeftPipe = new ModelRenderer(this, 12, 87);
LeftPipe.addBox(-2F, 0F, -2F, 2, 10, 4);
LeftPipe.setRotationPoint(6F, 14F, 0F);
LeftPipe.setTextureSize(128, 128);
LeftPipe.mirror = true;
setRotation(LeftPipe, 0F, 0F, 0F);
RigthF4 = new ModelRenderer(this, 0, 56);
RigthF4.addBox(-2F, 1F, 1F, 2, 1, 1);
RigthF4.setRotationPoint(-8F, 0F, 0F);
RigthF4.setTextureSize(128, 128);
RigthF4.mirror = true;
setRotation(RigthF4, 0F, 0F, 0F);
LeftF4 = new ModelRenderer(this, 0, 56);
LeftF4.addBox(0F, 1F, 1F, 2, 1, 1);
LeftF4.setRotationPoint(8F, 0F, 0F);
LeftF4.setTextureSize(128, 128);
LeftF4.mirror = true;
setRotation(LeftF4, 0.7853982F, 0F, 0F);
LeftF3 = new ModelRenderer(this, 0, 56);
LeftF3.addBox(0F, 1F, -2F, 2, 1, 1);
LeftF3.setRotationPoint(8F, 0F, 0F);
LeftF3.setTextureSize(128, 128);
LeftF3.mirror = true;
setRotation(LeftF3, 0.7853982F, 0F, 0F);
LeftF2 = new ModelRenderer(this, 0, 56);
LeftF2.addBox(0F, -2F, -2F, 2, 1, 1);
LeftF2.setRotationPoint(8F, 0F, 0F);
LeftF2.setTextureSize(128, 128);
LeftF2.mirror = true;
setRotation(LeftF2, 0.7853982F, 0F, 0F);
LeftF1 = new ModelRenderer(this, 0, 56);
LeftF1.addBox(0F, -2F, 1F, 2, 1, 1);
LeftF1.setRotationPoint(8F, 0F, 0F);
LeftF1.setTextureSize(128, 128);
LeftF1.mirror = true;
setRotation(LeftF1, 0.7853982F, 0F, 0F);
RigthF3 = new ModelRenderer(this, 0, 56);
RigthF3.addBox(-2F, 1F, -2F, 2, 1, 1);
RigthF3.setRotationPoint(-8F, 0F, 0F);
RigthF3.setTextureSize(128, 128);
RigthF3.mirror = true;
setRotation(RigthF3, 0F, 0F, 0F);
RigthF2 = new ModelRenderer(this, 0, 56);
RigthF2.addBox(-2F, -2F, 1F, 2, 1, 1);
RigthF2.setRotationPoint(-8F, 0F, 0F);
RigthF2.setTextureSize(128, 128);
RigthF2.mirror = true;
setRotation(RigthF2, 0F, 0F, 0F);
RigthF1 = new ModelRenderer(this, 0, 56);
RigthF1.addBox(-2F, -2F, -2F, 2, 1, 1);
RigthF1.setRotationPoint(-8F, 0F, 0F);
RigthF1.setTextureSize(128, 128);
RigthF1.mirror = true;
setRotation(RigthF1, 0F, 0F, 0F);
RigthGCC = new ModelRenderer(this, 12, 18);
RigthGCC.addBox(-2F, -2F, -2F, 2, 4, 4);
RigthGCC.setRotationPoint(-6F, 0F, 0F);
RigthGCC.setTextureSize(128, 128);
RigthGCC.mirror = true;
setRotation(RigthGCC, 0F, 0F, 0F);
RightSlide = new ModelRenderer(this, 0, 44);
RightSlide.addBox(0F, -2F, -2F, 1, 7, 4);
RightSlide.setRotationPoint(-4F, 0F, 0F);
RightSlide.setTextureSize(128, 128);
RightSlide.mirror = true;
setRotation(RightSlide, 0F, 0F, 0F);
LeftSlide2 = new ModelRenderer(this, 0, 27);
LeftSlide2.addBox(0F, 2F, -1F, 6, 2, 2);
LeftSlide2.setRotationPoint(-3F, 0F, 0F);
LeftSlide2.setTextureSize(128, 128);
LeftSlide2.mirror = true;
setRotation(LeftSlide2, 0F, 0F, 0F);
RightRod2 = new ModelRenderer(this, 0, 20);
RightRod2.addBox(0F, -1.5F, -1.5F, 2, 3, 3);
RightRod2.setRotationPoint(-6F, 0F, 0F);
RightRod2.setTextureSize(128, 128);
RightRod2.mirror = true;
setRotation(RightRod2, 0F, 0F, 0F);
LeftGCC = new ModelRenderer(this, 24, 18);
LeftGCC.addBox(-1F, -2F, -2F, 2, 4, 4);
LeftGCC.setRotationPoint(7F, 0F, 0F);
LeftGCC.setTextureSize(128, 128);
LeftGCC.mirror = true;
setRotation(LeftGCC, 0.7853982F, 0F, 0F);
LeftRod2 = new ModelRenderer(this, 0, 20);
LeftRod2.addBox(-3F, -1.5F, -1.5F, 2, 3, 3);
LeftRod2.setRotationPoint(7F, 0F, 0F);
LeftRod2.setTextureSize(128, 128);
LeftRod2.mirror = true;
setRotation(LeftRod2, 0F, 0F, 0F);
midRod = new ModelRenderer(this, 0, 32);
midRod.addBox(-1F, -2F, -2F, 1, 7, 4);
midRod.setRotationPoint(4F, 0F, 0F);
midRod.setTextureSize(128, 128);
midRod.mirror = true;
setRotation(midRod, 0F, 0F, 0F);
}
public void renderBody(float f5)
{
Base.render(f5);
PistonCover.render(f5);
}
public void renderGear(float f5)
{
// Rod connectors
LeftF4.render(f5);
LeftF3.render(f5);
LeftF2.render(f5);
LeftF1.render(f5);
RigthF4.render(f5);
RigthF3.render(f5);
RigthF2.render(f5);
RigthF1.render(f5);
RigthGCC.render(f5);
LeftGCC.render(f5);
}
public void renderR(float f5, int pos)
{
switch (pos)
{
case 0:
RSpiston.setRotationPoint(1F, 3F, 0F);
LSpiston.setRotationPoint(2F, 3F, 0F);
RodPiston.setRotationPoint(0F, 8F, 0F);
setRotation(RSpiston, 0F, 0F, 0F);
setRotation(LSpiston, 0F, 0F, 0F);
break;
case 1:
RodPiston.setRotationPoint(0F, 6F, 0F);
LSpiston.setRotationPoint(2F, 2F, 2F);
RSpiston.setRotationPoint(1F, 2F, 2F);
setRotation(LSpiston, -0.5235988F, 0F, 0F);
setRotation(RSpiston, -0.5235988F, 0F, 0F);
break;
case 2:
LSpiston.setRotationPoint(2F, 0F, 3F);
RSpiston.setRotationPoint(1F, 0F, 3F);
RodPiston.setRotationPoint(0F, 3F, 0F);
setRotation(RSpiston, -1.047198F, 0F, 0F);
setRotation(LSpiston, -1.047198F, 0F, 0F);
break;
case 3:
LSpiston.setRotationPoint(2F, -2F, 2F);
RSpiston.setRotationPoint(1F, -2F, 2F);
RodPiston.setRotationPoint(0F, 1F, 0F);
setRotation(LSpiston, -0.7853982F, 0F, 0F);
setRotation(RSpiston, -0.7853982F, 0F, 0F);
break;
case 4:
LSpiston.setRotationPoint(2F, -3F, 0F);
RSpiston.setRotationPoint(1F, -3F, 0F);
RodPiston.setRotationPoint(0F, 1F, 0F);
setRotation(LSpiston, 0F, 0F, 0F);
setRotation(RSpiston, 0F, 0F, 0F);
break;
case 5:
LSpiston.setRotationPoint(2F, -2F, -2F);
RSpiston.setRotationPoint(1F, -2F, -2F);
RodPiston.setRotationPoint(0F, 1F, 0F);
setRotation(LSpiston, 0.7853982F, 0F, 0F);
setRotation(RSpiston, 0.7853982F, 0F, 0F);
break;
case 6:
RSpiston.setRotationPoint(1F, 0F, -3F);
LSpiston.setRotationPoint(2F, 0F, -3F);
RodPiston.setRotationPoint(0F, 2F, 0F);
setRotation(RSpiston, 1.047198F, 0F, 0F);
setRotation(LSpiston, 1.047198F, 0F, 0F);
break;
case 7:
RodPiston.setRotationPoint(0F, 6F, 0F);
LSpiston.setRotationPoint(2F, 2F, -2F);
RSpiston.setRotationPoint(1F, 2F, -2F);
setRotation(LSpiston, 0.5235988F, 0F, 0F);
setRotation(RSpiston, 0.5235988F, 0F, 0F);
break;
}
// Piston Arm
RSpiston.render(f5);
LSpiston.render(f5);
RodPiston.render(f5);
// GearShaft
RightSlide.rotateAngleX = 0.7853982F * pos;
midRod.rotateAngleX = 0.7853982F * pos;
midRod.rotateAngleX = 0.7853982F * pos;
RightRod2.rotateAngleX = 0.7853982F * pos;
LeftRod2.rotateAngleX = 0.7853982F * pos;
LeftSlide2.rotateAngleX = 0.7853982F * pos;
RightSlide.render(f5);
midRod.render(f5);
RightRod2.render(f5);
LeftRod2.render(f5);
LeftSlide2.render(f5);
}
public void renderLeft(float f5)
{
Left.render(f5);
LeftPipe.render(f5);
LeftCC.render(f5);
}
public void renderRight(float f5)
{
Right.render(f5);
RightCC.render(f5);
RightPipe.render(f5);
}
public void renderFront(float f5)
{
Front.render(f5);
FrontCC.render(f5);
FrontPipe.render(f5);
}
public void renderBack(float f5)
{
Back.render(f5);
BackPipe.render(f5);
BackCC.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
}

139
src/main/java/resonantinduction/old/client/model/ModelGearRod.java
View file

@ -1,139 +0,0 @@
// Date: 9/25/2012 4:29:17 PM
// Template version 1.1
// Java generated by Techne
// Keep in mind that you still need to fill in some blanks
// - ZeuX
package resonantinduction.old.client.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class ModelGearRod extends ModelBase
{
// fields
ModelRenderer Rod;
ModelRenderer front;
ModelRenderer back;
ModelRenderer f2;
ModelRenderer b2;
ModelRenderer b3;
ModelRenderer b4;
ModelRenderer b1;
ModelRenderer f1;
ModelRenderer f4;
ModelRenderer f3;
ModelRenderer Rod2;
public ModelGearRod()
{
textureWidth = 64;
textureHeight = 32;
Rod = new ModelRenderer(this, 0, 0);
Rod.addBox(-1.5F, -1.5F, 0F, 3, 3, 12);
Rod.setRotationPoint(0F, 16F, -6F);
Rod.setTextureSize(64, 32);
Rod.mirror = true;
setRotation(Rod, 0F, 0F, 0F);
front = new ModelRenderer(this, 35, 0);
front.addBox(-2F, -2F, -2F, 4, 4, 2);
front.setRotationPoint(0F, 16F, -6F);
front.setTextureSize(64, 32);
front.mirror = true;
setRotation(front, 0F, 0F, 0F);
back = new ModelRenderer(this, 35, 0);
back.addBox(-2F, -2F, 0F, 4, 4, 2);
back.setRotationPoint(0F, 16F, 6F);
back.setTextureSize(64, 32);
back.mirror = true;
setRotation(back, 0F, 0F, 0.7853982F);
f2 = new ModelRenderer(this, 0, 17);
f2.addBox(0F, 0F, 0F, 1, 1, 2);
f2.setRotationPoint(1F, 17F, -10F);
f2.setTextureSize(64, 32);
f2.mirror = true;
setRotation(f2, 0F, 0F, 0F);
b2 = new ModelRenderer(this, 0, 17);
b2.addBox(-0.5F, -0.5F, 0F, 1, 1, 2);
b2.setRotationPoint(0F, 18F, 8F);
b2.setTextureSize(64, 32);
b2.mirror = true;
setRotation(b2, 0F, 0F, 0.7853982F);
b3 = new ModelRenderer(this, 0, 17);
b3.addBox(-0.5F, -0.5F, 0F, 1, 1, 2);
b3.setRotationPoint(-2F, 16F, 8F);
b3.setTextureSize(64, 32);
b3.mirror = true;
setRotation(b3, 0F, 0F, 0.7853982F);
b4 = new ModelRenderer(this, 0, 17);
b4.addBox(-0.5F, -0.5F, 0F, 1, 1, 2);
b4.setRotationPoint(2F, 16F, 8F);
b4.setTextureSize(64, 32);
b4.mirror = true;
setRotation(b4, 0F, 0F, 0.7853982F);
b1 = new ModelRenderer(this, 0, 17);
b1.addBox(-0.5F, -0.5F, 0F, 1, 1, 2);
b1.setRotationPoint(0F, 14F, 8F);
b1.setTextureSize(64, 32);
b1.mirror = true;
setRotation(b1, 0F, 0F, 0.7853982F);
f1 = new ModelRenderer(this, 0, 17);
f1.addBox(0F, 0F, 0F, 1, 1, 2);
f1.setRotationPoint(1F, 14F, -10F);
f1.setTextureSize(64, 32);
f1.mirror = true;
setRotation(f1, 0F, 0F, 0F);
f4 = new ModelRenderer(this, 0, 17);
f4.addBox(0F, 0F, 0F, 1, 1, 2);
f4.setRotationPoint(-2F, 17F, -10F);
f4.setTextureSize(64, 32);
f4.mirror = true;
setRotation(f4, 0F, 0F, 0F);
f3 = new ModelRenderer(this, 0, 17);
f3.addBox(0F, 0F, 0F, 1, 1, 2);
f3.setRotationPoint(-2F, 14F, -10F);
f3.setTextureSize(64, 32);
f3.mirror = true;
setRotation(f3, 0F, 0F, 0F);
Rod2 = new ModelRenderer(this, 0, 0);
Rod2.addBox(-1.5F, -1.5F, 0F, 3, 3, 12);
Rod2.setRotationPoint(0F, 16F, -6F);
Rod2.setTextureSize(64, 32);
Rod2.mirror = true;
setRotation(Rod2, 0F, 0F, 0.7853982F);
}
public void render(float f5, int pos)
{
// Rod.rotateAngleZ = 45 * tileEntity;
Rod2.rotateAngleZ = Rod.rotateAngleZ + 45;
Rod.render(f5);
Rod2.render(f5);
// TODO add rotation to rods
front.render(f5);
back.render(f5);
f2.render(f5);
b2.render(f5);
b3.render(f5);
b4.render(f5);
b1.render(f5);
f1.render(f5);
f4.render(f5);
f3.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
}

193
src/main/java/resonantinduction/old/client/model/ModelGenerator.java
View file

@ -1,193 +0,0 @@
// Date: 12/23/2012 8:44:55 PM
// Template version 1.1
// Java generated by Techne
// Keep in mind that you still need to fill in some blanks
// - ZeuX
package resonantinduction.old.client.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.tileentity.TileEntity;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class ModelGenerator extends ModelBase
{
// fields
ModelRenderer Bottom;
ModelRenderer Left;
ModelRenderer CenterRod;
ModelRenderer Right;
ModelRenderer RightTopCorner;
ModelRenderer LeftTopCorner;
ModelRenderer LeftBottomCorner;
ModelRenderer RightBottomCorner;
ModelRenderer BottomCase;
ModelRenderer TopCase;
ModelRenderer LeftBrace;
ModelRenderer RightBrace;
ModelRenderer BackBracer;
ModelRenderer FrontBracer;
ModelRenderer FrontDisc;
ModelRenderer FrontDisc2;
ModelRenderer BackDisc;
ModelRenderer BackDisc2;
public ModelGenerator()
{
textureWidth = 128;
textureHeight = 128;
Bottom = new ModelRenderer(this, 0, 74);
Bottom.addBox(-7F, -1F, -7F, 14, 2, 14);
Bottom.setRotationPoint(0F, 23F, 0F);
Bottom.setTextureSize(128, 128);
Bottom.mirror = true;
setRotation(Bottom, 0F, 0F, 0F);
Left = new ModelRenderer(this, 17, 49);
Left.addBox(-1F, -4F, -3F, 2, 8, 6);
Left.setRotationPoint(7F, 15F, 0F);
Left.setTextureSize(128, 128);
Left.mirror = true;
setRotation(Left, 0F, 0F, 0F);
CenterRod = new ModelRenderer(this, 62, 0);
CenterRod.addBox(-1.5F, -1.5F, -8F, 3, 3, 16);
CenterRod.setRotationPoint(0F, 15F, 0F);
CenterRod.setTextureSize(128, 128);
CenterRod.mirror = true;
setRotation(CenterRod, 0F, 0F, 0F);
Right = new ModelRenderer(this, 0, 49);
Right.addBox(-1F, -4F, -3F, 2, 8, 6);
Right.setRotationPoint(-7F, 15F, 0F);
Right.setTextureSize(128, 128);
Right.mirror = true;
setRotation(Right, 0F, 0F, 0F);
RightTopCorner = new ModelRenderer(this, 0, 35);
RightTopCorner.addBox(-2F, -6F, -3F, 2, 6, 6);
RightTopCorner.setRotationPoint(-7F, 13F, 0F);
RightTopCorner.setTextureSize(128, 128);
RightTopCorner.mirror = true;
setRotation(RightTopCorner, 0F, 0F, 1.047198F);
LeftTopCorner = new ModelRenderer(this, 17, 35);
LeftTopCorner.addBox(0F, -6F, -3F, 2, 6, 6);
LeftTopCorner.setRotationPoint(7F, 13F, 0F);
LeftTopCorner.setTextureSize(128, 128);
LeftTopCorner.mirror = true;
setRotation(LeftTopCorner, 0F, 0F, -1.047198F);
LeftBottomCorner = new ModelRenderer(this, 17, 91);
LeftBottomCorner.addBox(0F, 0F, -3F, 2, 6, 6);
LeftBottomCorner.setRotationPoint(7F, 17F, 0F);
LeftBottomCorner.setTextureSize(128, 128);
LeftBottomCorner.mirror = true;
setRotation(LeftBottomCorner, 0F, 0F, 1.047198F);
RightBottomCorner = new ModelRenderer(this, 0, 91);
RightBottomCorner.addBox(-2F, 0F, -3F, 2, 6, 6);
RightBottomCorner.setRotationPoint(-7F, 17F, 0F);
RightBottomCorner.setTextureSize(128, 128);
RightBottomCorner.mirror = true;
setRotation(RightBottomCorner, 0F, 0F, -1.047198F);
BottomCase = new ModelRenderer(this, 3, 64);
BottomCase.addBox(0F, 0F, -3F, 6, 2, 6);
BottomCase.setRotationPoint(-3F, 20F, 0F);
BottomCase.setTextureSize(128, 128);
BottomCase.mirror = true;
setRotation(BottomCase, 0F, 0F, 0F);
TopCase = new ModelRenderer(this, 3, 26);
TopCase.addBox(0F, 0F, -3F, 6, 2, 6);
TopCase.setRotationPoint(-3F, 8F, 0F);
TopCase.setTextureSize(128, 128);
TopCase.mirror = true;
setRotation(TopCase, 0F, 0F, 0F);
LeftBrace = new ModelRenderer(this, 44, 64);
LeftBrace.addBox(0F, 0F, -1.5F, 3, 6, 3);
LeftBrace.setRotationPoint(3F, 17F, 0F);
LeftBrace.setTextureSize(128, 128);
LeftBrace.mirror = true;
setRotation(LeftBrace, 0F, 0F, 0F);
RightBrace = new ModelRenderer(this, 31, 64);
RightBrace.addBox(0F, 0F, -1.5F, 3, 6, 3);
RightBrace.setRotationPoint(-6F, 17F, 0F);
RightBrace.setTextureSize(128, 128);
RightBrace.mirror = true;
setRotation(RightBrace, 0F, 0F, 0F);
BackBracer = new ModelRenderer(this, 50, 0);
BackBracer.addBox(-2F, -3F, 5F, 4, 10, 1);
BackBracer.setRotationPoint(0F, 15F, 0F);
BackBracer.setTextureSize(128, 128);
BackBracer.mirror = true;
setRotation(BackBracer, 0F, 0F, 0F);
FrontBracer = new ModelRenderer(this, 50, 0);
FrontBracer.addBox(-2F, -3F, -6F, 4, 10, 1);
FrontBracer.setRotationPoint(0F, 15F, 0F);
FrontBracer.setTextureSize(128, 128);
FrontBracer.mirror = true;
setRotation(FrontBracer, 0F, 0F, 0F);
FrontDisc = new ModelRenderer(this, 65, 25);
FrontDisc.addBox(-5F, -5F, -5F, 10, 10, 2);
FrontDisc.setRotationPoint(0F, 15F, 0F);
FrontDisc.setTextureSize(128, 128);
FrontDisc.mirror = true;
setRotation(FrontDisc, 0F, 0F, 0.7853982F);
FrontDisc2 = new ModelRenderer(this, 65, 25);
FrontDisc2.addBox(-5F, -5F, -5F, 10, 10, 2);
FrontDisc2.setRotationPoint(0F, 15F, 0F);
FrontDisc2.setTextureSize(128, 128);
FrontDisc2.mirror = true;
setRotation(FrontDisc2, 0F, 0F, 0F);
BackDisc = new ModelRenderer(this, 65, 25);
BackDisc.addBox(-5F, -5F, 3F, 10, 10, 2);
BackDisc.setRotationPoint(0F, 15F, 0F);
BackDisc.setTextureSize(128, 128);
BackDisc.mirror = true;
setRotation(BackDisc, 0F, 0F, 0.7853982F);
BackDisc2 = new ModelRenderer(this, 65, 25);
BackDisc2.addBox(-5F, -5F, 3F, 10, 10, 2);
BackDisc2.setRotationPoint(0F, 15F, 0F);
BackDisc2.setTextureSize(128, 128);
BackDisc2.mirror = true;
setRotation(BackDisc2, 0F, 0F, 0F);
}
public void render(TileEntity ent)
{
float f5 = 0.0625F;
// noMoving renderParts
Bottom.render(f5);
Left.render(f5);
CenterRod.render(f5);
Right.render(f5);
RightTopCorner.render(f5);
LeftTopCorner.render(f5);
LeftBottomCorner.render(f5);
RightBottomCorner.render(f5);
BottomCase.render(f5);
TopCase.render(f5);
LeftBrace.render(f5);
RightBrace.render(f5);
BackBracer.render(f5);
FrontBracer.render(f5);
// Moving parts
float pos = 0;
// change
FrontDisc.rotateAngleZ = (float) Math.toRadians(pos);
FrontDisc2.rotateAngleZ = (float) Math.toRadians(pos + 45);
BackDisc.rotateAngleZ = (float) Math.toRadians(pos);
BackDisc2.rotateAngleZ = (float) Math.toRadians(pos + 45);
FrontDisc.render(f5);
FrontDisc2.render(f5);
BackDisc.render(f5);
BackDisc2.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
}

221
src/main/java/resonantinduction/old/client/model/ModelGrinder.java
View file

@ -1,221 +0,0 @@
// Date: 9/17/2013 12:00:07 AM
// Template version 1.1
// Java generated by Techne
// Keep in mind that you still need to fill in some blanks
// - ZeuX
package resonantinduction.old.client.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
public class ModelGrinder extends ModelBase
{
// fields
ModelRenderer base;
ModelRenderer rightSide;
ModelRenderer leftSide;
ModelRenderer front;
ModelRenderer back;
ModelRenderer top;
ModelRenderer uDisk1;
ModelRenderer uDisk2;
ModelRenderer uDisk3;
ModelRenderer uDisk4;
ModelRenderer uDisk5;
ModelRenderer uDisk6;
ModelRenderer dDisk1;
ModelRenderer dDisk2;
ModelRenderer dDisk3;
ModelRenderer dDisk4;
ModelRenderer dDisk5;
ModelRenderer dDisk6;
ModelRenderer[] topDiskSet;
ModelRenderer[] bottomDiskSet;
public ModelGrinder()
{
textureWidth = 128;
textureHeight = 128;
base = new ModelRenderer(this, 1, 109);
base.addBox(-8F, 0F, -8F, 16, 2, 16);
base.setRotationPoint(0F, 22F, 0F);
base.setTextureSize(128, 128);
base.mirror = true;
setRotation(base, 0F, 0F, 0F);
rightSide = new ModelRenderer(this, 0, 80);
rightSide.addBox(0F, 0F, 0F, 2, 13, 13);
rightSide.setRotationPoint(-8F, 9F, -6F);
rightSide.setTextureSize(128, 128);
rightSide.mirror = true;
setRotation(rightSide, 0F, 0F, 0F);
leftSide = new ModelRenderer(this, 40, 80);
leftSide.addBox(0F, 0F, 0F, 2, 13, 13);
leftSide.setRotationPoint(6F, 9F, -6F);
leftSide.setTextureSize(128, 128);
leftSide.mirror = true;
setRotation(leftSide, 0F, 0F, 0F);
front = new ModelRenderer(this, 78, 114);
front.addBox(-8F, 0F, -8F, 16, 5, 2);
front.setRotationPoint(0F, 17F, 0F);
front.setTextureSize(128, 128);
front.mirror = true;
setRotation(front, 0F, 0F, 0F);
back = new ModelRenderer(this, 78, 95);
back.addBox(-8F, 0F, -3F, 16, 13, 1);
back.setRotationPoint(0F, 9F, 10F);
back.setTextureSize(128, 128);
back.mirror = true;
setRotation(back, 0F, 0F, 0F);
top = new ModelRenderer(this, 1, 65);
top.addBox(-8F, 0F, -8F, 14, 1, 10);
top.setRotationPoint(1F, 8F, 5F);
top.setTextureSize(128, 128);
top.mirror = true;
setRotation(top, 0F, 0F, 0F);
uDisk1 = new ModelRenderer(this, 0, 0);
uDisk1.addBox(0F, -4F, -4F, 1, 8, 8);
uDisk1.setRotationPoint(-6F, 14F, 1F);
uDisk1.setTextureSize(128, 128);
uDisk1.mirror = true;
setRotation(uDisk1, 0.7853982F, 0F, 0F);
uDisk2 = new ModelRenderer(this, 0, 0);
uDisk2.addBox(0F, -4F, -4F, 1, 8, 8);
uDisk2.setRotationPoint(-4F, 14F, 1F);
uDisk2.setTextureSize(128, 128);
uDisk2.mirror = true;
setRotation(uDisk2, 0F, 0F, 0F);
uDisk3 = new ModelRenderer(this, 0, 0);
uDisk3.addBox(4F, -4F, -4F, 1, 8, 8);
uDisk3.setRotationPoint(-6F, 14F, 1F);
uDisk3.setTextureSize(128, 128);
uDisk3.mirror = true;
setRotation(uDisk3, 0.7853982F, 0F, 0F);
uDisk4 = new ModelRenderer(this, 0, 0);
uDisk4.addBox(6F, -4F, -4F, 1, 8, 8);
uDisk4.setRotationPoint(-6F, 14F, 1F);
uDisk4.setTextureSize(128, 128);
uDisk4.mirror = true;
setRotation(uDisk4, 0F, 0F, 0F);
uDisk5 = new ModelRenderer(this, 0, 0);
uDisk5.addBox(8F, -4F, -4F, 1, 8, 8);
uDisk5.setRotationPoint(-6F, 14F, 1F);
uDisk5.setTextureSize(128, 128);
uDisk5.mirror = true;
setRotation(uDisk5, 0.7853982F, 0F, 0F);
uDisk6 = new ModelRenderer(this, 0, 0);
uDisk6.addBox(10F, -4F, -4F, 1, 8, 8);
uDisk6.setRotationPoint(-6F, 14F, 1F);
uDisk6.setTextureSize(128, 128);
uDisk6.mirror = true;
setRotation(uDisk6, 0F, 0F, 0F);
dDisk1 = new ModelRenderer(this, 0, 0);
dDisk1.addBox(0F, -4F, -4F, 1, 8, 8);
dDisk1.setRotationPoint(-5F, 17F, 0F);
dDisk1.setTextureSize(128, 128);
dDisk1.mirror = true;
setRotation(dDisk1, 0F, 0F, 0F);
dDisk2 = new ModelRenderer(this, 0, 0);
dDisk2.addBox(2F, -4F, -4F, 1, 8, 8);
dDisk2.setRotationPoint(-5F, 17F, 0F);
dDisk2.setTextureSize(128, 128);
dDisk2.mirror = true;
setRotation(dDisk2, 0.7853982F, 0F, 0F);
dDisk3 = new ModelRenderer(this, 0, 0);
dDisk3.addBox(4F, -4F, -4F, 1, 8, 8);
dDisk3.setRotationPoint(-5F, 17F, 0F);
dDisk3.setTextureSize(128, 128);
dDisk3.mirror = true;
setRotation(dDisk3, 0F, 0F, 0F);
dDisk4 = new ModelRenderer(this, 0, 0);
dDisk4.addBox(6F, -4F, -4F, 1, 8, 8);
dDisk4.setRotationPoint(-5F, 17F, 0F);
dDisk4.setTextureSize(128, 128);
dDisk4.mirror = true;
setRotation(dDisk4, 0.7853982F, 0F, 0F);
dDisk5 = new ModelRenderer(this, 0, 0);
dDisk5.addBox(8F, -4F, -4F, 1, 8, 8);
dDisk5.setRotationPoint(-5F, 17F, 0F);
dDisk5.setTextureSize(128, 128);
dDisk5.mirror = true;
setRotation(dDisk5, 0F, 0F, 0F);
dDisk6 = new ModelRenderer(this, 0, 0);
dDisk6.addBox(10F, -4F, -4F, 1, 8, 8);
dDisk6.setRotationPoint(-5F, 17F, 0F);
dDisk6.setTextureSize(128, 128);
dDisk6.mirror = true;
setRotation(dDisk6, 0.7853982F, 0F, 0F);
topDiskSet = new ModelRenderer[] { uDisk1, uDisk2, uDisk3, uDisk4, uDisk5, uDisk6 };
bottomDiskSet = new ModelRenderer[] { dDisk1, dDisk2, dDisk3, dDisk4, dDisk5, dDisk6 };
}
public void renderBody(float f5)
{
base.render(f5);
rightSide.render(f5);
leftSide.render(f5);
front.render(f5);
back.render(f5);
top.render(f5);
}
public void renderRotation(float f5, int stage)
{
float rotation = 0.3926990816987241F * stage;
this.resetRotation();
// Set new rotation angle
for (int i = 0; i < 6; i++)
{
topDiskSet[i].rotateAngleX += rotation;
bottomDiskSet[i].rotateAngleX -= rotation;
}
// render
for (int i = 0; i < 6; i++)
{
topDiskSet[i].render(f5);
bottomDiskSet[i].render(f5);
}
this.resetRotation();
}
/** Resets default rotation of the spinning disks */
public void resetRotation()
{
for (int i = 0; i < topDiskSet.length; i++)
{
if (i == 0 || i % 2 == 0)
{
topDiskSet[i].rotateAngleX = 0.7853982F;
}
else
{
topDiskSet[i].rotateAngleX = 0F;
}
}
for (int i = 0; i < bottomDiskSet.length; i++)
{
if (i != 0 && i % 2 != 0)
{
bottomDiskSet[i].rotateAngleX = 0.7853982F;
}
else
{
bottomDiskSet[i].rotateAngleX = 0F;
}
}
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
}

203
src/main/java/resonantinduction/old/client/model/ModelHelper.java
View file

@ -1,203 +0,0 @@
package resonantinduction.old.client.model;
import static org.lwjgl.opengl.GL11.GL_QUADS;
import static org.lwjgl.opengl.GL11.glBegin;
import static org.lwjgl.opengl.GL11.glEnd;
import static org.lwjgl.opengl.GL11.glTexCoord2f;
import static org.lwjgl.opengl.GL11.glVertex3d;
import net.minecraft.util.Vec3;
import net.minecraftforge.common.ForgeDirection;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class ModelHelper
{
private static int gTexWidth = 64;
private static int gTexHeight = 32;
private static int sTexWidth = 64;
private static int sTexHeight = 32;
private static int texOffsetX = 0;
private static int texOffsetY = 0;
private static float texScale = 16f; // 16 pixels per world unit
private static boolean clip = false; // clip textures instead of scaling them
/**
* @param v1 Top Left
* @param v2 Top Right
* @param v3 Bottom Right
* @param v4 Bottom Left
*/
private static void drawQuadRaw(Vec3 v1, Vec3 v2, Vec3 v3, Vec3 v4, ForgeDirection side)
{
glBegin(GL_QUADS);
float quadWidth = 1;
float quadHeight = 1;
float subWidth = ((float) sTexWidth / (float) gTexWidth);
float subHeight = ((float) sTexHeight / (float) gTexHeight);
float xMin = ((float) texOffsetX / sTexWidth) * subWidth;
float yMin = ((float) texOffsetY / sTexHeight) * subHeight;
float subSqX = 0;
float subSqY = 0;
float subSqWidth = 0.25f * ((float) sTexWidth / (float) gTexWidth); // constant for now
float subSqHeight = 0.5f * ((float) sTexHeight / (float) gTexHeight);
switch (side)
{
case UP: // top
{
subSqX = 2f * subSqWidth;
subSqY = 0;
quadWidth = (float) Math.abs(v2.xCoord - v1.xCoord);
quadHeight = (float) Math.abs(v4.zCoord - v1.zCoord);
break;
}
case DOWN: // bottom
{
subSqX = 1f * subSqWidth;
subSqY = 0;
quadWidth = (float) Math.abs(v2.xCoord - v1.xCoord);
quadHeight = (float) Math.abs(v4.zCoord - v1.zCoord);
break;
}
case EAST: // right
{
subSqX = 0;
subSqY = subSqHeight;
quadWidth = (float) Math.abs(v2.zCoord - v1.zCoord);
quadHeight = (float) Math.abs(v4.yCoord - v1.yCoord);
break;
}
case WEST: // left
{
subSqX = 2f * subSqWidth;
subSqY = subSqHeight;
quadWidth = (float) Math.abs(v2.zCoord - v1.zCoord);
quadHeight = (float) Math.abs(v4.yCoord - v1.yCoord);
break;
}
case SOUTH: // back
{
subSqX = subSqWidth;
subSqY = subSqHeight;
quadWidth = (float) Math.abs(v2.xCoord - v1.xCoord);
quadHeight = (float) Math.abs(v4.yCoord - v1.yCoord);
break;
}
case NORTH: // front
{
subSqX = 3f * subSqWidth;
subSqY = subSqHeight;
quadWidth = (float) Math.abs(v2.xCoord - v1.xCoord);
quadHeight = (float) Math.abs(v4.yCoord - v1.yCoord);
break;
}
default:
break;
}
float xMax, yMax;
xMin += subSqX;
yMin += subSqY;
if (clip)
{
xMin += (1f - quadWidth) * subSqWidth;
yMin += (1f - quadHeight) * subSqHeight;
xMax = xMin + (subSqWidth * quadWidth);
yMax = yMin + (subSqHeight * quadHeight);
}
else
{
xMax = xMin + (subSqWidth);
yMax = yMin + (subSqHeight);
}
// System.out.println("xMin: " + xMin + "; xMax: " + xMax);
glTexCoord2f(xMin, yMin);
glVertex3d(v1.xCoord, v1.yCoord, v1.zCoord);
glTexCoord2f(xMax, yMin);
glVertex3d(v2.xCoord, v2.yCoord, v2.zCoord);
glTexCoord2f(xMax, yMax);
glVertex3d(v3.xCoord, v3.yCoord, v3.zCoord);
glTexCoord2f(xMin, yMax);
glVertex3d(v4.xCoord, v4.yCoord, v4.zCoord);
glEnd();
}
/**
* @param v1 Top Left Back
* @param v2 Top Right Back
* @param v3 Top Right Front
* @param v4 Top Left Front
* @param v5 Bottom Left Front
* @param v6 Bottom Right Front
* @param v7 Bottom Right Back
* @param v8 Bottom Left Back
*/
private static void drawCuboidRaw(Vec3 v1, Vec3 v2, Vec3 v3, Vec3 v4, Vec3 v5, Vec3 v6, Vec3 v7, Vec3 v8)
{
drawQuadRaw(v1, v2, v3, v4, ForgeDirection.UP); // top
drawQuadRaw(v7, v6, v3, v2, ForgeDirection.EAST); // right
drawQuadRaw(v5, v6, v7, v8, ForgeDirection.DOWN); // bottom
drawQuadRaw(v5, v8, v1, v4, ForgeDirection.WEST); // left
drawQuadRaw(v6, v5, v4, v3, ForgeDirection.NORTH); // front
drawQuadRaw(v8, v7, v2, v1, ForgeDirection.SOUTH); // back
}
public static void drawCuboid(float xOffset, float yOffset, float zOffset, float xSize, float ySize, float zSize)
{
Vec3 v1, v2, v3, v4, v5, v6, v7, v8;
float x, y, z;
float x2, y2, z2;
x = xOffset;
y = yOffset;
z = zOffset;
x2 = x + xSize;
y2 = y + ySize;
z2 = z + zSize;
v1 = Vec3.createVectorHelper(x, y2, z2);
v2 = Vec3.createVectorHelper(x2, y2, z2);
v3 = Vec3.createVectorHelper(x2, y2, z);
v4 = Vec3.createVectorHelper(x, y2, z);
v5 = Vec3.createVectorHelper(x, y, z);
v6 = Vec3.createVectorHelper(x2, y, z);
v7 = Vec3.createVectorHelper(x2, y, z2);
v8 = Vec3.createVectorHelper(x, y, z2);
drawCuboidRaw(v1, v2, v3, v4, v5, v6, v7, v8);
}
public static void setTextureOffset(int xOffset, int yOffset)
{
texOffsetX = xOffset;
texOffsetY = yOffset;
}
public static void setGlobalTextureResolution(int width, int height)
{
gTexWidth = width;
gTexHeight = height;
}
public static void setTextureSubResolution(int width, int height)
{
sTexWidth = width;
sTexHeight = height;
}
/**
* Sets whether or not to clip the texture.
*
* @param clip If true, textures on blocks less than 1x1x1 will be clipped. If false, they will
* be scaled.
*/
public static void setTextureClip(boolean clip)
{
ModelHelper.clip = clip;
}
}

119
src/main/java/resonantinduction/old/client/model/ModelLaserTile.java
View file

@ -1,119 +0,0 @@
// Date: 11/12/2013 5:27:39 PM
// Template version 1.1
// Java generated by Techne
// Keep in mind that you still need to fill in some blanks
// - ZeuX
package resonantinduction.old.client.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
public class ModelLaserTile extends ModelBase
{
// fields
ModelRenderer base;
ModelRenderer base2;
ModelRenderer rod;
ModelRenderer body;
ModelRenderer body2;
ModelRenderer body3;
ModelRenderer body4;
ModelRenderer body5;
ModelRenderer body6;
ModelRenderer body7;
public ModelLaserTile()
{
textureWidth = 128;
textureHeight = 128;
base = new ModelRenderer(this, 0, 76);
base.addBox(-5F, 0F, -5F, 10, 1, 10);
base.setRotationPoint(0F, 23F, 0F);
base.setTextureSize(128, 128);
base.mirror = true;
setRotation(base, 0F, 0F, 0F);
base2 = new ModelRenderer(this, 0, 66);
base2.addBox(-4F, 0F, -4F, 8, 1, 8);
base2.setRotationPoint(0F, 22F, 0F);
base2.setTextureSize(128, 128);
base2.mirror = true;
setRotation(base2, 0F, 0F, 0F);
rod = new ModelRenderer(this, 0, 53);
rod.addBox(-1.5F, -1F, -1.5F, 3, 8, 3);
rod.setRotationPoint(0F, 15F, 0F);
rod.setTextureSize(128, 128);
rod.mirror = true;
setRotation(rod, 0F, 0F, 0F);
body = new ModelRenderer(this, 0, 35);
body.addBox(-3.5F, -1F, -2.5F, 9, 3, 5);
body.setRotationPoint(0F, 10F, 0F);
body.setTextureSize(128, 128);
body.mirror = true;
setRotation(body, 0F, 0F, 0F);
body2 = new ModelRenderer(this, 0, 44);
body2.addBox(-3.5F, -1F, -2F, 7, 2, 4);
body2.setRotationPoint(0F, 13F, 0F);
body2.setTextureSize(128, 128);
body2.mirror = true;
setRotation(body2, 0F, 0F, 0F);
body3 = new ModelRenderer(this, 30, 37);
body3.addBox(-3.5F, -1F, -2F, 3, 4, 4);
body3.setRotationPoint(-3F, 10.3F, 0F);
body3.setTextureSize(128, 128);
body3.mirror = true;
setRotation(body3, 0F, 0F, 0F);
body4 = new ModelRenderer(this, 57, 34);
body4.addBox(-3.5F, -1.5F, -1F, 3, 1, 2);
body4.setRotationPoint(-6F, 11F, 0F);
body4.setTextureSize(128, 128);
body4.mirror = true;
setRotation(body4, 0F, 0F, 0F);
body5 = new ModelRenderer(this, 57, 47);
body5.addBox(-3.5F, -1.5F, -1F, 3, 1, 2);
body5.setRotationPoint(-6F, 13F, 0F);
body5.setTextureSize(128, 128);
body5.mirror = true;
setRotation(body5, 0F, 0F, 0F);
body6 = new ModelRenderer(this, 66, 42);
body6.addBox(-3.5F, -1.5F, -1.5F, 3, 1, 1);
body6.setRotationPoint(-6F, 12F, 0F);
body6.setTextureSize(128, 128);
body6.mirror = true;
setRotation(body6, 0F, 0F, 0F);
body7 = new ModelRenderer(this, 51, 41);
body7.addBox(-3.5F, -1.5F, 0.5F, 3, 1, 1);
body7.setRotationPoint(-6F, 12F, 0F);
body7.setTextureSize(128, 128);
body7.mirror = true;
setRotation(body7, 0F, 0F, 0F);
}
public void render(float f5)
{
base.render(f5);
base2.render(f5);
rod.render(f5);
body.render(f5);
body2.render(f5);
body3.render(f5);
body4.render(f5);
body5.render(f5);
body6.render(f5);
body7.render(f5);
}
public void renderAll()
{
this.render(0.0625F);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
}

135
src/main/java/resonantinduction/old/client/model/ModelLiquidTankCorner.java
View file

@ -1,135 +0,0 @@
package resonantinduction.old.client.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class ModelLiquidTankCorner extends ModelBase
{
// fields
ModelRenderer sOne;
ModelRenderer sTwo;
ModelRenderer d7;
ModelRenderer d5;
ModelRenderer d3;
ModelRenderer d4;
ModelRenderer d1;
ModelRenderer d6;
ModelRenderer d2;
ModelRenderer d8;
ModelRenderer d9;
ModelRenderer d10;
ModelRenderer face;
public ModelLiquidTankCorner()
{
textureWidth = 128;
textureHeight = 128;
sOne = new ModelRenderer(this, 0, 30);
sOne.addBox(-1F, 0F, -1F, 2, 16, 2);
sOne.setRotationPoint(-7F, 8F, 7F);
sOne.setTextureSize(128, 128);
sOne.mirror = true;
setRotation(sOne, 0F, 0F, 0F);
sTwo = new ModelRenderer(this, 0, 30);
sTwo.addBox(-1F, 0F, -1F, 2, 16, 2);
sTwo.setRotationPoint(-7F, 8F, -7F);
sTwo.setTextureSize(128, 128);
sTwo.mirror = true;
setRotation(sTwo, 0F, 0F, 0F);
d7 = new ModelRenderer(this, 43, 2);
d7.addBox(-1F, 0F, -1F, 2, 16, 12);
d7.setRotationPoint(-7F, 8F, -5F);
d7.setTextureSize(128, 128);
d7.mirror = true;
setRotation(d7, 0F, 0F, 0F);
d5 = new ModelRenderer(this, 9, 12);
d5.addBox(-1F, 0F, -1F, 14, 16, 2);
d5.setRotationPoint(-5F, 8F, 7F);
d5.setTextureSize(128, 128);
d5.mirror = true;
setRotation(d5, 0F, 0F, 0F);
d3 = new ModelRenderer(this, 9, 67);
d3.addBox(-1.5F, 0F, -1.3F, 20, 2, 2);
d3.setRotationPoint(-6F, 22F, -6F);
d3.setTextureSize(128, 128);
d3.mirror = true;
setRotation(d3, 0F, -0.7853982F, 0F);
d4 = new ModelRenderer(this, 9, 88);
d4.addBox(0F, 0F, -9F, 5, 2, 4);
d4.setRotationPoint(-6F, 22F, 6F);
d4.setTextureSize(128, 128);
d4.mirror = true;
setRotation(d4, 0F, 0F, 0F);
d1 = new ModelRenderer(this, 9, 67);
d1.addBox(-1.5F, 0F, -1.3F, 20, 2, 2);
d1.setRotationPoint(-6F, 8F, -6F);
d1.setTextureSize(128, 128);
d1.mirror = true;
setRotation(d1, 0F, -0.7853982F, 0F);
d6 = new ModelRenderer(this, 9, 75);
d6.addBox(-1.5F, 0F, -1.3F, 17, 2, 2);
d6.setRotationPoint(-6F, 22F, -4F);
d6.setTextureSize(128, 128);
d6.mirror = true;
setRotation(d6, 0F, -0.7853982F, 0F);
d2 = new ModelRenderer(this, 9, 80);
d2.addBox(0F, 0F, -5F, 9, 2, 5);
d2.setRotationPoint(-6F, 22F, 6F);
d2.setTextureSize(128, 128);
d2.mirror = true;
setRotation(d2, 0F, 0F, 0F);
d8 = new ModelRenderer(this, 9, 75);
d8.addBox(-1.5F, 0F, -1.3F, 17, 2, 2);
d8.setRotationPoint(-6F, 8F, -4F);
d8.setTextureSize(128, 128);
d8.mirror = true;
setRotation(d8, 0F, -0.7853982F, 0F);
d9 = new ModelRenderer(this, 9, 88);
d9.addBox(0F, 0F, -9F, 5, 2, 4);
d9.setRotationPoint(-6F, 8F, 6F);
d9.setTextureSize(128, 128);
d9.mirror = true;
setRotation(d9, 0F, 0F, 0F);
d10 = new ModelRenderer(this, 9, 80);
d10.addBox(0F, 0F, -5F, 9, 2, 5);
d10.setRotationPoint(-6F, 8F, 6F);
d10.setTextureSize(128, 128);
d10.mirror = true;
setRotation(d10, 0F, 0F, 0F);
face = new ModelRenderer(this, 0, 50);
face.addBox(-8.5F, 0F, 0F, 17, 14, 2);
face.setRotationPoint(0F, 9F, 0F);
face.setTextureSize(128, 128);
face.mirror = true;
setRotation(face, 0F, -0.7853982F, 0F);
}
public void render(float f5)
{
sOne.render(f5);
sTwo.render(f5);
d7.render(f5);
d5.render(f5);
d3.render(f5);
d4.render(f5);
d1.render(f5);
d6.render(f5);
d2.render(f5);
d8.render(f5);
d9.render(f5);
d10.render(f5);
face.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
}

8
src/main/java/resonantinduction/old/client/model/ModelMachine.java
View file

@ -1,8 +0,0 @@
package resonantinduction.old.client.model;
import net.minecraft.client.model.ModelBase;
public abstract class ModelMachine extends ModelBase
{
public abstract void render(float f5);
}

146
src/main/java/resonantinduction/old/client/model/ModelMiningLaserGun.java
View file

@ -1,146 +0,0 @@
// Date: 11/12/2013 5:48:04 PM
// Template version 1.1
// Java generated by Techne
// Keep in mind that you still need to fill in some blanks
// - ZeuX
package resonantinduction.old.client.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
public class ModelMiningLaserGun extends ModelBase
{
// fields
ModelRenderer grip;
ModelRenderer grip2;
ModelRenderer body;
ModelRenderer body2;
ModelRenderer body3;
ModelRenderer body4;
ModelRenderer body5;
ModelRenderer body6;
ModelRenderer barrel;
ModelRenderer barrel2;
ModelRenderer screen;
ModelRenderer battery;
ModelRenderer batteryClip;
ModelRenderer batteryClip2;
public ModelMiningLaserGun()
{
textureWidth = 128;
textureHeight = 64;
grip = new ModelRenderer(this, 1, 26);
grip.addBox(0F, 0F, 0F, 1, 2, 1);
grip.setRotationPoint(0.5F, 19F, -2F);
grip.setTextureSize(128, 64);
grip.mirror = true;
setRotation(grip, 0.4014257F, 0F, 0F);
grip2 = new ModelRenderer(this, 32, 2);
grip2.addBox(-1.5F, 0F, 0F, 3, 1, 1);
grip2.setRotationPoint(4.5F, 17.58F, -12.01F);
grip2.setTextureSize(128, 64);
grip2.mirror = true;
setRotation(grip2, 0F, 0F, 0F);
body = new ModelRenderer(this, 16, 39);
body.addBox(-1.5F, 0F, 0F, 3, 3, 13);
body.setRotationPoint(1F, 15.8F, -11.01F);
body.setTextureSize(128, 64);
body.mirror = true;
setRotation(body, 0F, 0F, 0F);
body2 = new ModelRenderer(this, 49, 41);
body2.addBox(0F, 0F, 0F, 2, 1, 13);
body2.setRotationPoint(0F, 15.6F, -11.01F);
body2.setTextureSize(128, 64);
body2.mirror = true;
setRotation(body2, 0F, 0F, 0F);
body3 = new ModelRenderer(this, 55, 7);
body3.addBox(-1.5F, 0F, 0F, 2, 1, 8);
body3.setRotationPoint(1.5F, 18.8F, -15.01F);
body3.setTextureSize(128, 64);
body3.mirror = true;
setRotation(body3, 0F, 0F, 0F);
body4 = new ModelRenderer(this, 0, 0);
body4.addBox(0F, 0F, 0F, 2, 1, 5);
body4.setRotationPoint(0F, 18F, -3F);
body4.setTextureSize(128, 64);
body4.mirror = true;
setRotation(body4, 0F, 0F, 0F);
body5 = new ModelRenderer(this, 17, 7);
body5.addBox(-1.5F, 0F, 0F, 1, 2, 8);
body5.setRotationPoint(0.5F, 17F, -15.01F);
body5.setTextureSize(128, 64);
body5.mirror = true;
setRotation(body5, 0F, 0F, 0F);
body6 = new ModelRenderer(this, 36, 7);
body6.addBox(-1.5F, 0F, 0F, 1, 2, 8);
body6.setRotationPoint(3.5F, 17F, -15.01F);
body6.setTextureSize(128, 64);
body6.mirror = true;
setRotation(body6, 0F, 0F, 0F);
barrel = new ModelRenderer(this, 34, 21);
barrel.addBox(0F, 0F, 0F, 1, 3, 8);
barrel.setRotationPoint(0.5F, 16F, -19.01F);
barrel.setTextureSize(128, 64);
barrel.mirror = true;
setRotation(barrel, 0F, 0F, 0F);
barrel2 = new ModelRenderer(this, 55, 23);
barrel2.addBox(0F, 0F, 0F, 2, 2, 6);
barrel2.setRotationPoint(0F, 16.8F, -17.01F);
barrel2.setTextureSize(128, 64);
barrel2.mirror = true;
setRotation(barrel2, 0F, 0F, 0F);
screen = new ModelRenderer(this, 7, 10);
screen.addBox(0F, 0F, 0F, 3, 3, 1);
screen.setRotationPoint(2.5F, 16F, -8.01F);
screen.setTextureSize(128, 64);
screen.mirror = true;
setRotation(screen, 0.5410521F, 0F, 0F);
battery = new ModelRenderer(this, 17, 22);
battery.addBox(-1.5F, 0F, 0F, 2, 4, 5);
battery.setRotationPoint(-1F, 16F, -6.5F);
battery.setTextureSize(128, 64);
battery.mirror = true;
setRotation(battery, 0F, 0F, 0F);
batteryClip = new ModelRenderer(this, 17, 0);
batteryClip.addBox(-1.5F, 0F, 0F, 2, 1, 1);
batteryClip.setRotationPoint(-0.4F, 16.5F, -2F);
batteryClip.setTextureSize(128, 64);
batteryClip.mirror = true;
setRotation(batteryClip, 0F, 0F, 0F);
batteryClip2 = new ModelRenderer(this, 17, 0);
batteryClip2.addBox(-1.5F, 0F, 0F, 2, 1, 1);
batteryClip2.setRotationPoint(-0.4F, 16.5F, -7F);
batteryClip2.setTextureSize(128, 64);
batteryClip2.mirror = true;
setRotation(batteryClip2, 0F, 0F, 0F);
}
public void render(float f5)
{
grip.render(f5);
grip2.render(f5);
body.render(f5);
body2.render(f5);
body3.render(f5);
body4.render(f5);
body5.render(f5);
body6.render(f5);
barrel.render(f5);
barrel2.render(f5);
screen.render(f5);
battery.render(f5);
batteryClip.render(f5);
batteryClip2.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
}

114
src/main/java/resonantinduction/old/client/model/ModelSink.java
View file

@ -1,114 +0,0 @@
// Date: 1/22/2013 12:21:32 AM
// Template version 1.1
// Java generated by Techne
// Keep in mind that you still need to fill in some blanks
// - ZeuX
package resonantinduction.old.client.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class ModelSink extends ModelBase
{
// fields
ModelRenderer Base;
ModelRenderer FrontLip;
ModelRenderer BottomLip;
ModelRenderer RightLip;
ModelRenderer LeftLip;
ModelRenderer BLip;
ModelRenderer Edge;
ModelRenderer Edge2;
ModelRenderer Water;
public ModelSink()
{
textureWidth = 128;
textureHeight = 128;
Base = new ModelRenderer(this, 0, 0);
Base.addBox(-7F, 0F, -7F, 14, 12, 14);
Base.setRotationPoint(0F, 12F, 0F);
Base.setTextureSize(128, 128);
Base.mirror = true;
setRotation(Base, 0F, 0F, 0F);
FrontLip = new ModelRenderer(this, 10, 62);
FrontLip.addBox(-8F, -4F, -8F, 16, 4, 2);
FrontLip.setRotationPoint(0F, 12F, 0F);
FrontLip.setTextureSize(128, 128);
FrontLip.mirror = true;
setRotation(FrontLip, 0F, 0F, 0F);
BottomLip = new ModelRenderer(this, 5, 37);
BottomLip.addBox(-8F, -4F, 4F, 16, 4, 4);
BottomLip.setRotationPoint(0F, 12F, 0F);
BottomLip.setTextureSize(128, 128);
BottomLip.mirror = true;
setRotation(BottomLip, 0F, 0F, 0F);
RightLip = new ModelRenderer(this, 0, 47);
RightLip.addBox(-8F, -4F, -6F, 2, 4, 10);
RightLip.setRotationPoint(0F, 12F, 0F);
RightLip.setTextureSize(128, 128);
RightLip.mirror = true;
setRotation(RightLip, 0F, 0F, 0F);
LeftLip = new ModelRenderer(this, 25, 47);
LeftLip.addBox(6F, -4F, -6F, 2, 4, 10);
LeftLip.setRotationPoint(0F, 12F, 0F);
LeftLip.setTextureSize(128, 128);
LeftLip.mirror = true;
setRotation(LeftLip, 0F, 0F, 0F);
BLip = new ModelRenderer(this, 9, 32);
BLip.addBox(-1F, -1F, 4F, 2, 2, 2);
BLip.setRotationPoint(0F, 12F, 0F);
BLip.setTextureSize(128, 128);
BLip.mirror = true;
setRotation(BLip, 0.5061455F, 0F, 0F);
Edge = new ModelRenderer(this, 5, 64);
Edge.addBox(0F, 0F, 0F, 1, 12, 1);
Edge.setRotationPoint(7F, 12F, 7F);
Edge.setTextureSize(128, 128);
Edge.mirror = true;
setRotation(Edge, 0F, 0F, 0F);
Edge2 = new ModelRenderer(this, 0, 64);
Edge2.addBox(0F, 0F, 0F, 1, 12, 1);
Edge2.setRotationPoint(-8F, 12F, 7F);
Edge2.setTextureSize(128, 128);
Edge2.mirror = true;
setRotation(Edge2, 0F, 0F, 0F);
Water = new ModelRenderer(this, 0, 0);
Water.addBox(-6F, 0F, -6F, 12, 0, 10);
Water.setRotationPoint(0F, 12F, 0F);
Water.setTextureSize(128, 128);
Water.mirror = true;
setRotation(Water, 0F, 0F, 0F);
}
public void render(float f5)
{
Base.render(f5);
FrontLip.render(f5);
BottomLip.render(f5);
RightLip.render(f5);
LeftLip.render(f5);
BLip.render(f5);
Edge.render(f5);
Edge2.render(f5);
}
public void renderLiquid(float f5, float level)
{
Water.setRotationPoint(0F, 12F - level, 0F);
Water.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
}

126
src/main/java/resonantinduction/old/client/model/ModelSmallFluidCan.java
View file

@ -1,126 +0,0 @@
// Date: 11/27/2013 9:27:04 AM
// Template version 1.1
// Java generated by Techne
// Keep in mind that you still need to fill in some blanks
// - ZeuX
package resonantinduction.old.client.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
public class ModelSmallFluidCan extends ModelBase
{
// fields
ModelRenderer body1;
ModelRenderer body2;
ModelRenderer body3;
ModelRenderer body4;
ModelRenderer edge1;
ModelRenderer edge2;
ModelRenderer edge3;
ModelRenderer edge4;
ModelRenderer glass1;
ModelRenderer glass2;
ModelRenderer glass3;
ModelRenderer glass4;
public ModelSmallFluidCan()
{
textureWidth = 64;
textureHeight = 32;
body1 = new ModelRenderer(this, 12, 28);
body1.addBox(-1.5F, 0F, -1.5F, 3, 1, 3);
body1.setRotationPoint(0F, 23F, 0F);
body1.setTextureSize(64, 32);
body1.mirror = true;
setRotation(body1, 0F, 0F, 0F);
body2 = new ModelRenderer(this, 10, 22);
body2.addBox(-2F, -1F, -2F, 4, 1, 4);
body2.setRotationPoint(0F, 23F, 0F);
body2.setTextureSize(64, 32);
body2.mirror = true;
setRotation(body2, 0F, 0F, 0F);
body3 = new ModelRenderer(this, 10, 5);
body3.addBox(-2F, -1F, -2F, 4, 1, 4);
body3.setRotationPoint(0F, 17F, 0F);
body3.setTextureSize(64, 32);
body3.mirror = true;
setRotation(body3, 0F, 0F, 0F);
body4 = new ModelRenderer(this, 12, 0);
body4.addBox(-1.5F, 0F, -1.5F, 3, 1, 3);
body4.setRotationPoint(0F, 15F, 0F);
body4.setTextureSize(64, 32);
body4.mirror = true;
setRotation(body4, 0F, 0F, 0F);
edge1 = new ModelRenderer(this, 21, 13);
edge1.addBox(-1.9F, -1F, -1.9F, 1, 5, 1);
edge1.setRotationPoint(0F, 18F, 0F);
edge1.setTextureSize(64, 32);
edge1.mirror = true;
setRotation(edge1, 0F, 0F, 0F);
edge2 = new ModelRenderer(this, 26, 13);
edge2.addBox(-2.1F, -1F, -1.9F, 1, 5, 1);
edge2.setRotationPoint(3F, 18F, 0F);
edge2.setTextureSize(64, 32);
edge2.mirror = true;
setRotation(edge2, 0F, 0F, 0F);
edge3 = new ModelRenderer(this, 10, 13);
edge3.addBox(-2.1F, -1F, 0.9F, 1, 5, 1);
edge3.setRotationPoint(3F, 18F, 0F);
edge3.setTextureSize(64, 32);
edge3.mirror = true;
setRotation(edge3, 0F, 0F, 0F);
edge4 = new ModelRenderer(this, 16, 13);
edge4.addBox(-1.9F, -1F, 0.9F, 1, 5, 1);
edge4.setRotationPoint(0F, 18F, 0F);
edge4.setTextureSize(64, 32);
edge4.mirror = true;
setRotation(edge4, 0F, 0F, 0F);
glass1 = new ModelRenderer(this, 2, 13);
glass1.addBox(-3.1F, -1F, 1.8F, 2, 5, 0);
glass1.setRotationPoint(2F, 18F, 0F);
glass1.setTextureSize(64, 32);
glass1.mirror = true;
setRotation(glass1, 0F, 0F, 0F);
glass2 = new ModelRenderer(this, 2, 13);
glass2.addBox(-3.1F, -1F, 0.2F, 2, 5, 0);
glass2.setRotationPoint(2F, 18F, -2F);
glass2.setTextureSize(64, 32);
glass2.mirror = true;
setRotation(glass2, 0F, 0F, 0F);
glass3 = new ModelRenderer(this, 2, 13);
glass3.addBox(-1.1F, -1F, -0.2F, 2, 5, 0);
glass3.setRotationPoint(2F, 18F, 0F);
glass3.setTextureSize(64, 32);
glass3.mirror = true;
setRotation(glass3, 0F, 1.570796F, 0F);
glass4 = new ModelRenderer(this, 2, 13);
glass4.addBox(-1.1F, -1F, 2.2F, 2, 5, 0);
glass4.setRotationPoint(-4F, 18F, 0F);
glass4.setTextureSize(64, 32);
glass4.mirror = true;
setRotation(glass4, 0F, 1.570796F, 0F);
}
public void render(float f5)
{
body1.render(f5);
body2.render(f5);
body3.render(f5);
body4.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;
}
}

288
src/main/java/resonantinduction/old/client/model/ModelSteamGen.java
View file

@ -1,288 +0,0 @@
// Date: 11/27/2013 5:36:07 AM
// Template version 1.1
// Java generated by Techne
// Keep in mind that you still need to fill in some blanks
// - ZeuX
package resonantinduction.old.client.model;
import net.minecraft.client.model.ModelRenderer;
public class ModelSteamGen extends ModelMachine
{
// fields
ModelRenderer face;
ModelRenderer grill;
ModelRenderer grill2;
ModelRenderer grill3;
ModelRenderer grill4;
ModelRenderer grill5;
ModelRenderer grill6;
ModelRenderer grill7;
ModelRenderer grill8;
ModelRenderer grill9;
ModelRenderer grill10;
ModelRenderer grill11;
ModelRenderer grill12;
ModelRenderer grill13;
ModelRenderer grill14;
ModelRenderer grill15;
ModelRenderer grill16;
ModelRenderer grill17;
ModelRenderer tank;
ModelRenderer tank2;
ModelRenderer tank3;
ModelRenderer tank4;
ModelRenderer tank5;
ModelRenderer tankTop;
ModelRenderer tankTop2;
ModelRenderer tankTop3;
ModelRenderer tankTop4;
ModelRenderer pipe;
ModelRenderer pipe2;
ModelRenderer gauge;
ModelRenderer gaugeNeedle;
public ModelSteamGen()
{
textureWidth = 128;
textureHeight = 128;
face = new ModelRenderer(this, 20, 93);
face.addBox(-8F, 0F, -6F, 16, 6, 14);
face.setRotationPoint(0F, 18F, 0F);
face.setTextureSize(128, 128);
face.mirror = true;
setRotation(face, 0F, 0F, 0F);
grill = new ModelRenderer(this, 44, 56);
grill.addBox(0F, 0F, 0F, 1, 5, 1);
grill.setRotationPoint(-7.6F, 18.5F, -7F);
grill.setTextureSize(128, 128);
grill.mirror = true;
setRotation(grill, 0F, 0F, 0F);
grill2 = new ModelRenderer(this, 38, 56);
grill2.addBox(0F, 0F, 0F, 1, 5, 1);
grill2.setRotationPoint(6.4F, 18.5F, -7F);
grill2.setTextureSize(128, 128);
grill2.mirror = true;
setRotation(grill2, 0F, 0F, 0F);
grill3 = new ModelRenderer(this, 0, 49);
grill3.addBox(0F, 0F, 0F, 13, 1, 1);
grill3.setRotationPoint(-6.6F, 18.5F, -7F);
grill3.setTextureSize(128, 128);
grill3.mirror = true;
setRotation(grill3, 0F, 0F, 0F);
grill4 = new ModelRenderer(this, 0, 52);
grill4.addBox(0F, 0F, 0F, 13, 1, 1);
grill4.setRotationPoint(-6.6F, 22.5F, -7F);
grill4.setTextureSize(128, 128);
grill4.mirror = true;
setRotation(grill4, 0F, 0F, 0F);
grill5 = new ModelRenderer(this, 0, 56);
grill5.addBox(0F, 0F, 0F, 1, 3, 1);
grill5.setRotationPoint(-6.6F, 19.5F, -6F);
grill5.setTextureSize(128, 128);
grill5.mirror = true;
setRotation(grill5, 0F, 0.7853982F, 0F);
grill6 = new ModelRenderer(this, 0, 56);
grill6.addBox(0F, 0F, 0F, 1, 3, 1);
grill6.setRotationPoint(5F, 19.5F, -6F);
grill6.setTextureSize(128, 128);
grill6.mirror = true;
setRotation(grill6, 0F, 0.7853982F, 0F);
grill7 = new ModelRenderer(this, 0, 56);
grill7.addBox(0F, 0F, 0F, 1, 3, 1);
grill7.setRotationPoint(4F, 19.5F, -6F);
grill7.setTextureSize(128, 128);
grill7.mirror = true;
setRotation(grill7, 0F, 0.7853982F, 0F);
grill8 = new ModelRenderer(this, 0, 56);
grill8.addBox(0F, 0F, 0F, 1, 3, 1);
grill8.setRotationPoint(3F, 19.5F, -6F);
grill8.setTextureSize(128, 128);
grill8.mirror = true;
setRotation(grill8, 0F, 0.7853982F, 0F);
grill9 = new ModelRenderer(this, 0, 56);
grill9.addBox(0F, 0F, 0F, 1, 3, 1);
grill9.setRotationPoint(2F, 19.5F, -6F);
grill9.setTextureSize(128, 128);
grill9.mirror = true;
setRotation(grill9, 0F, 0.7853982F, 0F);
grill10 = new ModelRenderer(this, 0, 56);
grill10.addBox(0F, 0F, 0F, 1, 3, 1);
grill10.setRotationPoint(-5.6F, 19.5F, -6F);
grill10.setTextureSize(128, 128);
grill10.mirror = true;
setRotation(grill10, 0F, 0.7853982F, 0F);
grill11 = new ModelRenderer(this, 0, 56);
grill11.addBox(0F, 0F, 0F, 1, 3, 1);
grill11.setRotationPoint(-4.6F, 19.5F, -6F);
grill11.setTextureSize(128, 128);
grill11.mirror = true;
setRotation(grill11, 0F, 0.7853982F, 0F);
grill12 = new ModelRenderer(this, 0, 56);
grill12.addBox(0F, 0F, 0F, 1, 3, 1);
grill12.setRotationPoint(-3.6F, 19.5F, -6F);
grill12.setTextureSize(128, 128);
grill12.mirror = true;
setRotation(grill12, 0F, 0.7853982F, 0F);
grill13 = new ModelRenderer(this, 0, 56);
grill13.addBox(0F, 0F, 0F, 1, 3, 1);
grill13.setRotationPoint(-2.6F, 19.5F, -6F);
grill13.setTextureSize(128, 128);
grill13.mirror = true;
setRotation(grill13, 0F, 0.7853982F, 0F);
grill14 = new ModelRenderer(this, 0, 56);
grill14.addBox(0F, 0F, 0F, 1, 3, 1);
grill14.setRotationPoint(-1.6F, 19.5F, -6F);
grill14.setTextureSize(128, 128);
grill14.mirror = true;
setRotation(grill14, 0F, 0.7853982F, 0F);
grill15 = new ModelRenderer(this, 0, 56);
grill15.addBox(0F, 0F, 0F, 1, 3, 1);
grill15.setRotationPoint(1F, 19.5F, -6F);
grill15.setTextureSize(128, 128);
grill15.mirror = true;
setRotation(grill15, 0F, 0.7853982F, 0F);
grill16 = new ModelRenderer(this, 0, 56);
grill16.addBox(0F, 0F, 0F, 1, 3, 1);
grill16.setRotationPoint(0F, 19.5F, -6F);
grill16.setTextureSize(128, 128);
grill16.mirror = true;
setRotation(grill16, 0F, 0.7853982F, 0F);
grill17 = new ModelRenderer(this, 0, 56);
grill17.addBox(0F, 0F, 0F, 1, 3, 1);
grill17.setRotationPoint(-0.8F, 19.5F, -6F);
grill17.setTextureSize(128, 128);
grill17.mirror = true;
setRotation(grill17, 0F, 0.7853982F, 0F);
tank = new ModelRenderer(this, 22, 65);
tank.addBox(-5F, 0F, -5F, 10, 8, 10);
tank.setRotationPoint(0F, 10F, 2F);
tank.setTextureSize(128, 128);
tank.mirror = true;
setRotation(tank, 0F, 0F, 0F);
tank2 = new ModelRenderer(this, 0, 66);
tank2.addBox(-4F, 0F, -6F, 8, 8, 1);
tank2.setRotationPoint(0F, 10F, 2F);
tank2.setTextureSize(128, 128);
tank2.mirror = true;
setRotation(tank2, 0F, 0F, 0F);
tank3 = new ModelRenderer(this, 0, 65);
tank3.addBox(-4F, 0F, -6F, 8, 8, 1);
tank3.setRotationPoint(0F, 10F, 2F);
tank3.setTextureSize(128, 128);
tank3.mirror = true;
setRotation(tank3, 0F, 1.570796F, 0F);
tank4 = new ModelRenderer(this, 0, 65);
tank4.addBox(-4F, 0F, -6F, 8, 8, 1);
tank4.setRotationPoint(0F, 10F, 2F);
tank4.setTextureSize(128, 128);
tank4.mirror = true;
setRotation(tank4, 0F, 3.141593F, 0F);
tank5 = new ModelRenderer(this, 0, 65);
tank5.addBox(-4F, 0F, -6F, 8, 8, 1);
tank5.setRotationPoint(0F, 10F, 2F);
tank5.setTextureSize(128, 128);
tank5.mirror = true;
setRotation(tank5, 0F, -1.570796F, 0F);
tankTop = new ModelRenderer(this, 0, 11);
tankTop.addBox(0F, 0F, 0F, 16, 2, 4);
tankTop.setRotationPoint(-8F, 8F, -6F);
tankTop.setTextureSize(128, 128);
tankTop.mirror = true;
setRotation(tankTop, 0F, 0F, 0F);
tankTop2 = new ModelRenderer(this, 0, 18);
tankTop2.addBox(-4F, 0F, 2F, 8, 2, 4);
tankTop2.setRotationPoint(0F, 8F, 2F);
tankTop2.setTextureSize(128, 128);
tankTop2.mirror = true;
setRotation(tankTop2, 0F, 0F, 0F);
tankTop3 = new ModelRenderer(this, 29, 25);
tankTop3.addBox(0F, 0F, 0F, 4, 2, 10);
tankTop3.setRotationPoint(4F, 8F, -2F);
tankTop3.setTextureSize(128, 128);
tankTop3.mirror = true;
setRotation(tankTop3, 0F, 0F, 0F);
tankTop4 = new ModelRenderer(this, 0, 25);
tankTop4.addBox(0F, 0F, 0F, 4, 2, 10);
tankTop4.setRotationPoint(-8F, 8F, -2F);
tankTop4.setTextureSize(128, 128);
tankTop4.mirror = true;
setRotation(tankTop4, 0F, 0F, 0F);
pipe = new ModelRenderer(this, 10, 0);
pipe.addBox(0F, 0F, 0F, 2, 8, 2);
pipe.setRotationPoint(-7F, 10F, -5F);
pipe.setTextureSize(128, 128);
pipe.mirror = true;
setRotation(pipe, 0F, 0F, 0F);
pipe2 = new ModelRenderer(this, 0, 0);
pipe2.addBox(0F, 0F, 0F, 2, 8, 2);
pipe2.setRotationPoint(5F, 10F, -5F);
pipe2.setTextureSize(128, 128);
pipe2.mirror = true;
setRotation(pipe2, 0F, 0F, 0F);
gauge = new ModelRenderer(this, 59, 25);
gauge.addBox(0F, 0F, 0F, 4, 4, 1);
gauge.setRotationPoint(-2F, 12F, -4.5F);
gauge.setTextureSize(128, 128);
gauge.mirror = true;
setRotation(gauge, 0F, 0F, 0F);
gaugeNeedle = new ModelRenderer(this, 71, 25);
gaugeNeedle.addBox(-0.5F, -2F, -1F, 1, 3, 0);
gaugeNeedle.setRotationPoint(0F, 15F, -3.6F);
gaugeNeedle.setTextureSize(128, 128);
gaugeNeedle.mirror = true;
setRotation(gaugeNeedle, -0.0174533F, 0F, -0.5759587F);
}
@Override
public void render(float f5)
{
face.render(f5);
grill.render(f5);
grill2.render(f5);
grill3.render(f5);
grill4.render(f5);
grill5.render(f5);
grill6.render(f5);
grill7.render(f5);
grill8.render(f5);
grill9.render(f5);
grill10.render(f5);
grill11.render(f5);
grill12.render(f5);
grill13.render(f5);
grill14.render(f5);
grill15.render(f5);
grill16.render(f5);
grill17.render(f5);
tank.render(f5);
tank2.render(f5);
tank3.render(f5);
tank4.render(f5);
tank5.render(f5);
tankTop.render(f5);
tankTop2.render(f5);
tankTop3.render(f5);
tankTop4.render(f5);
pipe.render(f5);
pipe2.render(f5);
gauge.render(f5);
}
public void renderGauge(float f5, float angle)
{
gaugeNeedle.rotateAngleZ = angle;
gaugeNeedle.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
}

214
src/main/java/resonantinduction/old/client/model/ModelSteamTurbine.java
View file

@ -1,214 +0,0 @@
// Date: 11/26/2013 1:36:31 AM
// Template version 1.1
// Java generated by Techne
// Keep in mind that you still need to fill in some blanks
// - ZeuX
package resonantinduction.old.client.model;
import net.minecraft.client.model.ModelRenderer;
public class ModelSteamTurbine extends ModelMachine
{
// fields
ModelRenderer base;
ModelRenderer base2;
ModelRenderer centerBeam;
ModelRenderer fan1;
ModelRenderer fan2;
ModelRenderer fan3;
ModelRenderer fan4;
ModelRenderer fan5;
ModelRenderer fan6;
ModelRenderer fan7;
ModelRenderer fan8;
ModelRenderer rightSide;
ModelRenderer leftSide;
ModelRenderer backSide;
ModelRenderer motor;
ModelRenderer motorNeck;
ModelRenderer brace;
ModelRenderer gauge;
ModelRenderer gaugeFrame;
ModelRenderer gaugeFrame2;
ModelRenderer gaugeFrame3;
ModelRenderer gaugeDieal;
public ModelSteamTurbine()
{
textureWidth = 256;
textureHeight = 256;
base = new ModelRenderer(this, 120, 40);
base.addBox(-8F, 0F, -8F, 16, 1, 16);
base.setRotationPoint(0F, 23F, 0F);
base.setTextureSize(256, 256);
base.mirror = true;
setRotation(base, 0F, 0F, 0F);
base2 = new ModelRenderer(this, 120, 22);
base2.addBox(-7F, -1F, -7F, 14, 1, 14);
base2.setRotationPoint(0F, 23F, 0F);
base2.setTextureSize(256, 256);
base2.mirror = true;
setRotation(base2, 0F, 0F, 0F);
centerBeam = new ModelRenderer(this, 0, 80);
centerBeam.addBox(-2F, -1F, -2F, 4, 7, 4);
centerBeam.setRotationPoint(0F, 16F, 0F);
centerBeam.setTextureSize(256, 256);
centerBeam.mirror = true;
setRotation(centerBeam, 0F, 0F, 0F);
fan1 = new ModelRenderer(this, 0, 100);
fan1.addBox(-0.5F, -1F, -6F, 1, 7, 4);
fan1.setRotationPoint(0F, 16F, 0F);
fan1.setTextureSize(256, 256);
fan1.mirror = true;
setRotation(fan1, 0F, 0F, 0F);
fan2 = new ModelRenderer(this, 0, 100);
fan2.addBox(-0.5F, -1F, -6F, 1, 7, 4);
fan2.setRotationPoint(0F, 16F, 0F);
fan2.setTextureSize(256, 256);
fan2.mirror = true;
setRotation(fan2, 0F, 0.7853982F, 0F);
fan3 = new ModelRenderer(this, 0, 100);
fan3.addBox(-0.5F, -1F, -6F, 1, 7, 4);
fan3.setRotationPoint(0F, 16F, 0F);
fan3.setTextureSize(256, 256);
fan3.mirror = true;
setRotation(fan3, 0F, 1.570796F, 0F);
fan4 = new ModelRenderer(this, 0, 100);
fan4.addBox(-0.5F, -1F, -6F, 1, 7, 4);
fan4.setRotationPoint(0F, 16F, 0F);
fan4.setTextureSize(256, 256);
fan4.mirror = true;
setRotation(fan4, 0F, 2.356194F, 0F);
fan5 = new ModelRenderer(this, 0, 100);
fan5.addBox(-0.5F, -1F, -6F, 1, 7, 4);
fan5.setRotationPoint(0F, 16F, 0F);
fan5.setTextureSize(256, 256);
fan5.mirror = true;
setRotation(fan5, 0F, 3.141593F, 0F);
fan6 = new ModelRenderer(this, 0, 100);
fan6.addBox(-0.5F, -1F, -6F, 1, 7, 4);
fan6.setRotationPoint(0F, 16F, 0F);
fan6.setTextureSize(256, 256);
fan6.mirror = true;
setRotation(fan6, 0F, -2.356194F, 0F);
fan7 = new ModelRenderer(this, 0, 100);
fan7.addBox(-0.5F, -1F, -6F, 1, 7, 4);
fan7.setRotationPoint(0F, 16F, 0F);
fan7.setTextureSize(256, 256);
fan7.mirror = true;
setRotation(fan7, 0F, -1.570796F, 0F);
fan8 = new ModelRenderer(this, 0, 100);
fan8.addBox(-0.5F, -1F, -6F, 1, 7, 4);
fan8.setRotationPoint(0F, 16F, 0F);
fan8.setTextureSize(256, 256);
fan8.mirror = true;
setRotation(fan8, 0F, -0.7853982F, 0F);
rightSide = new ModelRenderer(this, 124, 0);
rightSide.addBox(-8F, 0F, -3F, 2, 10, 9);
rightSide.setRotationPoint(0F, 13F, 0F);
rightSide.setTextureSize(256, 256);
rightSide.mirror = true;
setRotation(rightSide, 0F, 0F, 0F);
leftSide = new ModelRenderer(this, 150, 0);
leftSide.addBox(6F, 0F, -3F, 2, 10, 9);
leftSide.setRotationPoint(0F, 13F, 0F);
leftSide.setTextureSize(256, 256);
leftSide.mirror = true;
setRotation(leftSide, 0F, 0F, 0F);
backSide = new ModelRenderer(this, 120, 111);
backSide.addBox(-8F, 0F, 6F, 16, 15, 2);
backSide.setRotationPoint(0F, 8F, 0F);
backSide.setTextureSize(256, 256);
backSide.mirror = true;
setRotation(backSide, 0F, 0F, 0F);
motor = new ModelRenderer(this, 0, 53);
motor.addBox(-3F, -1F, -3F, 6, 7, 7);
motor.setRotationPoint(0F, 8F, 0F);
motor.setTextureSize(256, 256);
motor.mirror = true;
setRotation(motor, 0F, 0F, 0F);
motorNeck = new ModelRenderer(this, 0, 71);
motorNeck.addBox(-2F, -1F, -2F, 4, 1, 4);
motorNeck.setRotationPoint(0F, 15F, 0F);
motorNeck.setTextureSize(256, 256);
motorNeck.mirror = true;
setRotation(motorNeck, 0F, 0F, 0F);
brace = new ModelRenderer(this, 120, 96);
brace.addBox(0F, 0F, 0F, 14, 5, 5);
brace.setRotationPoint(-7F, 9F, 1F);
brace.setTextureSize(256, 256);
brace.mirror = true;
setRotation(brace, 0F, 0F, 0F);
gauge = new ModelRenderer(this, 0, 17);
gauge.addBox(0F, 0F, 0F, 5, 5, 2);
gauge.setRotationPoint(-8F, 8F, 0F);
gauge.setTextureSize(256, 256);
gauge.mirror = true;
setRotation(gauge, 0F, 0F, 0F);
gaugeFrame = new ModelRenderer(this, 0, 0);
gaugeFrame.addBox(0F, 0F, 0F, 5, 1, 1);
gaugeFrame.setRotationPoint(-8F, 8F, -0.2F);
gaugeFrame.setTextureSize(256, 256);
gaugeFrame.mirror = true;
setRotation(gaugeFrame, 0F, 0F, 0F);
gaugeFrame2 = new ModelRenderer(this, 0, 0);
gaugeFrame2.addBox(0F, 0F, 0F, 4, 1, 1);
gaugeFrame2.setRotationPoint(-7F, 12F, -0.2F);
gaugeFrame2.setTextureSize(256, 256);
gaugeFrame2.mirror = true;
setRotation(gaugeFrame2, 0F, 0F, 0F);
gaugeFrame3 = new ModelRenderer(this, 0, 0);
gaugeFrame3.addBox(0F, 0F, 0F, 1, 4, 1);
gaugeFrame3.setRotationPoint(-8F, 9F, -0.2F);
gaugeFrame3.setTextureSize(256, 256);
gaugeFrame3.mirror = true;
setRotation(gaugeFrame3, 0F, 0F, 0F);
gaugeDieal = new ModelRenderer(this, 0, 28);
gaugeDieal.addBox(-1F, -0.5F, 0F, 3, 1, 0);
gaugeDieal.setRotationPoint(-5F, 12F, -0.2F);
gaugeDieal.setTextureSize(256, 256);
gaugeDieal.mirror = true;
setRotation(gaugeDieal, 0F, 0F, -2.80998F);
}
@Override
public void render(float f5)
{
base.render(f5);
base2.render(f5);
centerBeam.render(f5);
rightSide.render(f5);
leftSide.render(f5);
backSide.render(f5);
motor.render(f5);
motorNeck.render(f5);
brace.render(f5);
gauge.render(f5);
gaugeFrame.render(f5);
gaugeFrame2.render(f5);
gaugeFrame3.render(f5);
gaugeDieal.render(f5);
}
public void renderFan(float f5)
{
fan1.render(f5);
fan2.render(f5);
fan3.render(f5);
fan4.render(f5);
fan5.render(f5);
fan6.render(f5);
fan7.render(f5);
fan8.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
}

140
src/main/java/resonantinduction/old/client/model/ModelTank.java
View file

@ -1,140 +0,0 @@
// Date: 8/14/2012 1:48:41 AM
// Template version 1.1
// Java generated by Techne
// Keep in mind that you still need to fill in some blanks
// - ZeuX
package resonantinduction.old.client.model;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class ModelTank extends ModelBase
{
// One Block Tank
ModelRenderer TANK_WALL_1;
ModelRenderer TANK_WALL_2;
ModelRenderer TANK_WALL_3;
ModelRenderer TANK_WALL_4;
ModelRenderer TANK_SUPPORT_1;
ModelRenderer TANK_TOP_1;
ModelRenderer TANK_WALL_5;
ModelRenderer TANK_SUPPORT_2;
ModelRenderer TANK_SUPPORT_3;
ModelRenderer TANK_WALL_6;
ModelRenderer TANK_TOP_2;
ModelRenderer TANK_TOP_3;
ModelRenderer TANK_VALVE;
public ModelTank(float par1)
{
textureWidth = 128;
textureHeight = 128;
TANK_WALL_1 = new ModelRenderer(this, 0, 49);
TANK_WALL_1.addBox(0F, 0F, 0F, 1, 12, 8, par1);
TANK_WALL_1.setRotationPoint(6F, 12F, -4F);
TANK_WALL_1.setTextureSize(128, 128);
TANK_WALL_1.mirror = true;
setRotation(TANK_WALL_1, 0F, 0F, 0F);
TANK_WALL_2 = new ModelRenderer(this, 0, 70);
TANK_WALL_2.addBox(0F, 0F, 0F, 1, 12, 7, par1);
TANK_WALL_2.setRotationPoint(-8F, 12F, -4F);
TANK_WALL_2.setTextureSize(128, 128);
TANK_WALL_2.mirror = true;
setRotation(TANK_WALL_2, 0F, 0F, 0F);
TANK_WALL_3 = new ModelRenderer(this, 0, 34);
TANK_WALL_3.addBox(0F, 0F, 0F, 8, 12, 1, par1);
TANK_WALL_3.setRotationPoint(0F, 12F, 8F);
TANK_WALL_3.setTextureSize(128, 128);
TANK_WALL_3.mirror = true;
setRotation(TANK_WALL_3, 0F, 2.617994F, 0F);
TANK_WALL_4 = new ModelRenderer(this, 0, 34);
TANK_WALL_4.addBox(0F, 0F, 0F, 8, 12, 1, par1);
TANK_WALL_4.setRotationPoint(0F, 12F, -8F);
TANK_WALL_4.setTextureSize(128, 128);
TANK_WALL_4.mirror = true;
setRotation(TANK_WALL_4, 0F, -0.5235988F, 0F);
TANK_SUPPORT_1 = new ModelRenderer(this, 43, 22);
TANK_SUPPORT_1.addBox(-1F, 0F, -8F, 2, 14, 16, par1);
TANK_SUPPORT_1.setRotationPoint(0F, 10F, 0F);
TANK_SUPPORT_1.setTextureSize(128, 128);
TANK_SUPPORT_1.mirror = true;
setRotation(TANK_SUPPORT_1, 0F, 0F, 0F);
TANK_TOP_1 = new ModelRenderer(this, 43, 11);
TANK_TOP_1.addBox(-8F, 0F, -4F, 16, 2, 8, par1);
TANK_TOP_1.setRotationPoint(0F, 10F, 0F);
TANK_TOP_1.setTextureSize(128, 128);
TANK_TOP_1.mirror = true;
setRotation(TANK_TOP_1, 0F, 0F, 0F);
TANK_WALL_5 = new ModelRenderer(this, 0, 34);
TANK_WALL_5.addBox(0F, 0F, 0F, 8, 12, 1, par1);
TANK_WALL_5.setRotationPoint(0F, 12F, -7F);
TANK_WALL_5.setTextureSize(128, 128);
TANK_WALL_5.mirror = true;
setRotation(TANK_WALL_5, 0F, -2.617994F, 0F);
TANK_SUPPORT_2 = new ModelRenderer(this, 0, 0);
TANK_SUPPORT_2.addBox(-1F, 0F, -9F, 2, 14, 18, par1);
TANK_SUPPORT_2.setRotationPoint(0F, 10F, 0F);
TANK_SUPPORT_2.setTextureSize(128, 128);
TANK_SUPPORT_2.mirror = true;
setRotation(TANK_SUPPORT_2, 0F, 1.047198F, 0F);
TANK_SUPPORT_3 = new ModelRenderer(this, 0, 0);
TANK_SUPPORT_3.addBox(-1F, 0F, -9F, 2, 14, 18, par1);
TANK_SUPPORT_3.setRotationPoint(0F, 10F, 0F);
TANK_SUPPORT_3.setTextureSize(128, 128);
TANK_SUPPORT_3.mirror = true;
setRotation(TANK_SUPPORT_3, 0F, -1.047198F, 0F);
TANK_WALL_6 = new ModelRenderer(this, 0, 34);
TANK_WALL_6.addBox(0F, 0F, 0F, 8, 12, 1, par1);
TANK_WALL_6.setRotationPoint(0F, 12F, 7F);
TANK_WALL_6.setTextureSize(128, 128);
TANK_WALL_6.mirror = true;
setRotation(TANK_WALL_6, 0F, 0.5235988F, 0F);
TANK_TOP_2 = new ModelRenderer(this, 43, 0);
TANK_TOP_2.addBox(-6F, 0F, -4F, 12, 2, 8, par1);
TANK_TOP_2.setRotationPoint(0F, 10F, 0F);
TANK_TOP_2.setTextureSize(128, 128);
TANK_TOP_2.mirror = true;
setRotation(TANK_TOP_2, 0F, 1.047198F, 0F);
TANK_TOP_3 = new ModelRenderer(this, 43, 0);
TANK_TOP_3.addBox(-6F, 0F, -4F, 12, 2, 8, par1);
TANK_TOP_3.setRotationPoint(0F, 10F, 0F);
TANK_TOP_3.setTextureSize(128, 128);
TANK_TOP_3.mirror = true;
setRotation(TANK_TOP_3, 0F, -1.047198F, 0F);
TANK_VALVE = new ModelRenderer(this, 84, 0);
TANK_VALVE.addBox(0F, 0F, 0F, 2, 1, 2, par1);
TANK_VALVE.setRotationPoint(-1F, 9F, -1F);
TANK_VALVE.setTextureSize(128, 128);
TANK_VALVE.mirror = true;
setRotation(TANK_VALVE, 0F, 0F, 0F);
}
public void generalRender(float f5)
{
TANK_WALL_1.render(f5);
TANK_WALL_2.render(f5);
TANK_WALL_3.render(f5);
TANK_WALL_4.render(f5);
TANK_SUPPORT_1.render(f5);
TANK_TOP_1.render(f5);
TANK_WALL_5.render(f5);
TANK_SUPPORT_2.render(f5);
TANK_SUPPORT_3.render(f5);
TANK_WALL_6.render(f5);
TANK_TOP_2.render(f5);
TANK_TOP_3.render(f5);
TANK_VALVE.render(f5);
}
private void setRotation(ModelRenderer model, float x, float y, float z)
{
model.rotateAngleX = x;
model.rotateAngleY = y;
model.rotateAngleZ = z;
}
}