remove all

6 files changed, 0 insertions, 1096 deletions

diff --git a/src/main/java/gregtech/common/render/GT_CapeRenderer.java b/src/main/java/gregtech/common/render/GT_CapeRenderer.java
deleted file mode 100644
index c62a68700f..0000000000
--- a/src/main/java/gregtech/common/render/GT_CapeRenderer.java
+++ /dev/null
@@ -1,110 +0,0 @@
-package gregtech.common.render;

-

-import gregtech.api.enums.GT_Values;

-import gregtech.api.util.GT_Log;

-import gregtech.api.util.GT_Utility;

-import net.minecraft.client.entity.AbstractClientPlayer;

-import net.minecraft.client.model.ModelBiped;

-import net.minecraft.client.renderer.entity.RenderManager;

-import net.minecraft.client.renderer.entity.RenderPlayer;

-import net.minecraft.potion.Potion;

-import net.minecraft.util.MathHelper;

-import net.minecraft.util.ResourceLocation;

-import net.minecraftforge.client.event.RenderPlayerEvent;

-import org.lwjgl.opengl.GL11;

-

-import java.util.Collection;

-

-public class GT_CapeRenderer

-        extends RenderPlayer {

-    private final ResourceLocation[] mCapes = { new ResourceLocation("gregtech:textures/BrainTechCape.png"),

-                                                new ResourceLocation("gregtech:textures/GregTechCape.png"),

-                                                new ResourceLocation("gregtech:textures/MrBrainCape.png"),

-                                                new ResourceLocation("gregtech:textures/GregoriusCape.png"),

-                                                new ResourceLocation("gregtech:textures/DonorCape.png"),

-                                                new ResourceLocation("gregtech:textures/DevCape.png"),

-                                                new ResourceLocation("gregtech:textures/TecCape.png")};

-    private final Collection<String> mCapeList;

-

-    public GT_CapeRenderer(Collection<String> aCapeList) {

-        this.mCapeList = aCapeList;

-        setRenderManager(RenderManager.instance);

-    }

-

-    public void receiveRenderSpecialsEvent(RenderPlayerEvent.Specials.Pre aEvent) {

-        AbstractClientPlayer aPlayer = (AbstractClientPlayer) aEvent.entityPlayer;

-        if (GT_Utility.getFullInvisibility(aPlayer)) {

-            aEvent.setCanceled(true);

-            return;

-        }

-        float aPartialTicks = aEvent.partialRenderTick;

-        if (aPlayer.isInvisible()) {

-            return;

-        }

-        if (GT_Utility.getPotion(aPlayer, Integer.valueOf(Potion.invisibility.id).intValue())) {

-            return;

-        }

-        try {

-            ResourceLocation tResource = null;

-            if (aPlayer.getDisplayName().equalsIgnoreCase("Friedi4321")) {

-                tResource = this.mCapes[0];

-            }

-            if (this.mCapeList.contains(aPlayer.getDisplayName().toLowerCase())) {

-                tResource = this.mCapes[1];

-            }

-            if (aPlayer.getDisplayName().equalsIgnoreCase("Mr_Brain")) {

-                tResource = this.mCapes[2];

-            }

-            if (aPlayer.getDisplayName().equalsIgnoreCase("GregoriusT")) {

-                tResource = this.mCapes[3];

-            }

-            if (this.mCapeList.contains(aPlayer.getDisplayName().toLowerCase() + ":capedonor")) {

-                tResource = this.mCapes[4];

-            }

-            if (this.mCapeList.contains(aPlayer.getDisplayName().toLowerCase() + ":capedev")) {

-                tResource = this.mCapes[5];

-            }

-            if (this.mCapeList.contains(aPlayer.getDisplayName().toLowerCase() + ":capetec")) {

-                tResource = this.mCapes[6];

-            }

-            if ((tResource != null) && (!aPlayer.getHideCape())) {

-                bindTexture(tResource);

-                GL11.glPushMatrix();

-                GL11.glTranslatef(0.0F, 0.0F, 0.125F);

-                double d0 = aPlayer.field_71091_bM + (aPlayer.field_71094_bP - aPlayer.field_71091_bM) * aPartialTicks - (aPlayer.prevPosX + (aPlayer.posX - aPlayer.prevPosX) * aPartialTicks);

-                double d1 = aPlayer.field_71096_bN + (aPlayer.field_71095_bQ - aPlayer.field_71096_bN) * aPartialTicks - (aPlayer.prevPosY + (aPlayer.posY - aPlayer.prevPosY) * aPartialTicks);

-                double d2 = aPlayer.field_71097_bO + (aPlayer.field_71085_bR - aPlayer.field_71097_bO) * aPartialTicks - (aPlayer.prevPosZ + (aPlayer.posZ - aPlayer.prevPosZ) * aPartialTicks);

-                float f6 = aPlayer.prevRenderYawOffset + (aPlayer.renderYawOffset - aPlayer.prevRenderYawOffset) * aPartialTicks;

-                double d3 = MathHelper.sin(f6 * 3.141593F / 180.0F);

-                double d4 = -MathHelper.cos(f6 * 3.141593F / 180.0F);

-                float f7 = (float) d1 * 10.0F;

-                float f8 = (float) (d0 * d3 + d2 * d4) * 100.0F;

-                float f9 = (float) (d0 * d4 - d2 * d3) * 100.0F;

-                if (f7 < -6.0F) {

-                    f7 = -6.0F;

-                }

-                if (f7 > 32.0F) {

-                    f7 = 32.0F;

-                }

-                if (f8 < 0.0F) {

-                    f8 = 0.0F;

-                }

-                float f10 = aPlayer.prevCameraYaw + (aPlayer.cameraYaw - aPlayer.prevCameraYaw) * aPartialTicks;

-                f7 += MathHelper.sin((aPlayer.prevDistanceWalkedModified + (aPlayer.distanceWalkedModified - aPlayer.prevDistanceWalkedModified) * aPartialTicks) * 6.0F) * 32.0F * f10;

-                if (aPlayer.isSneaking()) {

-                    f7 += 25.0F;

-                }

-                GL11.glRotatef(6.0F + f8 / 2.0F + f7, 1.0F, 0.0F, 0.0F);

-                GL11.glRotatef(f9 / 2.0F, 0.0F, 0.0F, 1.0F);

-                GL11.glRotatef(-f9 / 2.0F, 0.0F, 1.0F, 0.0F);

-                GL11.glRotatef(180.0F, 0.0F, 1.0F, 0.0F);

-                ((ModelBiped) this.mainModel).renderCloak(0.0625F);

-                GL11.glPopMatrix();

-            }

-        } catch (Throwable e) {

-            if (GT_Values.D1) {

-                e.printStackTrace(GT_Log.err);

-            }

-        }

-    }

-}

diff --git a/src/main/java/gregtech/common/render/GT_MetaGenerated_Item_Renderer.java b/src/main/java/gregtech/common/render/GT_MetaGenerated_Item_Renderer.java
deleted file mode 100644
index 316b5542a5..0000000000
--- a/src/main/java/gregtech/common/render/GT_MetaGenerated_Item_Renderer.java
+++ /dev/null
@@ -1,154 +0,0 @@
-package gregtech.common.render;

-

-import gregtech.api.interfaces.IIconContainer;

-import gregtech.api.items.GT_MetaGenerated_Item;

-import gregtech.api.util.GT_Utility;

-import net.minecraft.client.Minecraft;

-import net.minecraft.client.renderer.ItemRenderer;

-import net.minecraft.client.renderer.Tessellator;

-import net.minecraft.client.renderer.entity.RenderItem;

-import net.minecraft.client.renderer.texture.TextureMap;

-import net.minecraft.item.ItemStack;

-import net.minecraft.util.IIcon;

-import net.minecraftforge.client.IItemRenderer;

-import net.minecraftforge.client.MinecraftForgeClient;

-import net.minecraftforge.fluids.FluidStack;

-import org.lwjgl.opengl.GL11;

-

-import java.util.Iterator;

-

-public class GT_MetaGenerated_Item_Renderer

-        implements IItemRenderer {

-    public GT_MetaGenerated_Item_Renderer() {

-        GT_MetaGenerated_Item tItem;

-        for (Iterator i$ = GT_MetaGenerated_Item.sInstances.values().iterator(); i$.hasNext(); MinecraftForgeClient.registerItemRenderer(tItem, this)) {

-            tItem = (GT_MetaGenerated_Item) i$.next();

-            if ((tItem == null) || (!tItem.useStandardMetaItemRenderer())) {

-            }

-        }

-    }

-

-    public boolean handleRenderType(ItemStack aStack, IItemRenderer.ItemRenderType aType) {

-        if ((GT_Utility.isStackInvalid(aStack)) || (aStack.getItemDamage() < 0)) {

-            return false;

-        }

-        return (aType == IItemRenderer.ItemRenderType.EQUIPPED_FIRST_PERSON) || (aType == IItemRenderer.ItemRenderType.INVENTORY) || (aType == IItemRenderer.ItemRenderType.EQUIPPED) || (aType == IItemRenderer.ItemRenderType.ENTITY);

-    }

-

-    public boolean shouldUseRenderHelper(IItemRenderer.ItemRenderType aType, ItemStack aStack, IItemRenderer.ItemRendererHelper aHelper) {

-        if (GT_Utility.isStackInvalid(aStack)) {

-            return false;

-        }

-        return aType == IItemRenderer.ItemRenderType.ENTITY;

-    }

-

-    public void renderItem(IItemRenderer.ItemRenderType type, ItemStack aStack, Object... data) {

-        if (GT_Utility.isStackInvalid(aStack)) {

-            return;

-        }

-        short aMetaData = (short) aStack.getItemDamage();

-        if (aMetaData < 0) {

-            return;

-        }

-        GT_MetaGenerated_Item aItem = (GT_MetaGenerated_Item) aStack.getItem();

-

-

-        GL11.glEnable(3042);

-        if (type == IItemRenderer.ItemRenderType.ENTITY) {

-            if (RenderItem.renderInFrame) {

-                GL11.glScalef(0.85F, 0.85F, 0.85F);

-                GL11.glRotatef(-90.0F, 0.0F, 1.0F, 0.0F);

-                GL11.glTranslated(-0.5D, -0.42D, 0.0D);

-            } else {

-                GL11.glTranslated(-0.5D, -0.42D, 0.0D);

-            }

-        }

-        GL11.glColor3f(1.0F, 1.0F, 1.0F);

-        if (aMetaData < aItem.mOffset) {

-            IIconContainer aIcon = aItem.getIconContainer(aMetaData);

-            IIcon tOverlay = null;

-            IIcon tFluidIcon = null;

-            IIcon tIcon;

-            if (aIcon == null) {

-                tIcon = aStack.getIconIndex();

-            } else {

-                tIcon = aIcon.getIcon();

-                tOverlay = aIcon.getOverlayIcon();

-            }

-            if (tIcon == null) {

-                return;

-            }

-            FluidStack tFluid = GT_Utility.getFluidForFilledItem(aStack, true);

-            if ((tOverlay != null) && (tFluid != null) && (tFluid.getFluid() != null)) {

-                tFluidIcon = tFluid.getFluid().getIcon(tFluid);

-            }

-            Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationItemsTexture);

-            GL11.glBlendFunc(770, 771);

-            if (tFluidIcon == null) {

-                short[] tModulation = aItem.getRGBa(aStack);

-                GL11.glColor3f(tModulation[0] / 255.0F, tModulation[1] / 255.0F, tModulation[2] / 255.0F);

-            }

-            if (type.equals(IItemRenderer.ItemRenderType.INVENTORY)) {

-                GT_RenderUtil.renderItemIcon(tIcon, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F);

-            } else {

-                ItemRenderer.renderItemIn2D(Tessellator.instance, tIcon.getMaxU(), tIcon.getMinV(), tIcon.getMinU(), tIcon.getMaxV(), tIcon.getIconWidth(), tIcon.getIconHeight(), 0.0625F);

-            }

-            if (tFluidIcon != null) {

-                assert (tFluid != null);

-                int tColor = tFluid.getFluid().getColor(tFluid);

-                GL11.glColor3f((tColor >> 16 & 0xFF) / 255.0F, (tColor >> 8 & 0xFF) / 255.0F, (tColor & 0xFF) / 255.0F);

-                Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationBlocksTexture);

-                GL11.glBlendFunc(770, 771);

-                GL11.glDepthFunc(514);

-                if (type.equals(IItemRenderer.ItemRenderType.INVENTORY)) {

-                    GT_RenderUtil.renderItemIcon(tFluidIcon, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F);

-                } else {

-                    ItemRenderer.renderItemIn2D(Tessellator.instance, tFluidIcon.getMaxU(), tFluidIcon.getMinV(), tFluidIcon.getMinU(), tFluidIcon.getMaxV(), tFluidIcon.getIconWidth(), tFluidIcon.getIconHeight(), 0.0625F);

-                }

-                GL11.glDepthFunc(515);

-            }

-            GL11.glColor3f(1.0F, 1.0F, 1.0F);

-            if (tOverlay != null) {

-                Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationItemsTexture);

-                GL11.glBlendFunc(770, 771);

-                if (type.equals(IItemRenderer.ItemRenderType.INVENTORY)) {

-                    GT_RenderUtil.renderItemIcon(tOverlay, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F);

-                } else {

-                    ItemRenderer.renderItemIn2D(Tessellator.instance, tOverlay.getMaxU(), tOverlay.getMinV(), tOverlay.getMinU(), tOverlay.getMaxV(), tOverlay.getIconWidth(), tOverlay.getIconHeight(), 0.0625F);

-                }

-            }

-        } else {

-            IIcon tIcon;

-            if (aItem.mIconList[(aMetaData - aItem.mOffset)].length > 1) {

-                Long[] tStats = (Long[]) aItem.mElectricStats.get(Short.valueOf(aMetaData));

-

-                if ((tStats != null) && (tStats[3].longValue() < 0L)) {

-                    long tCharge = aItem.getRealCharge(aStack);

-

-                    if (tCharge <= 0L) {

-                        tIcon = aItem.mIconList[(aMetaData - aItem.mOffset)][1];

-                    } else {

-

-                        if (tCharge >= tStats[0].longValue()) {

-                            tIcon = aItem.mIconList[(aMetaData - aItem.mOffset)][8];

-                        } else {

-                            tIcon = aItem.mIconList[(aMetaData - aItem.mOffset)][(7 - (int) java.lang.Math.max(0L, java.lang.Math.min(5L, (tStats[0].longValue() - tCharge) * 6L / tStats[0].longValue())))];

-                        }

-                    }

-                } else {

-                    tIcon = aItem.mIconList[(aMetaData - aItem.mOffset)][0];

-                }

-            } else {

-                tIcon = aItem.mIconList[(aMetaData - aItem.mOffset)][0];

-            }

-            Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationItemsTexture);

-            GL11.glBlendFunc(770, 771);

-            if (type.equals(IItemRenderer.ItemRenderType.INVENTORY)) {

-                GT_RenderUtil.renderItemIcon(tIcon, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F);

-            } else {

-                ItemRenderer.renderItemIn2D(Tessellator.instance, tIcon.getMaxU(), tIcon.getMinV(), tIcon.getMinU(), tIcon.getMaxV(), tIcon.getIconWidth(), tIcon.getIconHeight(), 0.0625F);

-            }

-        }

-        GL11.glDisable(3042);

-    }

-}

diff --git a/src/main/java/gregtech/common/render/GT_MetaGenerated_Tool_Renderer.java b/src/main/java/gregtech/common/render/GT_MetaGenerated_Tool_Renderer.java
deleted file mode 100644
index 40d4acf8f8..0000000000
--- a/src/main/java/gregtech/common/render/GT_MetaGenerated_Tool_Renderer.java
+++ /dev/null
@@ -1,184 +0,0 @@
-package gregtech.common.render;

-

-import gregtech.api.enums.Materials;

-import gregtech.api.interfaces.IIconContainer;

-import gregtech.api.interfaces.IToolStats;

-import gregtech.api.items.GT_MetaGenerated_Tool;

-import gregtech.api.util.GT_Utility;

-import net.minecraft.client.Minecraft;

-import net.minecraft.client.renderer.ItemRenderer;

-import net.minecraft.client.renderer.Tessellator;

-import net.minecraft.client.renderer.entity.RenderItem;

-import net.minecraft.item.ItemStack;

-import net.minecraft.util.IIcon;

-import net.minecraftforge.client.IItemRenderer;

-import net.minecraftforge.client.MinecraftForgeClient;

-import org.lwjgl.opengl.GL11;

-

-public class GT_MetaGenerated_Tool_Renderer

-        implements IItemRenderer {

-    public GT_MetaGenerated_Tool_Renderer() {

-        for (GT_MetaGenerated_Tool tItem : GT_MetaGenerated_Tool.sInstances.values()) {

-            if (tItem != null) {

-                MinecraftForgeClient.registerItemRenderer(tItem, this);

-            }

-        }

-    }

-

-    public boolean handleRenderType(ItemStack aStack, IItemRenderer.ItemRenderType aType) {

-        if ((GT_Utility.isStackInvalid(aStack)) || (aStack.getItemDamage() < 0)) {

-            return false;

-        }

-        return (aType == IItemRenderer.ItemRenderType.EQUIPPED_FIRST_PERSON) || (aType == IItemRenderer.ItemRenderType.INVENTORY) || (aType == IItemRenderer.ItemRenderType.EQUIPPED) || (aType == IItemRenderer.ItemRenderType.ENTITY);

-    }

-

-    public boolean shouldUseRenderHelper(IItemRenderer.ItemRenderType aType, ItemStack aStack, IItemRenderer.ItemRendererHelper aHelper) {

-        if (GT_Utility.isStackInvalid(aStack)) {

-            return false;

-        }

-        return aType == IItemRenderer.ItemRenderType.ENTITY;

-    }

-

-    public void renderItem(IItemRenderer.ItemRenderType aType, ItemStack aStack, Object... data) {

-        if (GT_Utility.isStackInvalid(aStack)) {

-            return;

-        }

-        GT_MetaGenerated_Tool aItem = (GT_MetaGenerated_Tool) aStack.getItem();

-        GL11.glEnable(3042);

-        if (aType == IItemRenderer.ItemRenderType.ENTITY) {

-            if (RenderItem.renderInFrame) {

-                GL11.glScalef(0.85F, 0.85F, 0.85F);

-                GL11.glRotatef(-90.0F, 0.0F, 1.0F, 0.0F);

-                GL11.glTranslated(-0.5D, -0.42D, 0.0D);

-            } else {

-                GL11.glTranslated(-0.5D, -0.42D, 0.0D);

-            }

-        }

-        GL11.glColor3f(1.0F, 1.0F, 1.0F);

-

-        IToolStats tToolStats = aItem.getToolStats(aStack);

-        if (tToolStats != null) {

-            IIconContainer aIcon = tToolStats.getIcon(false, aStack);

-            if (aIcon != null) {

-                IIcon tIcon = aIcon.getIcon();

-                IIcon tOverlay = aIcon.getOverlayIcon();

-                if (tIcon != null) {

-                    Minecraft.getMinecraft().renderEngine.bindTexture(aIcon.getTextureFile());

-                    GL11.glBlendFunc(770, 771);

-                    short[] tModulation = tToolStats.getRGBa(false, aStack);

-                    GL11.glColor3f(tModulation[0] / 255.0F, tModulation[1] / 255.0F, tModulation[2] / 255.0F);

-                    if (aType.equals(IItemRenderer.ItemRenderType.INVENTORY)) {

-                        GT_RenderUtil.renderItemIcon(tIcon, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F);

-                    } else {

-                        ItemRenderer.renderItemIn2D(Tessellator.instance, tIcon.getMaxU(), tIcon.getMinV(), tIcon.getMinU(), tIcon.getMaxV(), tIcon.getIconWidth(), tIcon.getIconHeight(), 0.0625F);

-                    }

-                    GL11.glColor3f(1.0F, 1.0F, 1.0F);

-                }

-                if (tOverlay != null) {

-                    Minecraft.getMinecraft().renderEngine.bindTexture(aIcon.getTextureFile());

-                    GL11.glBlendFunc(770, 771);

-                    if (aType.equals(IItemRenderer.ItemRenderType.INVENTORY)) {

-                        GT_RenderUtil.renderItemIcon(tOverlay, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F);

-                    } else {

-                        ItemRenderer.renderItemIn2D(Tessellator.instance, tOverlay.getMaxU(), tOverlay.getMinV(), tOverlay.getMinU(), tOverlay.getMaxV(), tOverlay.getIconWidth(), tOverlay.getIconHeight(), 0.0625F);

-                    }

-                }

-            }

-            aIcon = tToolStats.getIcon(true, aStack);

-            if (aIcon != null) {

-                IIcon tIcon = aIcon.getIcon();

-                IIcon tOverlay = aIcon.getOverlayIcon();

-                if (tIcon != null) {

-                    Minecraft.getMinecraft().renderEngine.bindTexture(aIcon.getTextureFile());

-                    GL11.glBlendFunc(770, 771);

-                    short[] tModulation = tToolStats.getRGBa(true, aStack);

-                    GL11.glColor3f(tModulation[0] / 255.0F, tModulation[1] / 255.0F, tModulation[2] / 255.0F);

-                    if (aType.equals(IItemRenderer.ItemRenderType.INVENTORY)) {

-                        GT_RenderUtil.renderItemIcon(tIcon, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F);

-                    } else {

-                        ItemRenderer.renderItemIn2D(Tessellator.instance, tIcon.getMaxU(), tIcon.getMinV(), tIcon.getMinU(), tIcon.getMaxV(), tIcon.getIconWidth(), tIcon.getIconHeight(), 0.0625F);

-                    }

-                    GL11.glColor3f(1.0F, 1.0F, 1.0F);

-                }

-                if (tOverlay != null) {

-                    Minecraft.getMinecraft().renderEngine.bindTexture(aIcon.getTextureFile());

-                    GL11.glBlendFunc(770, 771);

-                    if (aType.equals(IItemRenderer.ItemRenderType.INVENTORY)) {

-                        GT_RenderUtil.renderItemIcon(tOverlay, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F);

-                    } else {

-                        ItemRenderer.renderItemIn2D(Tessellator.instance, tOverlay.getMaxU(), tOverlay.getMinV(), tOverlay.getMinU(), tOverlay.getMaxV(), tOverlay.getIconWidth(), tOverlay.getIconHeight(), 0.0625F);

-                    }

-                }

-            }

-            if ((aType == IItemRenderer.ItemRenderType.INVENTORY) && (GT_MetaGenerated_Tool.getPrimaryMaterial(aStack) != Materials._NULL)) {

-                long tDamage = GT_MetaGenerated_Tool.getToolDamage(aStack);

-                long tMaxDamage = GT_MetaGenerated_Tool.getToolMaxDamage(aStack);

-                if (tDamage <= 0L) {

-                    aIcon = gregtech.api.enums.Textures.ItemIcons.DURABILITY_BAR[8];

-                } else if (tDamage >= tMaxDamage) {

-                    aIcon = gregtech.api.enums.Textures.ItemIcons.DURABILITY_BAR[0];

-                } else {

-                    aIcon = gregtech.api.enums.Textures.ItemIcons.DURABILITY_BAR[((int) java.lang.Math.max(0L, java.lang.Math.min(7L, (tMaxDamage - tDamage) * 8L / tMaxDamage)))];

-                }

-                if (aIcon != null) {

-                    IIcon tIcon = aIcon.getIcon();

-                    IIcon tOverlay = aIcon.getOverlayIcon();

-                    if (tIcon != null) {

-                        Minecraft.getMinecraft().renderEngine.bindTexture(aIcon.getTextureFile());

-                        GL11.glBlendFunc(770, 771);

-                        if (aType.equals(IItemRenderer.ItemRenderType.INVENTORY)) {

-                            GT_RenderUtil.renderItemIcon(tIcon, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F);

-                        } else {

-                            ItemRenderer.renderItemIn2D(Tessellator.instance, tIcon.getMaxU(), tIcon.getMinV(), tIcon.getMinU(), tIcon.getMaxV(), tIcon.getIconWidth(), tIcon.getIconHeight(), 0.0625F);

-                        }

-                    }

-                    if (tOverlay != null) {

-                        Minecraft.getMinecraft().renderEngine.bindTexture(aIcon.getTextureFile());

-                        GL11.glBlendFunc(770, 771);

-                        if (aType.equals(IItemRenderer.ItemRenderType.INVENTORY)) {

-                            GT_RenderUtil.renderItemIcon(tOverlay, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F);

-                        } else {

-                            ItemRenderer.renderItemIn2D(Tessellator.instance, tOverlay.getMaxU(), tOverlay.getMinV(), tOverlay.getMinU(), tOverlay.getMaxV(), tOverlay.getIconWidth(), tOverlay.getIconHeight(), 0.0625F);

-                        }

-                    }

-                }

-                Long[] tStats = aItem.getElectricStats(aStack);

-                if ((tStats != null) && (tStats[3].longValue() < 0L)) {

-                    long tCharge = aItem.getRealCharge(aStack);

-                    if (tCharge <= 0L) {

-                        aIcon = gregtech.api.enums.Textures.ItemIcons.ENERGY_BAR[0];

-                    } else if (tCharge >= tStats[0].longValue()) {

-                        aIcon = gregtech.api.enums.Textures.ItemIcons.ENERGY_BAR[8];

-                    } else {

-                        aIcon = gregtech.api.enums.Textures.ItemIcons.ENERGY_BAR[(7 - (int) java.lang.Math.max(0L, java.lang.Math.min(6L, (tStats[0].longValue() - tCharge) * 7L / tStats[0].longValue())))];

-                    }

-                } else {

-                    aIcon = null;

-                }

-                if (aIcon != null) {

-                    IIcon tIcon = aIcon.getIcon();

-                    IIcon tOverlay = aIcon.getOverlayIcon();

-                    if (tIcon != null) {

-                        Minecraft.getMinecraft().renderEngine.bindTexture(aIcon.getTextureFile());

-                        GL11.glBlendFunc(770, 771);

-                        if (aType.equals(IItemRenderer.ItemRenderType.INVENTORY)) {

-                            GT_RenderUtil.renderItemIcon(tIcon, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F);

-                        } else {

-                            ItemRenderer.renderItemIn2D(Tessellator.instance, tIcon.getMaxU(), tIcon.getMinV(), tIcon.getMinU(), tIcon.getMaxV(), tIcon.getIconWidth(), tIcon.getIconHeight(), 0.0625F);

-                        }

-                    }

-                    if (tOverlay != null) {

-                        Minecraft.getMinecraft().renderEngine.bindTexture(aIcon.getTextureFile());

-                        GL11.glBlendFunc(770, 771);

-                        if (aType.equals(IItemRenderer.ItemRenderType.INVENTORY)) {

-                            GT_RenderUtil.renderItemIcon(tOverlay, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F);

-                        } else {

-                            ItemRenderer.renderItemIn2D(Tessellator.instance, tOverlay.getMaxU(), tOverlay.getMinV(), tOverlay.getMinU(), tOverlay.getMaxV(), tOverlay.getIconWidth(), tOverlay.getIconHeight(), 0.0625F);

-                        }

-                    }

-                }

-            }

-        }

-        GL11.glDisable(3042);

-    }

-}

diff --git a/src/main/java/gregtech/common/render/GT_RenderUtil.java b/src/main/java/gregtech/common/render/GT_RenderUtil.java
deleted file mode 100644
index cba37972fe..0000000000
--- a/src/main/java/gregtech/common/render/GT_RenderUtil.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package gregtech.common.render;

-

-import net.minecraft.client.renderer.Tessellator;

-import net.minecraft.util.IIcon;

-

-public class GT_RenderUtil {

-    public static void renderItemIcon(IIcon icon, double size, double z, float nx, float ny, float nz) {

-        renderItemIcon(icon, 0.0D, 0.0D, size, size, z, nx, ny, nz);

-    }

-

-    public static void renderItemIcon(IIcon icon, double xStart, double yStart, double xEnd, double yEnd, double z, float nx, float ny, float nz) {

-        if (icon == null) {

-            return;

-        }

-        Tessellator.instance.startDrawingQuads();

-        Tessellator.instance.setNormal(nx, ny, nz);

-        if (nz > 0.0F) {

-            Tessellator.instance.addVertexWithUV(xStart, yStart, z, icon.getMinU(), icon.getMinV());

-            Tessellator.instance.addVertexWithUV(xEnd, yStart, z, icon.getMaxU(), icon.getMinV());

-            Tessellator.instance.addVertexWithUV(xEnd, yEnd, z, icon.getMaxU(), icon.getMaxV());

-            Tessellator.instance.addVertexWithUV(xStart, yEnd, z, icon.getMinU(), icon.getMaxV());

-        } else {

-            Tessellator.instance.addVertexWithUV(xStart, yEnd, z, icon.getMinU(), icon.getMaxV());

-            Tessellator.instance.addVertexWithUV(xEnd, yEnd, z, icon.getMaxU(), icon.getMaxV());

-            Tessellator.instance.addVertexWithUV(xEnd, yStart, z, icon.getMaxU(), icon.getMinV());

-            Tessellator.instance.addVertexWithUV(xStart, yStart, z, icon.getMinU(), icon.getMinV());

-        }

-        Tessellator.instance.draw();

-    }

-}

diff --git a/src/main/java/gregtech/common/render/GT_Renderer_Block.java b/src/main/java/gregtech/common/render/GT_Renderer_Block.java
deleted file mode 100644
index 95fd453592..0000000000
--- a/src/main/java/gregtech/common/render/GT_Renderer_Block.java
+++ /dev/null
@@ -1,598 +0,0 @@
-package gregtech.common.render;
-
-import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
-import cpw.mods.fml.client.registry.RenderingRegistry;
-import gregtech.api.GregTech_API;
-import gregtech.api.interfaces.ITexture;
-import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
-import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
-import gregtech.api.interfaces.tileentity.IPipeRenderedTileEntity;
-import gregtech.api.interfaces.tileentity.ITexturedTileEntity;
-import gregtech.common.blocks.GT_Block_Machines;
-import gregtech.common.blocks.GT_Block_Ores;
-import gregtech.common.blocks.GT_TileEntity_Ores;
-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.world.IBlockAccess;
-import org.lwjgl.opengl.GL11;
-
-public class GT_Renderer_Block
-        implements ISimpleBlockRenderingHandler {
-    public static GT_Renderer_Block INSTANCE;
-    public final int mRenderID;
-
-    public GT_Renderer_Block() {
-        this.mRenderID = RenderingRegistry.getNextAvailableRenderId();
-        INSTANCE = this;
-        RenderingRegistry.registerBlockHandler(this);
-    }
-
-    private static void renderNormalInventoryMetaTileEntity(Block aBlock, int aMeta, RenderBlocks aRenderer) {
-        if ((aMeta <= 0) || (aMeta >= GregTech_API.METATILEENTITIES.length)) {
-            return;
-        }
-        IMetaTileEntity tMetaTileEntity = GregTech_API.METATILEENTITIES[aMeta];
-        if (tMetaTileEntity == null) {
-            return;
-        }
-        aBlock.setBlockBoundsForItemRender();
-        aRenderer.setRenderBoundsFromBlock(aBlock);
-
-        GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F);
-        GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
-        if ((tMetaTileEntity.getBaseMetaTileEntity() instanceof IPipeRenderedTileEntity)) {
-            float tThickness = ((IPipeRenderedTileEntity) tMetaTileEntity.getBaseMetaTileEntity()).getThickNess();
-            float sp = (1.0F - tThickness) / 2.0F;
-
-            aBlock.setBlockBounds(0.0F, sp, sp, 1.0F, sp + tThickness, sp + tThickness);
-            aRenderer.setRenderBoundsFromBlock(aBlock);
-
-            Tessellator.instance.startDrawingQuads();
-            Tessellator.instance.setNormal(0.0F, -1.0F, 0.0F);
-            renderNegativeYFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte) 0, (byte) 9, (byte) -1, false, false), true);
-            Tessellator.instance.draw();
-
-            Tessellator.instance.startDrawingQuads();
-            Tessellator.instance.setNormal(0.0F, 1.0F, 0.0F);
-            renderPositiveYFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte) 1, (byte) 9, (byte) -1, false, false), true);
-            Tessellator.instance.draw();
-
-            Tessellator.instance.startDrawingQuads();
-            Tessellator.instance.setNormal(0.0F, 0.0F, -1.0F);
-            renderNegativeZFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte) 2, (byte) 9, (byte) -1, false, false), true);
-            Tessellator.instance.draw();
-
-            Tessellator.instance.startDrawingQuads();
-            Tessellator.instance.setNormal(0.0F, 0.0F, 1.0F);
-            renderPositiveZFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte) 3, (byte) 9, (byte) -1, false, false), true);
-            Tessellator.instance.draw();
-
-            Tessellator.instance.startDrawingQuads();
-            Tessellator.instance.setNormal(-1.0F, 0.0F, 0.0F);
-            renderNegativeXFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte) 4, (byte) 9, (byte) -1, true, false), true);
-            Tessellator.instance.draw();
-
-            Tessellator.instance.startDrawingQuads();
-            Tessellator.instance.setNormal(1.0F, 0.0F, 0.0F);
-            renderPositiveXFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte) 5, (byte) 9, (byte) -1, true, false), true);
-            Tessellator.instance.draw();
-        } else {
-            Tessellator.instance.startDrawingQuads();
-            Tessellator.instance.setNormal(0.0F, -1.0F, 0.0F);
-            renderNegativeYFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte) 0, (byte) 4, (byte) -1, true, false), true);
-            Tessellator.instance.draw();
-
-            Tessellator.instance.startDrawingQuads();
-            Tessellator.instance.setNormal(0.0F, 1.0F, 0.0F);
-            renderPositiveYFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte) 1, (byte) 4, (byte) -1, true, false), true);
-            Tessellator.instance.draw();
-
-            Tessellator.instance.startDrawingQuads();
-            Tessellator.instance.setNormal(0.0F, 0.0F, -1.0F);
-            renderNegativeZFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte) 2, (byte) 4, (byte) -1, true, false), true);
-            Tessellator.instance.draw();
-
-            Tessellator.instance.startDrawingQuads();
-            Tessellator.instance.setNormal(0.0F, 0.0F, 1.0F);
-            renderPositiveZFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte) 3, (byte) 4, (byte) -1, true, false), true);
-            Tessellator.instance.draw();
-
-            Tessellator.instance.startDrawingQuads();
-            Tessellator.instance.setNormal(-1.0F, 0.0F, 0.0F);
-            renderNegativeXFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte) 4, (byte) 4, (byte) -1, true, false), true);
-            Tessellator.instance.draw();
-
-            Tessellator.instance.startDrawingQuads();
-            Tessellator.instance.setNormal(1.0F, 0.0F, 0.0F);
-            renderPositiveXFacing(null, aRenderer, aBlock, 0, 0, 0, tMetaTileEntity.getTexture(tMetaTileEntity.getBaseMetaTileEntity(), (byte) 5, (byte) 4, (byte) -1, true, false), true);
-            Tessellator.instance.draw();
-        }
-        aBlock.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
-        aRenderer.setRenderBoundsFromBlock(aBlock);
-        GL11.glTranslatef(0.5F, 0.5F, 0.5F);
-    }
-
-    public static boolean renderStandardBlock(IBlockAccess aWorld, int aX, int aY, int aZ, Block aBlock, RenderBlocks aRenderer) {
-        TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
-        if ((tTileEntity instanceof ITexturedTileEntity)) {
-            return renderStandardBlock(aWorld, aX, aY, aZ, aBlock, aRenderer, new ITexture[][]{((ITexturedTileEntity) tTileEntity).getTexture((byte) 0), ((ITexturedTileEntity) tTileEntity).getTexture((byte) 1), ((ITexturedTileEntity) tTileEntity).getTexture((byte) 2), ((ITexturedTileEntity) tTileEntity).getTexture((byte) 3), ((ITexturedTileEntity) tTileEntity).getTexture((byte) 4), ((ITexturedTileEntity) tTileEntity).getTexture((byte) 5)});
-        }
-        return false;
-    }
-
-    public static boolean renderStandardBlock(IBlockAccess aWorld, int aX, int aY, int aZ, Block aBlock, RenderBlocks aRenderer, ITexture[][] aTextures) {
-        aBlock.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
-        aRenderer.setRenderBoundsFromBlock(aBlock);
-
-        renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, aTextures[0], true);
-        renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, aTextures[1], true);
-        renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, aTextures[2], true);
-        renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, aTextures[3], true);
-        renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, aTextures[4], true);
-        renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, aTextures[5], true);
-        return true;
-    }
-
-    public static boolean renderPipeBlock(IBlockAccess aWorld, int aX, int aY, int aZ, Block aBlock, IPipeRenderedTileEntity aTileEntity, RenderBlocks aRenderer) {
-        byte aConnections = aTileEntity.getConnections();
-        if ((aConnections & 0xC0) != 0) {
-            return renderStandardBlock(aWorld, aX, aY, aZ, aBlock, aRenderer);
-        }
-        float tThickness = aTileEntity.getThickNess();
-        if (tThickness >= 0.99F) {
-            return renderStandardBlock(aWorld, aX, aY, aZ, aBlock, aRenderer);
-        }
-        float sp = (1.0F - tThickness) / 2.0F;
-
-        byte tConnections = 0;
-        for (byte i = 0; i < 6; i = (byte) (i + 1)) {
-            if ((aConnections & 1 << i) != 0) {
-                tConnections = (byte) (tConnections | 1 << (i + 2) % 6);
-            }
-        }
-        boolean[] tIsCovered = new boolean[6];
-        for (byte i = 0; i < 6; i = (byte) (i + 1)) {
-            tIsCovered[i] = (aTileEntity.getCoverIDAtSide(i) != 0 ? true : false);
-        }
-        if ((tIsCovered[0]) && (tIsCovered[1]) && (tIsCovered[2]) && (tIsCovered[3]) && (tIsCovered[4]) && (tIsCovered[5])) {
-            return renderStandardBlock(aWorld, aX, aY, aZ, aBlock, aRenderer);
-        }
-        ITexture[][] tIcons = new ITexture[6][];
-        ITexture[][] tCovers = new ITexture[6][];
-        for (byte i = 0; i < 6; i = (byte) (i + 1)) {
-            tCovers[i] = aTileEntity.getTexture(i);
-            tIcons[i] = aTileEntity.getTextureUncovered(i);
-        }
-        if (tConnections == 0) {
-            aBlock.setBlockBounds(sp, sp, sp, sp + tThickness, sp + tThickness, sp + tThickness);
-            aRenderer.setRenderBoundsFromBlock(aBlock);
-            renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[0], false);
-            renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[1], false);
-            renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[2], false);
-            renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[3], false);
-            renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[4], false);
-            renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[5], false);
-        } else if (tConnections == 3) {
-            aBlock.setBlockBounds(0.0F, sp, sp, 1.0F, sp + tThickness, sp + tThickness);
-            aRenderer.setRenderBoundsFromBlock(aBlock);
-            renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[0], false);
-            renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[1], false);
-            renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[2], false);
-            renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[3], false);
-            if (!tIsCovered[4]) {
-                renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[4], false);
-            }
-            if (!tIsCovered[5]) {
-                renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[5], false);
-            }
-        } else if (tConnections == 12) {
-            aBlock.setBlockBounds(sp, 0.0F, sp, sp + tThickness, 1.0F, sp + tThickness);
-            aRenderer.setRenderBoundsFromBlock(aBlock);
-            renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[2], false);
-            renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[3], false);
-            renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[4], false);
-            renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[5], false);
-            if (!tIsCovered[0]) {
-                renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[0], false);
-            }
-            if (!tIsCovered[1]) {
-                renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[1], false);
-            }
-        } else if (tConnections == 48) {
-            aBlock.setBlockBounds(sp, sp, 0.0F, sp + tThickness, sp + tThickness, 1.0F);
-            aRenderer.setRenderBoundsFromBlock(aBlock);
-            renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[0], false);
-            renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[1], false);
-            renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[4], false);
-            renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[5], false);
-            if (!tIsCovered[2]) {
-                renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[2], false);
-            }
-            if (!tIsCovered[3]) {
-                renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[3], false);
-            }
-        } else {
-            if ((tConnections & 0x1) == 0) {
-                aBlock.setBlockBounds(sp, sp, sp, sp + tThickness, sp + tThickness, sp + tThickness);
-                aRenderer.setRenderBoundsFromBlock(aBlock);
-                renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[4], false);
-            } else {
-                aBlock.setBlockBounds(0.0F, sp, sp, sp, sp + tThickness, sp + tThickness);
-                aRenderer.setRenderBoundsFromBlock(aBlock);
-                renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[0], false);
-                renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[1], false);
-                renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[2], false);
-                renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[3], false);
-                if (!tIsCovered[4]) {
-                    renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[4], false);
-                }
-            }
-            if ((tConnections & 0x2) == 0) {
-                aBlock.setBlockBounds(sp, sp, sp, sp + tThickness, sp + tThickness, sp + tThickness);
-                aRenderer.setRenderBoundsFromBlock(aBlock);
-                renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[5], false);
-            } else {
-                aBlock.setBlockBounds(sp + tThickness, sp, sp, 1.0F, sp + tThickness, sp + tThickness);
-                aRenderer.setRenderBoundsFromBlock(aBlock);
-                renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[0], false);
-                renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[1], false);
-                renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[2], false);
-                renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[3], false);
-                if (!tIsCovered[5]) {
-                    renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[5], false);
-                }
-            }
-            if ((tConnections & 0x4) == 0) {
-                aBlock.setBlockBounds(sp, sp, sp, sp + tThickness, sp + tThickness, sp + tThickness);
-                aRenderer.setRenderBoundsFromBlock(aBlock);
-                renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[0], false);
-            } else {
-                aBlock.setBlockBounds(sp, 0.0F, sp, sp + tThickness, sp, sp + tThickness);
-                aRenderer.setRenderBoundsFromBlock(aBlock);
-                renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[2], false);
-                renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[3], false);
-                renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[4], false);
-                renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[5], false);
-                if (!tIsCovered[0]) {
-                    renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[0], false);
-                }
-            }
-            if ((tConnections & 0x8) == 0) {
-                aBlock.setBlockBounds(sp, sp, sp, sp + tThickness, sp + tThickness, sp + tThickness);
-                aRenderer.setRenderBoundsFromBlock(aBlock);
-                renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[1], false);
-            } else {
-                aBlock.setBlockBounds(sp, sp + tThickness, sp, sp + tThickness, 1.0F, sp + tThickness);
-                aRenderer.setRenderBoundsFromBlock(aBlock);
-                renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[2], false);
-                renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[3], false);
-                renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[4], false);
-                renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[5], false);
-                if (!tIsCovered[1]) {
-                    renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[1], false);
-                }
-            }
-            if ((tConnections & 0x10) == 0) {
-                aBlock.setBlockBounds(sp, sp, sp, sp + tThickness, sp + tThickness, sp + tThickness);
-                aRenderer.setRenderBoundsFromBlock(aBlock);
-                renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[2], false);
-            } else {
-                aBlock.setBlockBounds(sp, sp, 0.0F, sp + tThickness, sp + tThickness, sp);
-                aRenderer.setRenderBoundsFromBlock(aBlock);
-                renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[0], false);
-                renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[1], false);
-                renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[4], false);
-                renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[5], false);
-                if (!tIsCovered[2]) {
-                    renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[2], false);
-                }
-            }
-            if ((tConnections & 0x20) == 0) {
-                aBlock.setBlockBounds(sp, sp, sp, sp + tThickness, sp + tThickness, sp + tThickness);
-                aRenderer.setRenderBoundsFromBlock(aBlock);
-                renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[3], false);
-            } else {
-                aBlock.setBlockBounds(sp, sp, sp + tThickness, sp + tThickness, sp + tThickness, 1.0F);
-                aRenderer.setRenderBoundsFromBlock(aBlock);
-                renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[0], false);
-                renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[1], false);
-                renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[4], false);
-                renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[5], false);
-                if (!tIsCovered[3]) {
-                    renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tIcons[3], false);
-                }
-            }
-        }
-        if (tIsCovered[0]) {
-            aBlock.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.125F, 1.0F);
-            aRenderer.setRenderBoundsFromBlock(aBlock);
-            renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[0], false);
-            renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[0], false);
-            if (!tIsCovered[2]) {
-                renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[0], false);
-            }
-            if (!tIsCovered[3]) {
-                renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[0], false);
-            }
-            if (!tIsCovered[4]) {
-                renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[0], false);
-            }
-            if (!tIsCovered[5]) {
-                renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[0], false);
-            }
-        }
-        if (tIsCovered[1]) {
-            aBlock.setBlockBounds(0.0F, 0.875F, 0.0F, 1.0F, 1.0F, 1.0F);
-            aRenderer.setRenderBoundsFromBlock(aBlock);
-            renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[1], false);
-            renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[1], false);
-            if (!tIsCovered[2]) {
-                renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[1], false);
-            }
-            if (!tIsCovered[3]) {
-                renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[1], false);
-            }
-            if (!tIsCovered[4]) {
-                renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[1], false);
-            }
-            if (!tIsCovered[5]) {
-                renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[1], false);
-            }
-        }
-        if (tIsCovered[2]) {
-            aBlock.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 0.125F);
-            aRenderer.setRenderBoundsFromBlock(aBlock);
-            if (!tIsCovered[0]) {
-                renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[2], false);
-            }
-            if (!tIsCovered[1]) {
-                renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[2], false);
-            }
-            renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[2], false);
-            renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[2], false);
-            if (!tIsCovered[4]) {
-                renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[2], false);
-            }
-            if (!tIsCovered[5]) {
-                renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[2], false);
-            }
-        }
-        if (tIsCovered[3]) {
-            aBlock.setBlockBounds(0.0F, 0.0F, 0.875F, 1.0F, 1.0F, 1.0F);
-            aRenderer.setRenderBoundsFromBlock(aBlock);
-            if (!tIsCovered[0]) {
-                renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[3], false);
-            }
-            if (!tIsCovered[1]) {
-                renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[3], false);
-            }
-            renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[3], false);
-            renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[3], false);
-            if (!tIsCovered[4]) {
-                renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[3], false);
-            }
-            if (!tIsCovered[5]) {
-                renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[3], false);
-            }
-        }
-        if (tIsCovered[4]) {
-            aBlock.setBlockBounds(0.0F, 0.0F, 0.0F, 0.125F, 1.0F, 1.0F);
-            aRenderer.setRenderBoundsFromBlock(aBlock);
-            if (!tIsCovered[0]) {
-                renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[4], false);
-            }
-            if (!tIsCovered[1]) {
-                renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[4], false);
-            }
-            if (!tIsCovered[2]) {
-                renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[4], false);
-            }
-            if (!tIsCovered[3]) {
-                renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[4], false);
-            }
-            renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[4], false);
-            renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[4], false);
-        }
-        if (tIsCovered[5]) {
-            aBlock.setBlockBounds(0.875F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
-            aRenderer.setRenderBoundsFromBlock(aBlock);
-            if (!tIsCovered[0]) {
-                renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[5], false);
-            }
-            if (!tIsCovered[1]) {
-                renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[5], false);
-            }
-            if (!tIsCovered[2]) {
-                renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[5], false);
-            }
-            if (!tIsCovered[3]) {
-                renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[5], false);
-            }
-            renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[5], false);
-            renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[5], false);
-        }
-        aBlock.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
-        aRenderer.setRenderBoundsFromBlock(aBlock);
-
-        return true;
-    }
-
-    public static void renderNegativeYFacing(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[] aIcon, boolean aFullBlock) {
-        if (aWorld != null) {
-            if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX, aY - 1, aZ, 0))) {
-                return;
-            }
-            Tessellator.instance.setBrightness(aBlock.getMixedBrightnessForBlock(aWorld, aX, aFullBlock ? aY - 1 : aY, aZ));
-        }
-        if (aIcon != null) {
-            for (int i = 0; i < aIcon.length; i++) {
-                if (aIcon[i] != null) {
-                    aIcon[i].renderYNeg(aRenderer, aBlock, aX, aY, aZ);
-                }
-            }
-        }
-        aRenderer.flipTexture = false;
-    }
-
-    public static void renderPositiveYFacing(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[] aIcon, boolean aFullBlock) {
-        if (aWorld != null) {
-            if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX, aY + 1, aZ, 1))) {
-                return;
-            }
-            Tessellator.instance.setBrightness(aBlock.getMixedBrightnessForBlock(aWorld, aX, aFullBlock ? aY + 1 : aY, aZ));
-        }
-        if (aIcon != null) {
-            for (int i = 0; i < aIcon.length; i++) {
-                if (aIcon[i] != null) {
-                    aIcon[i].renderYPos(aRenderer, aBlock, aX, aY, aZ);
-                }
-            }
-        }
-        aRenderer.flipTexture = false;
-    }
-
-    public static void renderNegativeZFacing(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[] aIcon, boolean aFullBlock) {
-        if (aWorld != null) {
-            if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX, aY, aZ - 1, 2))) {
-                return;
-            }
-            Tessellator.instance.setBrightness(aBlock.getMixedBrightnessForBlock(aWorld, aX, aY, aFullBlock ? aZ - 1 : aZ));
-        }
-        aRenderer.flipTexture = (!aFullBlock);
-        if (aIcon != null) {
-            for (int i = 0; i < aIcon.length; i++) {
-                if (aIcon[i] != null) {
-                    aIcon[i].renderZNeg(aRenderer, aBlock, aX, aY, aZ);
-                }
-            }
-        }
-        aRenderer.flipTexture = false;
-    }
-
-    public static void renderPositiveZFacing(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[] aIcon, boolean aFullBlock) {
-        if (aWorld != null) {
-            if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX, aY, aZ + 1, 3))) {
-                return;
-            }
-            Tessellator.instance.setBrightness(aBlock.getMixedBrightnessForBlock(aWorld, aX, aY, aFullBlock ? aZ + 1 : aZ));
-        }
-        if (aIcon != null) {
-            for (int i = 0; i < aIcon.length; i++) {
-                if (aIcon[i] != null) {
-                    aIcon[i].renderZPos(aRenderer, aBlock, aX, aY, aZ);
-                }
-            }
-        }
-        aRenderer.flipTexture = false;
-    }
-
-    public static void renderNegativeXFacing(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[] aIcon, boolean aFullBlock) {
-        if (aWorld != null) {
-            if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX - 1, aY, aZ, 4))) {
-                return;
-            }
-            Tessellator.instance.setBrightness(aBlock.getMixedBrightnessForBlock(aWorld, aFullBlock ? aX - 1 : aX, aY, aZ));
-        }
-        if (aIcon != null) {
-            for (int i = 0; i < aIcon.length; i++) {
-                if (aIcon[i] != null) {
-                    aIcon[i].renderXNeg(aRenderer, aBlock, aX, aY, aZ);
-                }
-            }
-        }
-        aRenderer.flipTexture = false;
-    }
-
-    public static void renderPositiveXFacing(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[] aIcon, boolean aFullBlock) {
-        if (aWorld != null) {
-            if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX + 1, aY, aZ, 5))) {
-                return;
-            }
-            Tessellator.instance.setBrightness(aBlock.getMixedBrightnessForBlock(aWorld, aFullBlock ? aX + 1 : aX, aY, aZ));
-        }
-        aRenderer.flipTexture = (!aFullBlock);
-        if (aIcon != null) {
-            for (int i = 0; i < aIcon.length; i++) {
-                if (aIcon[i] != null) {
-                    aIcon[i].renderXPos(aRenderer, aBlock, aX, aY, aZ);
-                }
-            }
-        }
-        aRenderer.flipTexture = false;
-    }
-
-    public void renderInventoryBlock(Block aBlock, int aMeta, int aModelID, RenderBlocks aRenderer) {
-        if ((aBlock instanceof GT_Block_Machines)) {
-            if ((aMeta > 0) && (aMeta < GregTech_API.METATILEENTITIES.length) && (GregTech_API.METATILEENTITIES[aMeta] != null) &&
-                    (!GregTech_API.METATILEENTITIES[aMeta].renderInInventory(aBlock, aMeta, aRenderer))) {
-                renderNormalInventoryMetaTileEntity(aBlock, aMeta, aRenderer);
-            }
-        } else if ((aBlock instanceof GT_Block_Ores)) {
-            GT_TileEntity_Ores tTileEntity = new GT_TileEntity_Ores();
-            tTileEntity.mMetaData = ((short) aMeta);
-
-            aBlock.setBlockBoundsForItemRender();
-            aRenderer.setRenderBoundsFromBlock(aBlock);
-
-            GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F);
-            GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
-
-            Tessellator.instance.startDrawingQuads();
-            Tessellator.instance.setNormal(0.0F, -1.0F, 0.0F);
-            renderNegativeYFacing(null, aRenderer, aBlock, 0, 0, 0, tTileEntity.getTexture((byte) 0), true);
-            Tessellator.instance.draw();
-
-            Tessellator.instance.startDrawingQuads();
-            Tessellator.instance.setNormal(0.0F, 1.0F, 0.0F);
-            renderPositiveYFacing(null, aRenderer, aBlock, 0, 0, 0, tTileEntity.getTexture((byte) 1), true);
-            Tessellator.instance.draw();
-
-            Tessellator.instance.startDrawingQuads();
-            Tessellator.instance.setNormal(0.0F, 0.0F, -1.0F);
-            renderNegativeZFacing(null, aRenderer, aBlock, 0, 0, 0, tTileEntity.getTexture((byte) 2), true);
-            Tessellator.instance.draw();
-
-            Tessellator.instance.startDrawingQuads();
-            Tessellator.instance.setNormal(0.0F, 0.0F, 1.0F);
-            renderPositiveZFacing(null, aRenderer, aBlock, 0, 0, 0, tTileEntity.getTexture((byte) 3), true);
-            Tessellator.instance.draw();
-
-            Tessellator.instance.startDrawingQuads();
-            Tessellator.instance.setNormal(-1.0F, 0.0F, 0.0F);
-            renderNegativeXFacing(null, aRenderer, aBlock, 0, 0, 0, tTileEntity.getTexture((byte) 4), true);
-            Tessellator.instance.draw();
-
-            Tessellator.instance.startDrawingQuads();
-            Tessellator.instance.setNormal(1.0F, 0.0F, 0.0F);
-            renderPositiveXFacing(null, aRenderer, aBlock, 0, 0, 0, tTileEntity.getTexture((byte) 5), true);
-            Tessellator.instance.draw();
-        }
-        aBlock.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
-        aRenderer.setRenderBoundsFromBlock(aBlock);
-        GL11.glTranslatef(0.5F, 0.5F, 0.5F);
-    }
-
-    public boolean renderWorldBlock(IBlockAccess aWorld, int aX, int aY, int aZ, Block aBlock, int aModelID, RenderBlocks aRenderer) {
-        TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
-        if (aTileEntity == null) {
-            return false;
-        }
-        if (((aTileEntity instanceof IGregTechTileEntity)) && (((IGregTechTileEntity) aTileEntity).getMetaTileEntity() != null) && (((IGregTechTileEntity) aTileEntity).getMetaTileEntity().renderInWorld(aWorld, aX, aY, aZ, aBlock, aRenderer))) {
-            return true;
-        }
-        if ((aTileEntity instanceof IPipeRenderedTileEntity)) {
-            return renderPipeBlock(aWorld, aX, aY, aZ, aBlock, (IPipeRenderedTileEntity) aTileEntity, aRenderer);
-        }
-        return renderStandardBlock(aWorld, aX, aY, aZ, aBlock, aRenderer);
-    }
-
-    public boolean shouldRender3DInInventory(int aModel) {
-        return true;
-    }
-
-    public int getRenderId() {
-        return this.mRenderID;
-    }
-}
diff --git a/src/main/java/gregtech/common/render/GT_Renderer_Entity_Arrow.java b/src/main/java/gregtech/common/render/GT_Renderer_Entity_Arrow.java
deleted file mode 100644
index ad6993bcd3..0000000000
--- a/src/main/java/gregtech/common/render/GT_Renderer_Entity_Arrow.java
+++ /dev/null
@@ -1,20 +0,0 @@
-package gregtech.common.render;

-

-import cpw.mods.fml.client.registry.RenderingRegistry;

-import net.minecraft.client.renderer.entity.RenderArrow;

-import net.minecraft.entity.Entity;

-import net.minecraft.util.ResourceLocation;

-

-public class GT_Renderer_Entity_Arrow

-        extends RenderArrow {

-    private final ResourceLocation mTexture;

-

-    public GT_Renderer_Entity_Arrow(Class aArrowClass, String aTextureName) {

-        this.mTexture = new ResourceLocation("gregtech:textures/entity/" + aTextureName + ".png");

-        RenderingRegistry.registerEntityRenderingHandler(aArrowClass, this);

-    }

-

-    protected ResourceLocation getEntityTexture(Entity p_110775_1_) {

-        return this.mTexture;

-    }

-}