From 0427ab89f1753a44b30cbc35ce021cbbdc845109 Mon Sep 17 00:00:00 2001 From: Foghrye4 Date: Thu, 10 Aug 2017 18:52:45 +0300 Subject: fix missing source folder --- .../CableHolderSelectionBoxSpecialRenderer.java | 42 +++ .../java/ihl/model/FlexibleCableItemRender.java | 178 +++++++++ src/main/java/ihl/model/FluidRenderer.java | 158 ++++++++ src/main/java/ihl/model/IHLBlockRenderer.java | 78 ++++ src/main/java/ihl/model/IHLModelRenderer.java | 369 ++++++++++++++++++ src/main/java/ihl/model/IHLToolRenderer.java | 69 ++++ .../ihl/model/ImpregnatingMachineBlockRender.java | 126 +++++++ .../java/ihl/model/IronWorkbenchBlockRender.java | 107 ++++++ src/main/java/ihl/model/ModelKnee.java | 228 +++++++++++ src/main/java/ihl/model/ModelToplessBox.java | 207 ++++++++++ src/main/java/ihl/model/ModelTube.java | 274 ++++++++++++++ .../model/RectifierTransformerUnitBlockRender.java | 415 +++++++++++++++++++++ ...TransformerUnitSelectionBoxSpecialRenderer.java | 51 +++ .../java/ihl/model/RefluxCondenserBlockRender.java | 125 +++++++ src/main/java/ihl/model/RenderInfo.java | 71 ++++ src/main/java/ihl/model/UniversalTileRender.java | 76 ++++ 16 files changed, 2574 insertions(+) create mode 100644 src/main/java/ihl/model/CableHolderSelectionBoxSpecialRenderer.java create mode 100644 src/main/java/ihl/model/FlexibleCableItemRender.java create mode 100644 src/main/java/ihl/model/FluidRenderer.java create mode 100644 src/main/java/ihl/model/IHLBlockRenderer.java create mode 100644 src/main/java/ihl/model/IHLModelRenderer.java create mode 100644 src/main/java/ihl/model/IHLToolRenderer.java create mode 100644 src/main/java/ihl/model/ImpregnatingMachineBlockRender.java create mode 100644 src/main/java/ihl/model/IronWorkbenchBlockRender.java create mode 100644 src/main/java/ihl/model/ModelKnee.java create mode 100644 src/main/java/ihl/model/ModelToplessBox.java create mode 100644 src/main/java/ihl/model/ModelTube.java create mode 100644 src/main/java/ihl/model/RectifierTransformerUnitBlockRender.java create mode 100644 src/main/java/ihl/model/RectifierTransformerUnitSelectionBoxSpecialRenderer.java create mode 100644 src/main/java/ihl/model/RefluxCondenserBlockRender.java create mode 100644 src/main/java/ihl/model/RenderInfo.java create mode 100644 src/main/java/ihl/model/UniversalTileRender.java (limited to 'src/main/java/ihl/model') diff --git a/src/main/java/ihl/model/CableHolderSelectionBoxSpecialRenderer.java b/src/main/java/ihl/model/CableHolderSelectionBoxSpecialRenderer.java new file mode 100644 index 0000000..e878a78 --- /dev/null +++ b/src/main/java/ihl/model/CableHolderSelectionBoxSpecialRenderer.java @@ -0,0 +1,42 @@ +package ihl.model; + +import org.lwjgl.opengl.GL11; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import ihl.flexible_cable.AnchorTileEntity; +import ihl.interfaces.ISelectionBoxSpecialRenderer; +import ihl.utils.IHLUtils; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.OpenGlHelper; +import net.minecraft.client.renderer.RenderGlobal; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.util.MovingObjectPosition; + +@SideOnly(value=Side.CLIENT) +public class CableHolderSelectionBoxSpecialRenderer implements ISelectionBoxSpecialRenderer +{ + @Override + public void drawSelectionBox(EntityPlayer player, ItemStack currentItem, MovingObjectPosition movingObjectPosition, float partialTick) + { + AnchorTileEntity ate = (AnchorTileEntity) Minecraft.getMinecraft().theWorld.getTileEntity(movingObjectPosition.blockX, movingObjectPosition.blockY, movingObjectPosition.blockZ); + short facing = IHLUtils.getFacingFromPlayerView(player, true); + double[] portPos = ate.energyNetNodes[facing].getPortPos(player); + GL11.glEnable(GL11.GL_BLEND); + OpenGlHelper.glBlendFunc(770, 771, 1, 0); + GL11.glColor4f(0.0F, 0.0F, 0.0F, 0.8F); + GL11.glLineWidth(2.0F); + GL11.glDisable(GL11.GL_TEXTURE_2D); + GL11.glDepthMask(false); + double offsetX = player.lastTickPosX + (player.posX - player.lastTickPosX) * partialTick; + double offsetY = player.lastTickPosY + (player.posY - player.lastTickPosY) * partialTick; + double offsetZ = player.lastTickPosZ + (player.posZ - player.lastTickPosZ) * partialTick; + double size=0.1d; + RenderGlobal.drawOutlinedBoundingBox(AxisAlignedBB.getBoundingBox(portPos[0]-size, portPos[1]-size, portPos[2]-size, portPos[0]+size, portPos[1]+size, portPos[2]+size).getOffsetBoundingBox(-offsetX, -offsetY, -offsetZ), -1); + GL11.glDepthMask(true); + GL11.glEnable(GL11.GL_TEXTURE_2D); + GL11.glDisable(GL11.GL_BLEND); + } +} diff --git a/src/main/java/ihl/model/FlexibleCableItemRender.java b/src/main/java/ihl/model/FlexibleCableItemRender.java new file mode 100644 index 0000000..e11a253 --- /dev/null +++ b/src/main/java/ihl/model/FlexibleCableItemRender.java @@ -0,0 +1,178 @@ +package ihl.model; + +import org.lwjgl.opengl.GL11; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import ihl.items_blocks.FlexibleCableItem; +import net.minecraft.client.Minecraft; +import net.minecraft.client.entity.EntityClientPlayerMP; +import net.minecraft.client.renderer.GLAllocation; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.client.renderer.entity.RenderManager; +import net.minecraft.client.renderer.entity.RenderPlayer; +import net.minecraft.item.ItemStack; +import net.minecraftforge.client.IItemRenderer; +import net.minecraftforge.common.util.ForgeDirection; + +@SideOnly(value=Side.CLIENT) +public class FlexibleCableItemRender implements IItemRenderer { + private ModelTube model; + private ModelTube modelThin; + private ModelTube modelLong; + private ModelTube modelThinLong; + private final int segmentsAmount = 19; + private final float spiralStepAngle = 1f; + private final float scale = 1 / 32f; + private final int[] displayListCache = new int[4]; + + public FlexibleCableItemRender() { + float vOffset = 16f; + int longFragmensSize = 24; + model = new ModelTube(null, 0, 0, -2F, -3F, -2F + vOffset, 4, 6, 4, 0f, 0.5f, 0.99f, ForgeDirection.UP); + modelLong = new ModelTube(null, 0, 0, -2F, -3F, -2F + vOffset, 4, longFragmensSize, 4, 0f, 0f, 0.99f, + ForgeDirection.UP); + modelThin = new ModelTube(null, 0, 0, -1F, -3F, -1F + vOffset, 2, 6, 2, 0f, 0.5f, 0.99f, ForgeDirection.UP); + modelThinLong = new ModelTube(null, 0, 0, -1F, -3F, -1F + vOffset, 2, longFragmensSize, 2, 0f, 0.5f, 0.99f, + ForgeDirection.UP); + } + + @Override + public boolean handleRenderType(ItemStack item, ItemRenderType type) { + switch (type) { + case ENTITY: + return true; + case EQUIPPED: + return true; + case EQUIPPED_FIRST_PERSON: + return true; + case INVENTORY: + return true; + default: + return false; + } + } + + @Override + public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) { + return true; + } + + @Override + public void renderItem(ItemRenderType type, ItemStack stack, Object... data) { + GL11.glPushMatrix(); + GL11.glEnable(GL11.GL_BLEND); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + GL11.glScalef(1F, -1F, -1F); + switch (type) { + case ENTITY: + GL11.glTranslatef(0, -1.0F, 0); + this.rendercoil(stack); + break; + case EQUIPPED: + GL11.glTranslatef(0.25F, -2F, -0.75F); + this.rendercoil(stack); + break; + case EQUIPPED_FIRST_PERSON: + RenderPlayer var25; + EntityClientPlayerMP var3 = Minecraft.getMinecraft().thePlayer; + Minecraft.getMinecraft().getTextureManager().bindTexture(var3.getLocationSkin()); + var25 = (RenderPlayer) RenderManager.instance.getEntityRenderObject(Minecraft.getMinecraft().thePlayer); + GL11.glRotatef(135F, 1.0F, 0.0F, 0.0F); + GL11.glRotatef(35F, 0.0F, 1.0F, 0.0F); + var25.renderFirstPersonArm(Minecraft.getMinecraft().thePlayer); + GL11.glRotatef(-35F, 0.0F, 1.0F, 0.0F); + GL11.glRotatef(-135F, 1.0F, 0.0F, 0.0F); + GL11.glTranslatef(0.0F, 0.2F, 0F); + GL11.glTranslatef(-0.25F, -1.0F, 0F); + this.rendercoil(stack); + break; + case INVENTORY: + GL11.glTranslatef(0.0F, -0.2F, 0F); + this.rendercoil(stack); + break; + default: + } + GL11.glPopMatrix(); + } + + private void rendercoil(ItemStack stack) { + int type = this.getCableType(stack); + if (this.displayListCache[type] != 0) { + GL11.glCallList(displayListCache[type]); + } else { + + this.displayListCache[type] = GLAllocation.generateDisplayLists(1); + GL11.glNewList(displayListCache[type], 4864 /* GL_COMPILE */); + + GL11.glDisable(GL11.GL_TEXTURE_2D); + int saMax = this.segmentsAmount * 2 + this.segmentsAmount / 2; + for (int i = 0; i <= saMax; i++) { + GL11.glRotatef(-spiralStepAngle, 0f, 0f, 1f); + GL11.glRotatef(360f / this.segmentsAmount, 1f, 0f, 0f); + GL11.glTranslatef(0.004f, 0f, 0f); + GL11.glRotatef(spiralStepAngle, 0f, 0f, 1f); + GL11.glColor3f(1f, 1f, 1f); + if (i == 0) { + if (isNoInsulation(stack)) { + if (FlexibleCableItem.instance.yellowColoredWires + .contains(FlexibleCableItem.instance.getMaterial(stack))) { + GL11.glColor3f(1f, 0.75f, 0.1f); + } else { + GL11.glColor3f(0.65f, 0.65f, 0.67f); + } + this.modelThinLong.render(Tessellator.instance, scale); + + } else { + this.modelLong.render(Tessellator.instance, scale); + } + } else if (i == saMax) { + GL11.glTranslatef(0.0F, -0.55F, 0F); + if (isNoInsulation(stack)) { + if (FlexibleCableItem.instance.yellowColoredWires + .contains(FlexibleCableItem.instance.getMaterial(stack))) { + GL11.glColor3f(1f, 0.75f, 0.1f); + } else { + GL11.glColor3f(0.65f, 0.65f, 0.67f); + } + this.modelThinLong.render(Tessellator.instance, scale); + + } else { + this.modelLong.render(Tessellator.instance, scale); + } + GL11.glTranslatef(0.0F, 0.55F, 0F); + } else { + if (isNoInsulation(stack)) { + if (FlexibleCableItem.instance.yellowColoredWires + .contains(FlexibleCableItem.instance.getMaterial(stack))) { + GL11.glColor3f(1f, 0.75f, 0.1f); + } else { + GL11.glColor3f(0.65f, 0.65f, 0.67f); + } + this.modelThin.render(Tessellator.instance, scale); + + } else { + this.model.render(Tessellator.instance, scale); + } + } + } + GL11.glEnable(GL11.GL_TEXTURE_2D); + GL11.glEndList(); + } + } + + private int getCableType(ItemStack stack) { + if (isNoInsulation(stack)) { + if (FlexibleCableItem.instance.yellowColoredWires.contains(FlexibleCableItem.instance.getMaterial(stack))) { + return 1; + } else { + return 2; + } + } + return 0; + } + + private boolean isNoInsulation(ItemStack stack) { + return stack.stackTagCompound != null && FlexibleCableItem.instance.getInsulationMaterial(stack).equals("null"); + } +} \ No newline at end of file diff --git a/src/main/java/ihl/model/FluidRenderer.java b/src/main/java/ihl/model/FluidRenderer.java new file mode 100644 index 0000000..674e4ea --- /dev/null +++ b/src/main/java/ihl/model/FluidRenderer.java @@ -0,0 +1,158 @@ +package ihl.model; +/* This code with minimal changes was + * taken by me (Foghrye4) from + * RailCraft GitHub. + */ + +/* + * Copyright (c) CovertJaguar, 2014 http://railcraft.info + * + * This code is the property of CovertJaguar + * and may only be used with explicit written + * permission unless otherwise specified on the + * license page at http://railcraft.info/wiki/info:license. + */ +import java.util.HashMap; +import java.util.Map; + +import org.lwjgl.opengl.GL11; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.GLAllocation; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.client.renderer.texture.TextureMap; +import net.minecraft.init.Blocks; +import net.minecraft.util.IIcon; +import net.minecraft.util.ResourceLocation; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; + +/** + * + * @author CovertJaguar + */ +@SideOnly(value=Side.CLIENT) +public class FluidRenderer { + + private static RenderBlocks renderBlocks = new RenderBlocks(); + private static final ResourceLocation BLOCK_TEXTURE = TextureMap.locationBlocksTexture; + private static final Map flowingRenderCache = new HashMap(); + private static final Map stillRenderCache = new HashMap(); + public static final int DISPLAY_STAGES = 100; + private static final RenderInfo liquidBlock = new RenderInfo(); + + static { + liquidBlock.texture = new IIcon[1]; + } + + public static IIcon getFluidTexture(FluidStack fluidStack, boolean flowing) { + if (fluidStack == null) + return ((TextureMap) Minecraft.getMinecraft().getTextureManager().getTexture(TextureMap.locationBlocksTexture)).getAtlasSprite("missingno"); + Fluid fluid = fluidStack.getFluid(); + if (fluid == null) + return ((TextureMap) Minecraft.getMinecraft().getTextureManager().getTexture(TextureMap.locationBlocksTexture)).getAtlasSprite("missingno"); + IIcon icon = flowing ? fluid.getFlowingIcon() : fluid.getStillIcon(); + if(icon==null) + { + icon = ((TextureMap) Minecraft.getMinecraft().getTextureManager().getTexture(TextureMap.locationBlocksTexture)).getAtlasSprite("missingno"); + } + return icon; + } + + public static ResourceLocation getFluidSheet(FluidStack liquid) { + return BLOCK_TEXTURE; + } + + public static ResourceLocation setupFlowingLiquidTexture(FluidStack liquid, IIcon[] texArray) { + if (liquid == null || liquid.amount <= 0) + return null; + + Fluid fluid = liquid.getFluid(); + if (fluid == null) + return null; + IIcon top = fluid.getStillIcon(); + IIcon side = fluid.getFlowingIcon(); + texArray[0] = top; + texArray[1] = top; + texArray[2] = side; + texArray[3] = side; + texArray[4] = side; + texArray[5] = side; + return getFluidSheet(liquid); + } + + public static int[] getLiquidDisplayLists(FluidStack fluidStack) { + return getLiquidDisplayLists(fluidStack, false); + } + + public static int[] getLiquidDisplayLists(FluidStack fluidStack, boolean flowing) { + if (fluidStack == null) + return null; + Fluid fluid = fluidStack.getFluid(); + if (fluid == null) + return null; + Map cache = flowing ? flowingRenderCache : stillRenderCache; + int[] diplayLists = cache.get(fluid); + if (diplayLists != null) + return diplayLists; + + diplayLists = new int[DISPLAY_STAGES]; + + liquidBlock.texture[0] = null; + + if (fluid.getBlock() != null) { + liquidBlock.template = fluid.getBlock(); + liquidBlock.texture[0] = getFluidTexture(fluidStack, flowing); + } else { + liquidBlock.template = Blocks.water; + liquidBlock.texture[0] = getFluidTexture(fluidStack, flowing); + } + + GL11.glDisable(GL11.GL_LIGHTING); + GL11.glDisable(GL11.GL_BLEND); + GL11.glDisable(GL11.GL_CULL_FACE); + for (int s = 0; s < DISPLAY_STAGES; ++s) { + diplayLists[s] = GLAllocation.generateDisplayLists(1); + GL11.glNewList(diplayLists[s], 4864 /*GL_COMPILE*/); + + liquidBlock.minX = 0.01f; + liquidBlock.minY = 0; + liquidBlock.minZ = 0.01f; + + liquidBlock.maxX = 0.99f; + liquidBlock.maxY = (float) s / (float) DISPLAY_STAGES; + liquidBlock.maxZ = 0.99f; + Tessellator tessellator = Tessellator.instance; + tessellator.startDrawingQuads(); + RenderInfo info = liquidBlock; + renderBlocks.setRenderBounds(info.minX, info.minY, info.minZ, info.maxX, info.maxY, info.maxZ); + + if (info.renderSide[0]) + renderBlocks.renderFaceYNeg(info.template, 0D, 0D, 0D, info.getBlockTextureFromSide(0)); + if (info.renderSide[1]) + renderBlocks.renderFaceYPos(info.template, 0D, 0D, 0D, info.getBlockTextureFromSide(1)); + if (info.renderSide[2]) + renderBlocks.renderFaceZNeg(info.template, 0D, 0D, 0D, info.getBlockTextureFromSide(2)); + if (info.renderSide[3]) + renderBlocks.renderFaceZPos(info.template, 0D, 0D, 0D, info.getBlockTextureFromSide(3)); + if (info.renderSide[4]) + renderBlocks.renderFaceXNeg(info.template, 0D, 0D, 0D, info.getBlockTextureFromSide(4)); + if (info.renderSide[5]) + renderBlocks.renderFaceXPos(info.template, 0D, 0D, 0D, info.getBlockTextureFromSide(5)); + tessellator.draw(); + GL11.glEndList(); + } + + GL11.glColor4f(1, 1, 1, 1); + GL11.glEnable(GL11.GL_CULL_FACE); + GL11.glEnable(GL11.GL_BLEND); + + cache.put(fluid, diplayLists); + + return diplayLists; + } + +} diff --git a/src/main/java/ihl/model/IHLBlockRenderer.java b/src/main/java/ihl/model/IHLBlockRenderer.java new file mode 100644 index 0000000..81efbd9 --- /dev/null +++ b/src/main/java/ihl/model/IHLBlockRenderer.java @@ -0,0 +1,78 @@ +package ihl.model; + +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import org.lwjgl.opengl.GL11; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import ihl.handpump.BlockWithCoordinates; +import net.minecraft.client.renderer.GLAllocation; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.world.ChunkCache; +import net.minecraft.world.World; + +@SideOnly(value=Side.CLIENT) +public class IHLBlockRenderer { + + private RenderBlocks renderBlocks; + private final Map renderCache = new HashMap(); + public static IHLBlockRenderer instance; + + public IHLBlockRenderer() + { + renderBlocks=RenderBlocks.getInstance(); + instance=this; + } + + public void refreshDisplayLists(int diplayLists, List bwc, ChunkCache iBlockAccess) + { + if (bwc==null || bwc.isEmpty()) + { + return; + } + renderBlocks.blockAccess=iBlockAccess; + GL11.glNewList(diplayLists, 4864 /*GL_COMPILE*/); + Iterator bwci = bwc.iterator(); + while(bwci.hasNext()) + { + BlockWithCoordinates bwce = bwci.next(); + renderBlock(bwce); + } + GL11.glEndList(); + } + + + public int getBlockDisplayLists(BlockWithCoordinates bwc, World world) { + if (bwc.block == null) + { + return -1; + } + if(renderCache.containsKey(bwc)) + { + return renderCache.get(bwc); + } + int diplayLists = GLAllocation.generateDisplayLists(1); + if(renderBlocks.blockAccess==null || !renderBlocks.blockAccess.equals(world)) + { + renderBlocks.blockAccess=world; + } + GL11.glNewList(diplayLists, 4864 /*GL_COMPILE*/); + renderBlock(bwc); + GL11.glEndList(); + renderCache.put(bwc, diplayLists); + return diplayLists; + } + + private void renderBlock(BlockWithCoordinates bwc) + { + Tessellator tessellator = Tessellator.instance; + tessellator.startDrawingQuads(); + renderBlocks.renderBlockByRenderType(bwc.block, bwc.x, bwc.y, bwc.z); + tessellator.draw(); + } +} diff --git a/src/main/java/ihl/model/IHLModelRenderer.java b/src/main/java/ihl/model/IHLModelRenderer.java new file mode 100644 index 0000000..0bf95d2 --- /dev/null +++ b/src/main/java/ihl/model/IHLModelRenderer.java @@ -0,0 +1,369 @@ +package ihl.model; + +import java.util.ArrayList; +import java.util.List; + +import org.lwjgl.opengl.GL11; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.model.ModelBase; +import net.minecraft.client.model.ModelRenderer; +import net.minecraft.client.model.TextureOffset; +import net.minecraft.client.renderer.GLAllocation; +import net.minecraft.client.renderer.Tessellator; +import net.minecraftforge.common.util.ForgeDirection; + +@SideOnly(value=Side.CLIENT) +public class IHLModelRenderer { + /** The size of the texture file's width in pixels. */ + public float textureWidth; + + /** The size of the texture file's height in pixels. */ + public float textureHeight; + + /** The X offset into the texture used for displaying this model */ + private int textureOffsetX; + + /** The Y offset into the texture used for displaying this model */ + private int textureOffsetY; + public float rotationPointX; + public float rotationPointY; + public float rotationPointZ; + public float rotateAngleX; + public float rotateAngleY; + public float rotateAngleZ; + private boolean compiled; + + /** The GL display list rendered by the Tessellator for this model */ + private int displayList; + public boolean mirror; + public boolean showModel; + + /** Hides the model. */ + public boolean isHidden; + public List cubeList; + public List childModels; + public final String boxName; + private ModelBase baseModel; + public float offsetX; + public float offsetY; + public float offsetZ; + + public boolean drawFromInside=false; + + @SuppressWarnings("unchecked") + public IHLModelRenderer(ModelBase par1ModelBase, String par2Str) + { + this.textureWidth = 64.0F; + this.textureHeight = 32.0F; + this.showModel = true; + this.cubeList = new ArrayList(); + this.baseModel = par1ModelBase; + par1ModelBase.boxList.add(this); + this.boxName = par2Str; + this.setTextureSize(par1ModelBase.textureWidth, par1ModelBase.textureHeight); + } + + public IHLModelRenderer(ModelBase par1ModelBase) + { + this(par1ModelBase, (String)null); + } + + public IHLModelRenderer(ModelBase par1ModelBase, int par2, int par3) + { + this(par1ModelBase); + this.setTextureOffset(par2, par3); + } + + /** + * Sets the current box's rotation points and rotation angles to another box. + */ + public void addChild(ModelRenderer par1ModelRenderer) + { + if (this.childModels == null) + { + this.childModels = new ArrayList(); + } + + this.childModels.add(par1ModelRenderer); + } + + public IHLModelRenderer setTextureOffset(int par1, int par2) + { + this.textureOffsetX = par1; + this.textureOffsetY = par2; + return this; + } + + public IHLModelRenderer addBox(String par1Str, float par2, float par3, float par4, int par5, int par6, int par7, boolean inverted, boolean[] renderFace) + { + par1Str = this.boxName + "." + par1Str; + TextureOffset var8 = this.baseModel.getTextureOffset(par1Str); + this.setTextureOffset(var8.textureOffsetX, var8.textureOffsetY); + this.cubeList.add((new ModelToplessBox(this, this.textureOffsetX, this.textureOffsetY, par2, par3, par4, par5, par6, par7, 0.0F, inverted, renderFace)).func_78244_a(par1Str)); + return this; + } + + public IHLModelRenderer addBox(String par1Str, float par2, float par3, float par4, int par5, int par6, int par7, boolean inverted) + { + boolean[] renderFace={true,true,true,true,true,true}; + par1Str = this.boxName + "." + par1Str; + TextureOffset var8 = this.baseModel.getTextureOffset(par1Str); + this.setTextureOffset(var8.textureOffsetX, var8.textureOffsetY); + this.cubeList.add((new ModelToplessBox(this, this.textureOffsetX, this.textureOffsetY, par2, par3, par4, par5, par6, par7, 0.0F, inverted, renderFace)).func_78244_a(par1Str)); + return this; + } + + public IHLModelRenderer addBox(float par1, float par2, float par3, int par4, int par5, int par6, boolean inverted, boolean[] renderFace) + { + this.cubeList.add(new ModelToplessBox(this, this.textureOffsetX, this.textureOffsetY, par1, par2, par3, par4, par5, par6, 0.0F, inverted, renderFace)); + return this; + } + + public IHLModelRenderer addTube(String par1Str, float par1, float par2, float par3, int par4, int par5, int par6, float radius1, float radius2, ForgeDirection direction) + { + par1Str = this.boxName + "." + par1Str; + TextureOffset var8 = this.baseModel.getTextureOffset(par1Str); + this.setTextureOffset(var8.textureOffsetX, var8.textureOffsetY); + this.cubeList.add(new ModelTube(this, this.textureOffsetX, this.textureOffsetY, par1, par2, par3, par4, par5, par6, 0.0F, radius1,radius2, direction)); + return this; + } + + public IHLModelRenderer addKnee(String par1Str, float par1, float par2, float par3, int par4, int par5, int par6, float radius1, float radius2, ForgeDirection direction, ForgeDirection direction2) + { + par1Str = this.boxName + "." + par1Str; + TextureOffset var8 = this.baseModel.getTextureOffset(par1Str); + this.setTextureOffset(var8.textureOffsetX, var8.textureOffsetY); + this.cubeList.add(new ModelKnee(this, this.textureOffsetX, this.textureOffsetY, par1, par2, par3, par4, par5, par6, 0.0F, radius1,radius2, direction, direction2)); + return this; + } + + public IHLModelRenderer addBox(float par1, float par2, float par3, int par4, int par5, int par6) + { + boolean[] renderFace={true,true,true,true,true,true}; + this.cubeList.add(new ModelToplessBox(this, this.textureOffsetX, this.textureOffsetY, par1, par2, par3, par4, par5, par6, 0.0F, false, renderFace)); + return this; + } + + /** + * Creates a textured box. Args: originX, originY, originZ, width, height, depth, scaleFactor. + */ + public void addBox(float par1, float par2, float par3, int par4, int par5, int par6, float par7, boolean inverted, boolean[] renderFace) + { + this.cubeList.add(new ModelToplessBox(this, this.textureOffsetX, this.textureOffsetY, par1, par2, par3, par4, par5, par6, par7, inverted, renderFace)); + } + + public void setRotationPoint(float par1, float par2, float par3) + { + this.rotationPointX = par1; + this.rotationPointY = par2; + this.rotationPointZ = par3; + } + + public void render(float par1) + { + if (!this.isHidden) + { + if (this.showModel) + { + if (!this.compiled) + { + this.compileDisplayList(par1); + } + + GL11.glTranslatef(this.offsetX, this.offsetY, this.offsetZ); + int var2; + + if (this.rotateAngleX == 0.0F && this.rotateAngleY == 0.0F && this.rotateAngleZ == 0.0F) + { + if (this.rotationPointX == 0.0F && this.rotationPointY == 0.0F && this.rotationPointZ == 0.0F) + { + GL11.glCallList(this.displayList); + + if (this.childModels != null) + { + for (var2 = 0; var2 < this.childModels.size(); ++var2) + { + ((ModelRenderer)this.childModels.get(var2)).render(par1); + } + } + } + else + { + GL11.glTranslatef(this.rotationPointX * par1, this.rotationPointY * par1, this.rotationPointZ * par1); + GL11.glCallList(this.displayList); + + if (this.childModels != null) + { + for (var2 = 0; var2 < this.childModels.size(); ++var2) + { + ((ModelRenderer)this.childModels.get(var2)).render(par1); + } + } + + GL11.glTranslatef(-this.rotationPointX * par1, -this.rotationPointY * par1, -this.rotationPointZ * par1); + } + } + else + { + GL11.glPushMatrix(); + GL11.glTranslatef(this.rotationPointX * par1, this.rotationPointY * par1, this.rotationPointZ * par1); + + if (this.rotateAngleZ != 0.0F) + { + GL11.glRotatef(this.rotateAngleZ * (180F / (float)Math.PI), 0.0F, 0.0F, 1.0F); + } + + if (this.rotateAngleY != 0.0F) + { + GL11.glRotatef(this.rotateAngleY * (180F / (float)Math.PI), 0.0F, 1.0F, 0.0F); + } + + if (this.rotateAngleX != 0.0F) + { + GL11.glRotatef(this.rotateAngleX * (180F / (float)Math.PI), 1.0F, 0.0F, 0.0F); + } + + GL11.glCallList(this.displayList); + + if (this.childModels != null) + { + for (var2 = 0; var2 < this.childModels.size(); ++var2) + { + ((ModelRenderer)this.childModels.get(var2)).render(par1); + } + } + + GL11.glPopMatrix(); + } + + GL11.glTranslatef(-this.offsetX, -this.offsetY, -this.offsetZ); + } + } + } + + public void renderWithRotation(float par1) + { + if (!this.isHidden) + { + if (this.showModel) + { + if (!this.compiled) + { + this.compileDisplayList(par1); + } + + GL11.glPushMatrix(); + GL11.glTranslatef(this.rotationPointX * par1, this.rotationPointY * par1, this.rotationPointZ * par1); + + if (this.rotateAngleY != 0.0F) + { + GL11.glRotatef(this.rotateAngleY * (180F / (float)Math.PI), 0.0F, 1.0F, 0.0F); + } + + if (this.rotateAngleX != 0.0F) + { + GL11.glRotatef(this.rotateAngleX * (180F / (float)Math.PI), 1.0F, 0.0F, 0.0F); + } + + if (this.rotateAngleZ != 0.0F) + { + GL11.glRotatef(this.rotateAngleZ * (180F / (float)Math.PI), 0.0F, 0.0F, 1.0F); + } + + GL11.glCallList(this.displayList); + GL11.glPopMatrix(); + } + } + } + + /** + * Allows the changing of Angles after a box has been rendered + */ + public void postRender(float par1) + { + if (!this.isHidden) + { + if (this.showModel) + { + if (!this.compiled) + { + this.compileDisplayList(par1); + } + + if (this.rotateAngleX == 0.0F && this.rotateAngleY == 0.0F && this.rotateAngleZ == 0.0F) + { + if (this.rotationPointX != 0.0F || this.rotationPointY != 0.0F || this.rotationPointZ != 0.0F) + { + GL11.glTranslatef(this.rotationPointX * par1, this.rotationPointY * par1, this.rotationPointZ * par1); + } + } + else + { + GL11.glTranslatef(this.rotationPointX * par1, this.rotationPointY * par1, this.rotationPointZ * par1); + + if (this.rotateAngleZ != 0.0F) + { + GL11.glRotatef(this.rotateAngleZ * (180F / (float)Math.PI), 0.0F, 0.0F, 1.0F); + } + + if (this.rotateAngleY != 0.0F) + { + GL11.glRotatef(this.rotateAngleY * (180F / (float)Math.PI), 0.0F, 1.0F, 0.0F); + } + + if (this.rotateAngleX != 0.0F) + { + GL11.glRotatef(this.rotateAngleX * (180F / (float)Math.PI), 1.0F, 0.0F, 0.0F); + } + } + } + } + } + + /** + * Compiles a GL display list for this model + */ + private void compileDisplayList(float par1) + { + this.displayList = GLAllocation.generateDisplayLists(1); + GL11.glNewList(this.displayList, GL11.GL_COMPILE); + Tessellator var2 = Tessellator.instance; + + for (int var3 = 0; var3 < this.cubeList.size(); ++var3) + { + if(this.cubeList.get(var3) instanceof ModelToplessBox) + { + ((ModelToplessBox)this.cubeList.get(var3)).render(var2, par1); + } + else if(this.cubeList.get(var3) instanceof ModelTube) + { + ((ModelTube)this.cubeList.get(var3)).render(var2, par1); + } + else if(this.cubeList.get(var3) instanceof ModelKnee) + { + ((ModelKnee)this.cubeList.get(var3)).render(var2, par1); + } + } + + GL11.glEndList(); + this.compiled = true; + } + + /** + * Returns the model renderer with the new texture parameters. + */ + public IHLModelRenderer setTextureSize(int par1, int par2) + { + this.textureWidth = par1; + this.textureHeight = par2; + return this; + } + + public void addBox(String string, float f, float g, float h, int i, int j, int k) { + this.addBox(string, f, g, h, i, j, k, false); + } + + +} diff --git a/src/main/java/ihl/model/IHLToolRenderer.java b/src/main/java/ihl/model/IHLToolRenderer.java new file mode 100644 index 0000000..31758b2 --- /dev/null +++ b/src/main/java/ihl/model/IHLToolRenderer.java @@ -0,0 +1,69 @@ +package ihl.model; + +import org.lwjgl.opengl.GL11; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.ItemRenderer; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.client.renderer.texture.TextureMap; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraftforge.client.IItemRenderer; + +@SideOnly(value=Side.CLIENT) +public class IHLToolRenderer implements IItemRenderer +{ + + @Override + public boolean handleRenderType(ItemStack item, ItemRenderType type) { + switch (type) { + case ENTITY: + return true; + case EQUIPPED: + return true; + case EQUIPPED_FIRST_PERSON: + return true; + case INVENTORY: + return true; + default: + return false; + } + } + + @Override + public void renderItem(ItemRenderType irt, ItemStack stack, Object... arg2) + { + IIcon icon = stack.getItem().getIcon(stack, 0); + Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationItemsTexture); + if(irt.equals(ItemRenderType.INVENTORY)) + { + GL11.glEnable(GL11.GL_BLEND); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + Tessellator tessellator = Tessellator.instance; + tessellator.startDrawingQuads(); + tessellator.setNormal(0f, 0f, -1f); + double xStart=0d,yStart=0d; + double xEnd=16d,yEnd=16d; + double z = 0.001d; + tessellator.addVertexWithUV(xStart, yEnd, z, icon.getMinU(), icon.getMaxV()); + tessellator.addVertexWithUV(xEnd, yEnd, z, icon.getMaxU(), icon.getMaxV()); + tessellator.addVertexWithUV(xEnd, yStart, z, icon.getMaxU(), icon.getMinV()); + tessellator.addVertexWithUV(xStart, yStart, z, icon.getMinU(), icon.getMinV()); + tessellator.draw(); + GL11.glDisable(GL11.GL_BLEND); + } + else + { + ItemRenderer.renderItemIn2D(Tessellator.instance, icon.getMaxU(), icon.getMinV(), icon.getMinU(), icon.getMaxV(), icon.getIconWidth(), icon.getIconHeight(), 0.0625F); + } + } + + @Override + public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack arg1, ItemRendererHelper arg2) + { + return type.equals(ItemRenderType.ENTITY); + } + +} diff --git a/src/main/java/ihl/model/ImpregnatingMachineBlockRender.java b/src/main/java/ihl/model/ImpregnatingMachineBlockRender.java new file mode 100644 index 0000000..2602fd0 --- /dev/null +++ b/src/main/java/ihl/model/ImpregnatingMachineBlockRender.java @@ -0,0 +1,126 @@ +package ihl.model; + +import org.lwjgl.opengl.GL11; + +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; +import ihl.items_blocks.MachineBaseBlock; +import ihl.items_blocks.MachineBaseBlock.MachineType; +import net.minecraft.block.Block; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.util.IIcon; +import net.minecraft.world.IBlockAccess; + +@SideOnly(value=Side.CLIENT) +public class ImpregnatingMachineBlockRender implements ISimpleBlockRenderingHandler +{ + public static int renderId; + + public ImpregnatingMachineBlockRender() + { + renderId = RenderingRegistry.getNextAvailableRenderId(); + } + + @Override + public int getRenderId() + { + return renderId; + } + + @Override + public void renderInventoryBlock(Block block, int metadata, int modelID, RenderBlocks renderblocks) + { + MachineBaseBlock blockmb = (MachineBaseBlock) block; + Tessellator tessellator = Tessellator.instance; + block.setBlockBoundsForItemRender(); + renderblocks.setRenderBoundsFromBlock(block); + GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F); + GL11.glTranslatef(-0.5F, -0.5F, -0.5F); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, -1.0F, 0.0F); + renderblocks.renderFaceYNeg(block, 0.0D, 0.0D, 0.0D, renderblocks.getBlockIconFromSideAndMetadata(block, 0, metadata)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, 1.0F, 0.0F); + renderblocks.renderFaceYPos(block, 0.0D, 0.0D, 0.0D, renderblocks.getBlockIconFromSideAndMetadata(block, 1, metadata)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, 0.0F, -1.0F); + renderblocks.renderFaceZNeg(block, 0.0D, 0.0D, 0.0D, renderblocks.getBlockIconFromSideAndMetadata(block, 2, metadata)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, 0.0F, 1.0F); + renderblocks.renderFaceZPos(block, 0.0D, 0.0D, 0.0D, renderblocks.getBlockIconFromSideAndMetadata(block, 3, metadata)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(-1.0F, 0.0F, 0.0F); + renderblocks.renderFaceXNeg(block, 0.0D, 0.0D, 0.0D, renderblocks.getBlockIconFromSideAndMetadata(block, 4, metadata)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(1.0F, 0.0F, 0.0F); + renderblocks.renderFaceXPos(block, 0.0D, 0.0D, 0.0D, renderblocks.getBlockIconFromSideAndMetadata(block, 5, metadata)); + tessellator.draw(); + float var11 = 0.0625F; + IIcon innerSideIcon = blockmb.getAdditionalIconsForBlockRenderer(0); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, 0.0F, -1.0F); + renderblocks.renderFaceZNeg(block, 0.0D, 0.0D, 1.0F - var11, innerSideIcon); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, 0.0F, 1.0F); + renderblocks.renderFaceZPos(block, 0.0D, 0.0D, var11-1.0F, innerSideIcon); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(-1.0F, 0.0F, 0.0F); + renderblocks.renderFaceXNeg(block, 1.0F - var11, 0.0D, 0.0D, innerSideIcon); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(1.0F, 0.0F, 0.0F); + renderblocks.renderFaceXPos(block, var11-1.0F, 0.0D, 0.0D, innerSideIcon); + tessellator.draw(); + IIcon innerBottomIcon = blockmb.getAdditionalIconsForBlockRenderer(1); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, 1.0F, 0.0F); + if(blockmb.type.equals(MachineType.SolarEvaporator)) + var11 = 0.5625f; + renderblocks.renderFaceYPos(block, 0.0D, var11-1.0F, 0.0D, innerBottomIcon); + tessellator.draw(); + GL11.glTranslatef(0.5F, 0.5F, 0.5F); + } + + @Override + public boolean renderWorldBlock(IBlockAccess blockAccess, int x, int y, int z, Block block, int meta, RenderBlocks blockRenderer) + { + MachineBaseBlock blockmb = (MachineBaseBlock) block; + blockRenderer.renderStandardBlock(block, x, y, z); + Tessellator var5 = Tessellator.instance; + var5.setBrightness(block.getMixedBrightnessForBlock(blockAccess, x, y, z)); + int var6 = block.colorMultiplier(blockAccess, x, y, z); + float var7 = (var6 >> 16 & 255) / 255.0F; + float var8 = (var6 >> 8 & 255) / 255.0F; + float var9 = (var6 & 255) / 255.0F; + float var11; + var5.setColorOpaque_F(var7, var8, var9); + IIcon innerSideIcon = blockmb.getAdditionalIconsForBlockRenderer(0); + var11 = 0.0625F; + + blockRenderer.renderFaceXPos(block, x - 1.0F + var11, y, z, innerSideIcon); + blockRenderer.renderFaceXNeg(block, x + 1.0F - var11, y, z, innerSideIcon); + blockRenderer.renderFaceZPos(block, x, y, z - 1.0F + var11, innerSideIcon); + blockRenderer.renderFaceZNeg(block, x, y, z + 1.0F - var11, innerSideIcon); + IIcon innerBottomIcon = blockmb.getAdditionalIconsForBlockRenderer(1); + if(blockmb.type.equals(MachineType.SolarEvaporator)) + var11 = 0.5625f; + blockRenderer.renderFaceYPos(block, x, y - 1.0F + var11, z, innerBottomIcon); + return true; + } + + @Override + public boolean shouldRender3DInInventory(int arg0) + { + return true; + } +} diff --git a/src/main/java/ihl/model/IronWorkbenchBlockRender.java b/src/main/java/ihl/model/IronWorkbenchBlockRender.java new file mode 100644 index 0000000..1af81cf --- /dev/null +++ b/src/main/java/ihl/model/IronWorkbenchBlockRender.java @@ -0,0 +1,107 @@ +package ihl.model; + +import org.lwjgl.opengl.GL11; + +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; +import net.minecraft.block.Block; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.world.IBlockAccess; + +@SideOnly(value=Side.CLIENT) +public class IronWorkbenchBlockRender implements ISimpleBlockRenderingHandler +{ + public static int renderId; + + public IronWorkbenchBlockRender() + { + renderId = RenderingRegistry.getNextAvailableRenderId(); + } + + @Override + public int getRenderId() + { + return renderId; + } + + @Override + public void renderInventoryBlock(Block block, int metadata, int modelID, RenderBlocks renderblocks) + { + Tessellator tessellator = Tessellator.instance; + GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F); + GL11.glTranslatef(-0.5F, -0.5F, -0.5F); + tessellator.startDrawingQuads(); + for(int i=0;i<=5;i++) + { + this.setBounds(i, renderblocks, block); + tessellator.setNormal(0.0F, -1.0F, 0.0F); + renderblocks.renderFaceYNeg(block, 0.0D, 0.0D, 0.0D, block.getIcon(0, 0)); + tessellator.setNormal(0.0F, 1.0F, 0.0F); + renderblocks.renderFaceYPos(block, 0.0D, 0.0D, 0.0D, block.getIcon(0, 0)); + tessellator.setNormal(0.0F, 0.0F, -1.0F); + renderblocks.renderFaceZNeg(block, 0.0D, 0.0D, 0.0D, block.getIcon(0, 0)); + tessellator.setNormal(0.0F, 0.0F, 1.0F); + renderblocks.renderFaceZPos(block, 0.0D, 0.0D, 0.0D, block.getIcon(0, 0)); + tessellator.setNormal(-1.0F, 0.0F, 0.0F); + renderblocks.renderFaceXNeg(block, 0.0D, 0.0D, 0.0D, block.getIcon(0, 0)); + tessellator.setNormal(1.0F, 0.0F, 0.0F); + renderblocks.renderFaceXPos(block, 0.0D, 0.0D, 0.0D, block.getIcon(0, 0)); + } + tessellator.draw(); + GL11.glTranslatef(0.5F, 0.5F, 0.5F); + renderblocks.clearOverrideBlockTexture(); + } + + @Override + public boolean renderWorldBlock(IBlockAccess blockAccess, int x, int y, int z, Block block, int meta, RenderBlocks renderblocks) + { + Tessellator var5 = Tessellator.instance; + var5.setBrightness(block.getMixedBrightnessForBlock(blockAccess, x, y, z)); + int var6 = block.colorMultiplier(blockAccess, x, y, z); + float var7 = (var6 >> 16 & 255) / 255.0F; + float var8 = (var6 >> 8 & 255) / 255.0F; + float var9 = (var6 & 255) / 255.0F; + var5.setColorOpaque_F(var7, var8, var9); + for(int i=0;i<=5;i++) + { + this.setBounds(i, renderblocks, block); + renderblocks.renderStandardBlock(block, x, y, z); + } + return true; + } + + private void setBounds(int index, RenderBlocks renderblocks, Block block) + { + double rt = 1/11d; + switch(index) + { + case 0: + renderblocks.setRenderBounds(0d, 10*rt, 0d, 1d, 1d, 1d); + break; + case 1: + renderblocks.setRenderBounds(rt*2, 4*rt, rt*2, 9*rt, 5*rt, 9*rt); + break; + case 2: + renderblocks.setRenderBounds(rt, 0d, rt, rt*3, rt*10, rt*3); + break; + case 3: + renderblocks.setRenderBounds(rt*8, 0d, rt, rt*10, rt*10, rt*3); + break; + case 4: + renderblocks.setRenderBounds(rt, 0d, rt*8, rt*3, rt*10, rt*10); + break; + case 5: + renderblocks.setRenderBounds(rt*8, 0d, rt*8, rt*10, rt*10, rt*10); + break; + } + } + + @Override + public boolean shouldRender3DInInventory(int arg0) + { + return true; + } +} diff --git a/src/main/java/ihl/model/ModelKnee.java b/src/main/java/ihl/model/ModelKnee.java new file mode 100644 index 0000000..3f720ac --- /dev/null +++ b/src/main/java/ihl/model/ModelKnee.java @@ -0,0 +1,228 @@ +package ihl.model; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.model.PositionTextureVertex; +import net.minecraft.client.model.TexturedQuad; +import net.minecraft.client.renderer.Tessellator; +import net.minecraftforge.common.util.ForgeDirection; + +@SideOnly(value=Side.CLIENT) +public class ModelKnee { + /** + * The (x,y,z) vertex positions and (u,v) texture coordinates for each of the 8 points on a cube + */ + private PositionTextureVertex[] vertexPositions; + + /** An array of 6 TexturedQuads, one for each face of a cube */ + private TexturedQuad[] quadList; + + /** X vertex coordinate of lower box corner */ + public final float posX1; + + /** Y vertex coordinate of lower box corner */ + public final float posY1; + + /** Z vertex coordinate of lower box corner */ + public final float posZ1; + + /** X vertex coordinate of upper box corner */ + public final float posX2; + + /** Y vertex coordinate of upper box corner */ + public final float posY2; + + /** Z vertex coordinate of upper box corner */ + public final float posZ2; + public String field_78247_g; + private ForgeDirection direction1; + private ForgeDirection direction2; + + public ModelKnee(IHLModelRenderer par1ModelRenderer, int par2, int par3, float x1, float y1, float z1, int par7, int par8, int par9, float par10, float radius1, float radius2, ForgeDirection direction1_1) + { + this(par1ModelRenderer, par2, par3, x1, y1, z1, par7, par8, par9, par10, radius1, radius2, direction1_1, direction1_1); + } + + + public ModelKnee(IHLModelRenderer par1ModelRenderer, int par2, int par3, float x1, float y1, float z1, int par7, int par8, int par9, float par10, float radius1, float radius2, ForgeDirection direction1_1, ForgeDirection direction2_1) + { + this.direction1=direction1_1; + this.direction2=direction2_1; + this.posX1 = x1; + this.posY1 = y1; + this.posZ1 = z1; + this.posX2 = x1 + par7; + this.posY2 = y1 + par8; + this.posZ2 = z1 + par9; + this.vertexPositions = new PositionTextureVertex[32]; + this.quadList = new TexturedQuad[32]; + float x2 = x1 + par7; + float y2 = y1 + par8; + float z2 = z1 + par9; + x1 -= par10; + y1 -= par10; + z1 -= par10; + x2 += par10; + y2 += par10; + z2 += par10; + + if (par1ModelRenderer.mirror) + { + float var14 = x2; + x2 = x1; + x1 = var14; + } + float dx = x2-x1 ; + float dy = y2-y1; + float dz = z2-z1; + PositionTextureVertex[] outervertexes1 = new PositionTextureVertex[8]; + PositionTextureVertex[] innervertexes1 = new PositionTextureVertex[8]; + PositionTextureVertex[] outervertexes2 = new PositionTextureVertex[8]; + PositionTextureVertex[] innervertexes2 = new PositionTextureVertex[8]; + int i=0; + for(i=0;i<8;i++) + { + switch(direction1) + { + case UP: + outervertexes1[i] = new PositionTextureVertex(x1+dx*0.5F+dx*0.25F*(float)Math.cos(2D*Math.PI/8D*i), y1, z1+dz*0.5F+dz*0.25F*(float)Math.sin(2D*Math.PI/8D*i), par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + innervertexes1[i] = new PositionTextureVertex(x1+dx*0.5F+dx*radius1*0.25F*(float)Math.cos(2D*Math.PI/8D*i), y1, z1+dz*0.5F+dz*0.25F*radius1*(float)Math.sin(2D*Math.PI/8D*i), par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + break; + case DOWN: + outervertexes1[i] = new PositionTextureVertex(x1+dx*0.5F+dx*0.25F*radius2*(float)Math.cos(2D*Math.PI/8D*i), y2, z1+dz*0.5F-dz*0.25F*radius2*(float)Math.sin(2D*Math.PI/8D*i), par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + innervertexes1[i] = new PositionTextureVertex(x1+dx*0.5F+dx*radius1*radius2*0.25F*(float)Math.cos(2D*Math.PI/8D*i), y2, z1+dz*0.5F-dz*0.25F*radius1*radius2*(float)Math.sin(2D*Math.PI/8D*i), par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + break; + case SOUTH: + outervertexes1[i] = new PositionTextureVertex(x1+dx*0.5F+dx*0.25F*(float)Math.cos(2D*Math.PI/8D*i), y1+dy*0.5F+dy*0.25F*(float)Math.sin(2D*Math.PI/8D*i), z2, par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + innervertexes1[i] = new PositionTextureVertex(x1+dx*0.5F+dx*radius1*0.25F*(float)Math.cos(2D*Math.PI/8D*i), y1+dy*0.5F+dy*0.25F*radius1*(float)Math.sin(2D*Math.PI/8D*i), z2, par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + break; + case NORTH: + outervertexes1[i] = new PositionTextureVertex(x1+dx*0.5F+dx*0.25F*radius2*(float)Math.cos(2D*Math.PI/8D*i), y1+dy*0.5F+dy*0.25F*radius2*(float)Math.sin(2D*Math.PI/8D*i), z2, par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + innervertexes1[i] = new PositionTextureVertex(x1+dx*0.5F+dx*radius1*radius2*0.25F*(float)Math.cos(2D*Math.PI/8D*i), y1+dy*0.5F+dy*0.25F*radius1*radius2*(float)Math.sin(2D*Math.PI/8D*i), z2, par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + break; + case EAST: + outervertexes1[i] = new PositionTextureVertex(x1, y1+dy*0.5F+dy*0.25F*(float)Math.sin(2D*Math.PI/8D*i), z1+dz*0.5F+dz*0.25F*(float)Math.cos(2D*Math.PI/8D*i), par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + innervertexes1[i] = new PositionTextureVertex(x1, y1+dy*0.5F+dy*0.25F*radius1*(float)Math.sin(2D*Math.PI/8D*i), z1+dz*0.5F+dz*radius1*0.25F*(float)Math.cos(2D*Math.PI/8D*i), par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + break; + case WEST: + outervertexes1[i] = new PositionTextureVertex(x1, y1+dy*0.5F+dy*0.25F*radius2*(float)Math.sin(2D*Math.PI/8D*i), z1+dz*0.5F+dz*0.52F*radius2*(float)Math.cos(2D*Math.PI/8D*i), par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + innervertexes1[i] = new PositionTextureVertex(x1, y1+dy*0.5F+dy*0.25F*radius2*radius1*(float)Math.sin(2D*Math.PI/8D*i), z1+dz*0.5F+dz*radius1*0.25F*radius2*(float)Math.cos(2D*Math.PI/8D*i), par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + break; + default: + outervertexes1[i] = new PositionTextureVertex(x1, y1+dy*0.5F+dy*0.25F*radius2*(float)Math.sin(2D*Math.PI/8D*i), z1+dz*0.5F+dz*0.52F*radius2*(float)Math.cos(2D*Math.PI/8D*i), par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + innervertexes1[i] = new PositionTextureVertex(x1, y1+dy*0.5F+dy*0.25F*radius2*radius1*(float)Math.sin(2D*Math.PI/8D*i), z1+dz*0.5F+dz*radius1*0.25F*radius2*(float)Math.cos(2D*Math.PI/8D*i), par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + break; + } + + switch(direction2) + { + case UP: + outervertexes2[i] = new PositionTextureVertex(x1+dx*0.5F+dx*0.5F*radius2*(float)Math.cos(2D*Math.PI/8D*i), y2, z1+dz*0.5F+dz*0.5F*radius2*(float)Math.sin(2D*Math.PI/8D*i), par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + innervertexes2[i] = new PositionTextureVertex(x1+dx*0.5F+dx*radius1*radius2*0.5F*(float)Math.cos(2D*Math.PI/8D*i), y2, z1+dz*0.5F+dz*0.5F*radius2*radius1*(float)Math.sin(2D*Math.PI/8D*i), par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + break; + case DOWN: + outervertexes2[i] = new PositionTextureVertex(x1+dx*0.5F+dx*0.5F*(float)Math.cos(2D*Math.PI/8D*i), y2, z1+dz*0.5F+dz*0.5F*(float)Math.sin(2D*Math.PI/8D*i), par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + innervertexes2[i] = new PositionTextureVertex(x1+dx*0.5F+dx*radius1*0.5F*(float)Math.cos(2D*Math.PI/8D*i), y2, z1+dz*0.5F+dz*0.5F*radius1*(float)Math.sin(2D*Math.PI/8D*i), par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + break; + case WEST: + outervertexes2[i] = new PositionTextureVertex(x2, y1+dy*0.5F+dy*0.25F*(float)Math.cos(2D*Math.PI/8D*i), z1+dz*0.5F-dz*0.25F*(float)Math.sin(2D*Math.PI/8D*i), par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + innervertexes2[i] = new PositionTextureVertex(x2, y1+dy*0.5F+dy*radius1*0.25F*(float)Math.cos(2D*Math.PI/8D*i), z1+dz*0.5F-dz*0.25F*radius1*(float)Math.sin(2D*Math.PI/8D*i), par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + break; + case EAST: + outervertexes2[i] = new PositionTextureVertex(x1, y1+dy*0.5F+dy*0.25F*(float)Math.cos(2D*Math.PI/8D*i), z1+dz*0.5F+dz*0.25F*(float)Math.sin(2D*Math.PI/8D*i), par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + innervertexes2[i] = new PositionTextureVertex(x1, y1+dy*0.5F+dy*radius1*0.25F*(float)Math.cos(2D*Math.PI/8D*i), z1+dz*0.5F+dz*0.25F*radius1*(float)Math.sin(2D*Math.PI/8D*i), par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + break; + case NORTH: + outervertexes2[i] = new PositionTextureVertex(x1+dx*0.5F+dx*0.25F*(float)Math.cos(2D*Math.PI/8D*i), y1+z2-dz*0.5F-dz*0.25F*(float)Math.sin(2D*Math.PI/8D*i), z2, par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + innervertexes2[i] = new PositionTextureVertex(x1+dx*0.5F+dx*radius1*0.25F*(float)Math.cos(2D*Math.PI/8D*i), y1+z2-dz*0.5F-dz*0.25F*radius1*(float)Math.sin(2D*Math.PI/8D*i), z2, par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + break; + case SOUTH: + outervertexes2[i] = new PositionTextureVertex(x1+dx*0.5F+dx*0.25F*(float)Math.cos(2D*Math.PI/8D*i), y1+dy*0.5F+dy*0.25F*(float)Math.sin(2D*Math.PI/8D*i), z1, par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + innervertexes2[i] = new PositionTextureVertex(x1+dx*0.5F+dx*radius1*0.25F*(float)Math.cos(2D*Math.PI/8D*i), y1+dy*0.5F+dy*0.25F*radius1*(float)Math.sin(2D*Math.PI/8D*i), z1, par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + break; + default: + outervertexes2[i] = new PositionTextureVertex(x1+dx*0.5F+dx*0.5F*radius2*(float)Math.cos(2D*Math.PI/8D*i), y2, z1+dz*0.5F+dz*0.5F*radius2*(float)Math.sin(2D*Math.PI/8D*i), par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + innervertexes2[i] = new PositionTextureVertex(x1+dx*0.5F+dx*radius1*radius2*0.5F*(float)Math.cos(2D*Math.PI/8D*i), y2, z1+dz*0.5F+dz*0.5F*radius2*radius1*(float)Math.sin(2D*Math.PI/8D*i), par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + break; + } + } + for(i=0;i<32;i++) + { + if(i<8) + { + this.vertexPositions[i]=outervertexes1[i]; + } + else if(i<16) + { + this.vertexPositions[i]=innervertexes1[i-8]; + } + else if(i<24) + { + this.vertexPositions[i]=outervertexes2[i-16]; + } + else + { + this.vertexPositions[i]=innervertexes2[i-24]; + } + } + for(i=0;i<32;i++) + { + if(i<7) + { + this.quadList[i]=new TexturedQuad(new PositionTextureVertex[] {outervertexes1[i],outervertexes1[i+1],innervertexes1[i+1],innervertexes1[i]},par2 + par9 + par7, par3 + par9, par2 + par9 + par7 + par9, par3 + par9 + par8, par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + } + else if(i==7) + { + this.quadList[i]=new TexturedQuad(new PositionTextureVertex[] {outervertexes1[i],outervertexes1[0],innervertexes1[0],innervertexes1[i]},par2 + par9 + par7, par3 + par9, par2 + par9 + par7 + par9, par3 + par9 + par8, par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + } + else if(i<15) + { + this.quadList[i]=new TexturedQuad(new PositionTextureVertex[] {innervertexes2[i-8],innervertexes2[i+1-8],outervertexes2[i+1-8],outervertexes2[i-8]},par2, par3 + par9, par2 + par9, par3 + par9 + par8, par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + } + else if(i==15) + { + this.quadList[i]=new TexturedQuad(new PositionTextureVertex[] {innervertexes2[i-8],innervertexes2[0],outervertexes2[0],outervertexes2[i-8]},par2, par3 + par9, par2 + par9, par3 + par9 + par8, par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + } + else if(i<23) + { + this.quadList[i]=new TexturedQuad(new PositionTextureVertex[] {outervertexes1[i-16],outervertexes2[i-16],outervertexes2[i-16+1],outervertexes1[i-16+1]},par2 + par9, par3, par2 + par9 + par7, par3 + par9, par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + } + else if(i==23) + { + this.quadList[i]=new TexturedQuad(new PositionTextureVertex[] {outervertexes1[i-16],outervertexes2[i-16],outervertexes2[0],outervertexes1[0]},par2 + par9, par3, par2 + par9 + par7, par3 + par9, par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + } + else if(i<31) + { + this.quadList[i]=new TexturedQuad(new PositionTextureVertex[] {innervertexes1[i-24+1],innervertexes2[i-24+1], innervertexes2[i-24], innervertexes1[i-24]},par2 + par9, par3, par2 + par9 + par7, par3 + par9, par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + } + else if(i==31) + { + this.quadList[i]=new TexturedQuad(new PositionTextureVertex[] {innervertexes1[0],innervertexes2[0],innervertexes2[i-24],innervertexes1[i-24]},par2 + par9, par3, par2 + par9 + par7, par3 + par9, par1ModelRenderer.textureWidth, par1ModelRenderer.textureHeight); + } + } + if (par1ModelRenderer.mirror) + { + for (int var22 = 0; var22 < this.quadList.length; ++var22) + { + this.quadList[var22].flipFace(); + } + } + } + + /** + * Draw the six sided box defined by this ModelBox + */ + public void render(Tessellator par1Tessellator, float par2) + { + for(int i=0;i> 16 & 255) / 255.0F; + float var8 = (var6 >> 8 & 255) / 255.0F; + float var9 = (var6 & 255) / 255.0F; + var5.setColorOpaque_F(var7, var8, var9); + for(int i=0;i<=43;i++) + { + this.setBounds(i, renderblocks, block); + renderblocks.renderStandardBlock(block, x, y, z); + } + + this.setBounds(44, renderblocks, block); + renderblocks.renderFaceXNeg(block, x, y, z, block.getIcon(0, 0)); + renderblocks.renderFaceXPos(block, x, y, z, block.getIcon(0, 0)); + renderblocks.renderFaceZNeg(block, x, y, z, block.getIcon(0, 0)); + renderblocks.renderFaceZPos(block, x, y, z, block.getIcon(0, 0)); + renderblocks.renderFaceYNeg(block, x, y, z, block.getIcon(5, 0)); + + this.setBounds(45, renderblocks, block); + renderblocks.renderFaceXNeg(block, x, y, z, block.getIcon(5, 0)); + renderblocks.renderFaceXPos(block, x, y, z, block.getIcon(5, 0)); + renderblocks.renderFaceZNeg(block, x, y, z, block.getIcon(0, 0)); + renderblocks.renderFaceZPos(block, x, y, z, block.getIcon(0, 0)); + renderblocks.renderFaceYNeg(block, x, y, z, block.getIcon(0, 0)); + renderblocks.renderFaceYPos(block, x, y, z, block.getIcon(0, 0)); + + this.setBounds(46, renderblocks, block); + renderblocks.renderFaceXNeg(block, x, y, z, block.getIcon(0, 0)); + renderblocks.renderFaceXPos(block, x, y, z, block.getIcon(0, 0)); + renderblocks.renderFaceZNeg(block, x, y, z, block.getIcon(5, 0)); + renderblocks.renderFaceZPos(block, x, y, z, block.getIcon(5, 0)); + renderblocks.renderFaceYNeg(block, x, y, z, block.getIcon(0, 0)); + renderblocks.renderFaceYPos(block, x, y, z, block.getIcon(0, 0)); + + this.setBounds(47, renderblocks, block); + renderblocks.renderFaceXNeg(block, x, y, z, block.getIcon(0, 0)); + renderblocks.renderFaceXPos(block, x, y, z, block.getIcon(0, 0)); + renderblocks.renderFaceZNeg(block, x, y, z, block.getIcon(0, 0)); + renderblocks.renderFaceZPos(block, x, y, z, block.getIcon(0, 0)); + renderblocks.renderFaceYNeg(block, x, y, z, block.getIcon(0, 0)); + renderblocks.renderFaceYPos(block, x, y, z, block.getIcon(4, 0)); + + IHLRenderUtils.instance.setPosition(x, y, z); + IHLRenderUtils.instance.setRotationPoint(0F, 16F, 0F); + IHLRenderUtils.instance.setRotation(0F, 0f, 0F); + + IIcon icon = block.getIcon(1, 0); + + TileEntity tile = blockAccess.getTileEntity(x, y, z); + if(tile!=null && tile.getWorldObj() != null) + { + switch (((IWrenchable)tile).getFacing()) + { + case 2: + IHLRenderUtils.instance.drawPipe(-6F, -14F, -2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(-6F, -12F, -2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(-6F, -10F, -2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + + IHLRenderUtils.instance.drawPipe(2F, -14F, -2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(2F, -12F, -2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(2F, -10F, -2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + + icon = block.getIcon(2, 0); + IHLRenderUtils.instance.drawPipe(-4.5F, -16F, -0.5F, 1, 2, 1, 0f, 1f, ForgeDirection.UP,icon); + icon = block.getIcon(3, 0); + IHLRenderUtils.instance.drawPipe(3.5F, -16F, -0.5F, 1, 2, 1, 0f, 1f, ForgeDirection.UP,icon); + break; + case 5: + IHLRenderUtils.instance.drawPipe(-2F, -14F, -6F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(-2F, -12F, -6F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(-2F, -10F, -6F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + + IHLRenderUtils.instance.drawPipe(-2F, -14F, 2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(-2F, -12F, 2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(-2F, -10F, 2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + + icon = block.getIcon(2, 0); + IHLRenderUtils.instance.drawPipe(-0.5F, -16F, -4.5F, 1, 2, 1, 0f, 1f, ForgeDirection.UP,icon); + icon = block.getIcon(3, 0); + IHLRenderUtils.instance.drawPipe(-0.5F, -16F, 3.5F, 1, 2, 1, 0f, 1f, ForgeDirection.UP,icon); + break; + case 3: + IHLRenderUtils.instance.drawPipe(-6F, -14F, -2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(-6F, -12F, -2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(-6F, -10F, -2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + + IHLRenderUtils.instance.drawPipe(2F, -14F, -2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(2F, -12F, -2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(2F, -10F, -2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + + icon = block.getIcon(3, 0); + IHLRenderUtils.instance.drawPipe(-4.5F, -16F, -0.5F, 1, 2, 1, 0f, 1f, ForgeDirection.UP,icon); + icon = block.getIcon(2, 0); + IHLRenderUtils.instance.drawPipe(3.5F, -16F, -0.5F, 1, 2, 1, 0f, 1f, ForgeDirection.UP,icon); + break; + case 4: + IHLRenderUtils.instance.drawPipe(-2F, -14F, -6F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(-2F, -12F, -6F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(-2F, -10F, -6F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + + IHLRenderUtils.instance.drawPipe(-2F, -14F, 2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(-2F, -12F, 2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(-2F, -10F, 2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + + icon = block.getIcon(3, 0); + IHLRenderUtils.instance.drawPipe(-0.5F, -16F, -4.5F, 1, 2, 1, 0f, 1f, ForgeDirection.UP,icon); + icon = block.getIcon(2, 0); + IHLRenderUtils.instance.drawPipe(-0.5F, -16F, 3.5F, 1, 2, 1, 0f, 1f, ForgeDirection.UP,icon); + break; + default: + IHLRenderUtils.instance.drawPipe(-6F, -14F, -2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(-6F, -12F, -2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(-6F, -10F, -2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + + IHLRenderUtils.instance.drawPipe(2F, -14F, -2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(2F, -12F, -2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(2F, -10F, -2F, 4, 2, 4, 0f, 0.5f,ForgeDirection.UP,icon); + + icon = block.getIcon(2, 0); + IHLRenderUtils.instance.drawPipe(-4.5F, -16F, -0.5F, 1, 2, 1, 0f, 1f, ForgeDirection.UP,icon); + icon = block.getIcon(3, 0); + IHLRenderUtils.instance.drawPipe(3.5F, -16F, -0.5F, 1, 2, 1, 0f, 1f, ForgeDirection.UP,icon); + break; + } + } + return true; + } + + private void setBounds(int index, RenderBlocks renderblocks, Block block) + { + double rt = 1/11d; + switch(index) + { + case 0: + renderblocks.setRenderBounds(rt, 0d, 0d, rt*2, 1d, rt); + break; + case 1: + renderblocks.setRenderBounds(rt*3, rt*8, 0d, rt*4, 1d, rt); + break; + case 2: + renderblocks.setRenderBounds(rt*5, rt*8, 0d, rt*6, 1d, rt); + break; + case 3: + renderblocks.setRenderBounds(rt*7, rt*8, 0d, rt*8, 1d, rt); + break; + case 4: + renderblocks.setRenderBounds(rt*3, 0d, 0d, rt*4, rt*3, rt); + break; + case 5: + renderblocks.setRenderBounds(rt*5, 0d, 0d, rt*6, rt*3, rt); + break; + case 6: + renderblocks.setRenderBounds(rt*7, 0d, 0d, rt*8, rt*3, rt); + break; + case 7: + renderblocks.setRenderBounds(rt*9, 0d, 0d, rt*10, 1d, rt); + break; + + case 8: + renderblocks.setRenderBounds(rt, 0d, rt*10, rt*2, 1d, 1d); + break; + case 9: + renderblocks.setRenderBounds(rt*3, rt*8, rt*10, rt*4, 1d, 1d); + break; + case 10: + renderblocks.setRenderBounds(rt*5, rt*8, rt*10, rt*6, 1d, 1d); + break; + case 11: + renderblocks.setRenderBounds(rt*7, rt*8, rt*10, rt*8, 1d, 1d); + break; + case 12: + renderblocks.setRenderBounds(rt*3, 0d, rt*10, rt*4, rt*3, 1d); + break; + case 13: + renderblocks.setRenderBounds(rt*5, 0d, rt*10, rt*6, rt*3, 1d); + break; + case 14: + renderblocks.setRenderBounds(rt*7, 0d, rt*10, rt*8, rt*3, 1d); + break; + case 15: + renderblocks.setRenderBounds(rt*9, 0d, rt*10, rt*10, 1d, 1d); + break; + + case 16: + renderblocks.setRenderBounds(0d, 0d, rt, rt, 1d, rt*2); + break; + case 17: + renderblocks.setRenderBounds(0d,rt*8, rt*3,rt,1d, rt*4); + break; + case 18: + renderblocks.setRenderBounds(0d,rt*8, rt*5,rt, 1d, rt*6); + break; + case 19: + renderblocks.setRenderBounds(0d,rt*8, rt*7,rt,1d, rt*8); + break; + case 20: + renderblocks.setRenderBounds(0d,0d, rt*3, rt, rt*3,rt*4); + break; + case 21: + renderblocks.setRenderBounds(0d,0d, rt*5,rt, rt*3, rt*6); + break; + case 22: + renderblocks.setRenderBounds(0d,0d, rt*7, rt,rt*3, rt*8); + break; + case 23: + renderblocks.setRenderBounds(0d,0d, rt*9,rt,1d, rt*10); + break; + + case 24: + renderblocks.setRenderBounds(rt*10, 0d, rt, 1d, 1d, rt*2); + break; + case 25: + renderblocks.setRenderBounds(rt*10, rt*8, rt*3, 1d, 1d, rt*4); + break; + case 26: + renderblocks.setRenderBounds(rt*10, rt*8, rt*5,1d, 1d, rt*6); + break; + case 27: + renderblocks.setRenderBounds(rt*10, rt*8, rt*7, 1d, 1d, rt*8); + break; + case 28: + renderblocks.setRenderBounds(rt*10, 0d, rt*3, 1d, rt*3, rt*4); + break; + case 29: + renderblocks.setRenderBounds(rt*10, 0d, rt*5,1d, rt*3, rt*6); + break; + case 30: + renderblocks.setRenderBounds(rt*10, 0d, rt*7,1d, rt*3, rt*8); + break; + case 31: + renderblocks.setRenderBounds(rt*10, 0d, rt*9, 1d, 1d, rt*10); + break; + + case 32: + renderblocks.setRenderBounds(rt, 0d, rt*3, rt*3, rt, rt*4); + break; + case 33: + renderblocks.setRenderBounds(rt, 0d, rt*5, rt*3, rt, rt*6); + break; + case 34: + renderblocks.setRenderBounds(rt, 0d, rt*7, rt*3, rt, rt*8); + break; + case 35: + renderblocks.setRenderBounds(rt*8, 0d, rt*3, rt*10, rt, rt*4); + break; + case 36: + renderblocks.setRenderBounds(rt*8, 0d, rt*5, rt*10, rt, rt*6); + break; + case 37: + renderblocks.setRenderBounds(rt*8, 0d, rt*7, rt*10, rt, rt*8); + break; + + case 38: + renderblocks.setRenderBounds(rt*3, 0d, rt, rt*4, rt, rt*3); + break; + case 39: + renderblocks.setRenderBounds(rt*5, 0d, rt, rt*6, rt, rt*3); + break; + case 40: + renderblocks.setRenderBounds(rt*7, 0d, rt, rt*8, rt, rt*3); + break; + case 41: + renderblocks.setRenderBounds(rt*3, 0d, rt*8, rt*4, rt, rt*10); + break; + case 42: + renderblocks.setRenderBounds(rt*5, 0d, rt*8, rt*6, rt, rt*10); + break; + case 43: + renderblocks.setRenderBounds(rt*7, 0d, rt*8, rt*8, rt, rt*10); + break; + + case 44: + renderblocks.setRenderBounds(rt*3, 0d, rt*3, rt*8, rt, rt*8); + break; + + case 45: + renderblocks.setRenderBounds(0d, rt*3, rt*3, 1d, rt*8, rt*8); + break; + + case 46: + renderblocks.setRenderBounds(rt*3, rt*3, 0d, rt*8, rt*8, 1d); + break; + + case 47: + renderblocks.setRenderBounds(rt, rt, rt, rt*10, 1d, rt*10); + break; + + } + } + + @Override + public boolean shouldRender3DInInventory(int arg0) + { + return true; + } +} diff --git a/src/main/java/ihl/model/RectifierTransformerUnitSelectionBoxSpecialRenderer.java b/src/main/java/ihl/model/RectifierTransformerUnitSelectionBoxSpecialRenderer.java new file mode 100644 index 0000000..4ce866b --- /dev/null +++ b/src/main/java/ihl/model/RectifierTransformerUnitSelectionBoxSpecialRenderer.java @@ -0,0 +1,51 @@ +package ihl.model; + +import org.lwjgl.opengl.GL11; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import ihl.flexible_cable.RectifierTransformerUnitTileEntity; +import ihl.interfaces.ISelectionBoxSpecialRenderer; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.OpenGlHelper; +import net.minecraft.client.renderer.RenderGlobal; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.util.MovingObjectPosition; + +@SideOnly(value=Side.CLIENT) +public class RectifierTransformerUnitSelectionBoxSpecialRenderer implements ISelectionBoxSpecialRenderer +{ + @Override + public void drawSelectionBox(EntityPlayer player, ItemStack currentItem, MovingObjectPosition movingObjectPosition, float partialTick) + { + double offsetX = player.lastTickPosX + (player.posX - player.lastTickPosX) * partialTick; + double offsetY = player.lastTickPosY + (player.posY - player.lastTickPosY) * partialTick; + double offsetZ = player.lastTickPosZ + (player.posZ - player.lastTickPosZ) * partialTick; + RectifierTransformerUnitTileEntity tile = (RectifierTransformerUnitTileEntity) Minecraft.getMinecraft().theWorld.getTileEntity(movingObjectPosition.blockX, movingObjectPosition.blockY, movingObjectPosition.blockZ); + if(tile!=null && tile.getWorldObj() != null) + { + GL11.glEnable(GL11.GL_BLEND); + OpenGlHelper.glBlendFunc(770, 771, 1, 0); + GL11.glLineWidth(2.0F); + GL11.glDisable(GL11.GL_TEXTURE_2D); + GL11.glDepthMask(false); + short side = tile.getSide(player); + if(side==0) + { + GL11.glColor4f(0.0F, 1.0F, 0.0F, 0.8F); + RenderGlobal.drawOutlinedBoundingBox(tile.aabb1.getOffsetBoundingBox(-offsetX, -offsetY, -offsetZ), -1); + RenderGlobal.drawOutlinedBoundingBox(tile.aabb1_1.getOffsetBoundingBox(-offsetX, -offsetY, -offsetZ), -1); + } + else if(side==1) + { + GL11.glColor4f(1.0F, 0.0F, 0.0F, 0.8F); + RenderGlobal.drawOutlinedBoundingBox(tile.aabb2.getOffsetBoundingBox(-offsetX, -offsetY, -offsetZ), -1); + RenderGlobal.drawOutlinedBoundingBox(tile.aabb2_1.getOffsetBoundingBox(-offsetX, -offsetY, -offsetZ), -1); + } + GL11.glEnable(GL11.GL_TEXTURE_2D); + GL11.glDepthMask(true); + GL11.glDisable(GL11.GL_BLEND); + } + } +} diff --git a/src/main/java/ihl/model/RefluxCondenserBlockRender.java b/src/main/java/ihl/model/RefluxCondenserBlockRender.java new file mode 100644 index 0000000..c9021b9 --- /dev/null +++ b/src/main/java/ihl/model/RefluxCondenserBlockRender.java @@ -0,0 +1,125 @@ +package ihl.model; + +import org.lwjgl.opengl.GL11; + +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; +import ic2.api.tile.IWrenchable; +import ihl.utils.IHLRenderUtils; +import net.minecraft.block.Block; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.IIcon; +import net.minecraft.world.IBlockAccess; +import net.minecraftforge.common.util.ForgeDirection; + +@SideOnly(value=Side.CLIENT) +public class RefluxCondenserBlockRender implements ISimpleBlockRenderingHandler +{ + public static int renderId; + + public RefluxCondenserBlockRender() + { + renderId = RenderingRegistry.getNextAvailableRenderId(); + } + + @Override + public void renderInventoryBlock(Block block, int metadata, int modelID, RenderBlocks renderblocks) + { + Tessellator tessellator = Tessellator.instance; + IHLRenderUtils.instance.reset(); + GL11.glTranslatef(-0.5F, -0.5F, -0.5F); + tessellator.startDrawingQuads(); + IIcon icon = block.getIcon(0, 0); + IHLRenderUtils.instance.setPosition(0, 0, 0); + IHLRenderUtils.instance.setRotationPoint(0F, 16F, 0F); + IHLRenderUtils.instance.setRotation(0F, 0f, 0F); + IHLRenderUtils.instance.drawPipe(-2F, 7F, -2F, 4, 1, 4, 0.6f, 1f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawKnee(-8F, 2F, -3F, 5, 6, 6, .8F, 1F, ForgeDirection.UP, ForgeDirection.EAST,icon); + IHLRenderUtils.instance.drawPipe(3.5F, -7F, -1.5F, 4, 3, 3, 0.8f, 1f,ForgeDirection.WEST,icon); + IHLRenderUtils.instance.drawPipe(7F, -7.5F, -2F, 1, 4, 4, 0.6f, 1f,ForgeDirection.WEST,icon); + IHLRenderUtils.instance.drawPipe(7F, 3F, -2F, 1, 4, 4, 0.6f, 1f,ForgeDirection.WEST,icon); + IHLRenderUtils.instance.drawPipe(-3F, 3.5F, -1.5F, 10, 3, 3, .8F, 1F, ForgeDirection.WEST,icon); + IHLRenderUtils.instance.drawPipe(-2F, -8F, -2F, 4, 1, 4, 0.6f, 1f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(-1.5F, -7F, -1.5F, 3, 2, 3, 0.8f, 1f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(-1.5F, 5F, -1.5F, 3, 2, 3, 0.8f, 1f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(-2F, -2F, -8F, 4, 4, 1, 0.6f, 1f,ForgeDirection.NORTH,icon); + IHLRenderUtils.instance.drawPipe(-1.5F, -1.5F, -7F, 3, 3, 7, 0.8f, 1f,ForgeDirection.NORTH,icon); + IHLRenderUtils.instance.setRotationPoint(3F, 16F, 0F); + IHLRenderUtils.instance.setRotation(0F, 0f, -0.5F); + IHLRenderUtils.instance.drawPipe(1F, -4F, -4F, 2, 8, 8, 0f, 0.8f,ForgeDirection.WEST,icon); + IHLRenderUtils.instance.drawPipe(-9F, -4F, -4F, 10, 8, 8, 0.8f, 1f,ForgeDirection.WEST,icon); + IHLRenderUtils.instance.drawPipe(-11F, -4F, -4F, 2, 8, 8, 0f, 0.8f,ForgeDirection.EAST,icon); + tessellator.draw(); + GL11.glTranslatef(0.5F, 0.5F, 0.5F); + } + + @Override + public boolean renderWorldBlock(IBlockAccess blockAccess, int x, int y, int z, Block block, int meta, RenderBlocks blockRenderer) + { + IHLRenderUtils.instance.reset(); + TileEntity tile = blockAccess.getTileEntity(x, y, z); + if(tile.getWorldObj() != null) + { + switch (((IWrenchable)tile).getFacing()) + { + case 5: + IHLRenderUtils.instance.renderFromInside=true; + IHLRenderUtils.instance.swapXandZ=true; + IHLRenderUtils.instance.swapRenderBoundsZ=true; + break; + case 3: + IHLRenderUtils.instance.swapRenderBoundsX=true; + IHLRenderUtils.instance.swapRenderBoundsZ=true; + break; + case 4: + IHLRenderUtils.instance.renderFromInside=true; + IHLRenderUtils.instance.swapXandZ=true; + IHLRenderUtils.instance.swapRenderBoundsX=true; + break; + default: + } + } + Tessellator.instance.setBrightness(block.getMixedBrightnessForBlock(blockAccess, x, y, z)); + int colorMultiplier = block.colorMultiplier(blockAccess, x, y, z); + float red = (colorMultiplier >> 16 & 255) / 255.0F; + float green = (colorMultiplier >> 8 & 255) / 255.0F; + float blue = (colorMultiplier & 255) / 255.0F; + Tessellator.instance.setColorOpaque_F(red, green, blue); + IIcon icon = block.getBlockTextureFromSide(0); + IHLRenderUtils.instance.setPosition(x, y, z); + IHLRenderUtils.instance.setRotationPoint(0F, 16F, 0F); + IHLRenderUtils.instance.setRotation(0F, 0f, 0F); + IHLRenderUtils.instance.drawPipe(-2F, 7F, -2F, 4, 1, 4, 0.6f, 1f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawKnee(-8F, 2F, -3F, 5, 6, 6, .8F, 1F, ForgeDirection.UP, ForgeDirection.EAST,icon); + IHLRenderUtils.instance.drawPipe(3.5F, -7F, -1.5F, 4, 3, 3, 0.8f, 1f,ForgeDirection.WEST,icon); + IHLRenderUtils.instance.drawPipe(7F, -7.5F, -2F, 1, 4, 4, 0.6f, 1f,ForgeDirection.WEST,icon); + IHLRenderUtils.instance.drawPipe(7F, 3F, -2F, 1, 4, 4, 0.6f, 1f,ForgeDirection.WEST,icon); + IHLRenderUtils.instance.drawPipe(-3F, 3.5F, -1.5F, 10, 3, 3, .8F, 1F, ForgeDirection.WEST,icon); + IHLRenderUtils.instance.drawPipe(-2F, -8F, -2F, 4, 1, 4, 0.6f, 1f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(-1.5F, -7F, -1.5F, 3, 2, 3, 0.8f, 1f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(-1.5F, 5F, -1.5F, 3, 2, 3, 0.8f, 1f,ForgeDirection.UP,icon); + IHLRenderUtils.instance.drawPipe(-2F, -2F, -8F, 4, 4, 1, 0.6f, 1f,ForgeDirection.NORTH,icon); + IHLRenderUtils.instance.drawPipe(-1.5F, -1.5F, -7F, 3, 3, 7, 0.8f, 1f,ForgeDirection.NORTH,icon); + IHLRenderUtils.instance.setRotationPoint(3F, 16F, 0F); + IHLRenderUtils.instance.setRotation(0F, 0f, -0.5F); + IHLRenderUtils.instance.drawPipe(1F, -4F, -4F, 2, 8, 8, 0f, 0.8f,ForgeDirection.WEST,icon); + IHLRenderUtils.instance.drawPipe(-9F, -4F, -4F, 10, 8, 8, 0.8f, 1f,ForgeDirection.WEST,icon); + IHLRenderUtils.instance.drawPipe(-11F, -4F, -4F, 2, 8, 8, 0f, 0.8f,ForgeDirection.EAST,icon); + return true; + } + + @Override + public boolean shouldRender3DInInventory(int arg0) + { + return true; + } + + @Override + public int getRenderId() { + return renderId; + } +} diff --git a/src/main/java/ihl/model/RenderInfo.java b/src/main/java/ihl/model/RenderInfo.java new file mode 100644 index 0000000..4e85f6f --- /dev/null +++ b/src/main/java/ihl/model/RenderInfo.java @@ -0,0 +1,71 @@ +package ihl.model; + +import java.util.Arrays; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.block.Block; +import net.minecraft.init.Blocks; +import net.minecraft.util.IIcon; + +@SideOnly(value=Side.CLIENT) +public class RenderInfo { + + public Block template = Blocks.stone; + public IIcon[] texture = null; + public IIcon override = null; + public float minX = 0; + public float minY = 0; + public float minZ = 0; + public float maxX = 1; + public float maxY = 1; + public float maxZ = 1; + public boolean[] renderSide = new boolean[6]; + public float light = -1f; + public int brightness = -1; + + public RenderInfo() { + setRenderAllSides(); + } + + public RenderInfo(Block template, IIcon[] texture) { + this(); + this.template = template; + this.texture = texture; + } + + public RenderInfo(float minX, float minY, float minZ, float maxX, float maxY, float maxZ) { + this(); + setBlockBounds(minX, minY, minZ, maxX, maxY, maxZ); + } + + public final void setBlockBounds(float minX, float minY, float minZ, float maxX, float maxY, float maxZ) { + this.minX = minX; + this.minY = minY; + this.minZ = minZ; + this.maxX = maxX; + this.maxY = maxY; + this.maxZ = maxZ; + } + + public final void setRenderSingleSide(int side) { + Arrays.fill(renderSide, false); + renderSide[side] = true; + } + + public final void setRenderAllSides() { + Arrays.fill(renderSide, true); + } + + public IIcon getBlockTextureFromSide(int i) { + if (override != null) + return override; + if (texture == null || texture.length == 0) + return template.getBlockTextureFromSide(i); + else { + if (i >= texture.length) + i = 0; + return texture[i]; + } + } +} diff --git a/src/main/java/ihl/model/UniversalTileRender.java b/src/main/java/ihl/model/UniversalTileRender.java new file mode 100644 index 0000000..d3cb4c6 --- /dev/null +++ b/src/main/java/ihl/model/UniversalTileRender.java @@ -0,0 +1,76 @@ +package ihl.model; +import org.lwjgl.opengl.GL11; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import ic2.api.tile.IWrenchable; +import ihl.IHLModInfo; +import ihl.flexible_cable.IronWorkbenchModel; +import net.minecraft.client.model.ModelBase; +import net.minecraft.client.model.ModelRenderer; +import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ResourceLocation; + +public class UniversalTileRender extends TileEntitySpecialRenderer{ +private ModelBase model = new IronWorkbenchModel(); +private ResourceLocation tex = new ResourceLocation(IHLModInfo.MODID+":textures/blocks/ironWorkbench.png"); +private final float scale=1F/16F; + +@SideOnly(value=Side.CLIENT) +public UniversalTileRender(ModelBase model1, ResourceLocation texture) +{ + this.model=model1; + this.tex=texture; +} + + @Override + public void renderTileEntityAt(TileEntity tile, double x, double y, double z, float par8) + { + int rotation = 0; + if(tile.getWorldObj() != null) + { + switch (((IWrenchable)tile).getFacing()) + { + case 2: + rotation = 0; + break; + case 5: + rotation = 1; + break; + case 3: + rotation = 2; + break; + case 4: + rotation = 3; + break; + default: + rotation = 0; + } + } + GL11.glPushMatrix(); + GL11.glEnable(GL11.GL_BLEND); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + GL11.glTranslatef((float)x + 0.5F, (float)y + 1.5F, (float)z + 0.5F); + GL11.glScalef(1.0F, -1F, -1F); + GL11.glRotatef(rotation*90, 0.0F, 1.0F, 0.0F); + + bindTexture(tex); + for(int i = 0;i