Move source files

6 files changed, 1243 insertions, 0 deletions

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

+

+import gregtech.api.enums.GT_Values;

+import gregtech.api.util.GT_Log;

+import gregtech.api.util.GT_Utility;

+

+import java.util.Collection;

+

+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 net.minecraftforge.client.event.RenderPlayerEvent.Specials.Pre;

+

+import org.lwjgl.opengl.GL11;

+

+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") };

+  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 ((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);

+      }

+    }

+  }

+}

+

+


+/* Location:           F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar


+ * Qualified Name:     gregtech.common.render.GT_CapeRenderer


+ * JD-Core Version:    0.7.0.1


+ */
\ No newline at end of file
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
new file mode 100644
index 0000000000..10e7e9c601
--- /dev/null
+++ b/src/main/java/gregtech/common/render/GT_MetaGenerated_Item_Renderer.java
@@ -0,0 +1,190 @@
+package gregtech.common.render;

+

+import gregtech.api.interfaces.IIconContainer;

+import gregtech.api.items.GT_MetaGenerated_Item;

+import gregtech.api.util.GT_Utility;

+import java.util.Collection;

+import java.util.HashMap;

+import java.util.Iterator;

+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.TextureManager;

+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.IItemRenderer.ItemRenderType;

+import net.minecraftforge.client.IItemRenderer.ItemRendererHelper;

+import net.minecraftforge.client.MinecraftForgeClient;

+import net.minecraftforge.fluids.Fluid;

+import net.minecraftforge.fluids.FluidStack;

+import org.lwjgl.opengl.GL11;

+

+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);

+  }

+}

+

+


+/* Location:           F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar


+ * Qualified Name:     gregtech.common.render.GT_MetaGenerated_Item_Renderer


+ * JD-Core Version:    0.7.0.1


+ */
\ No newline at end of file
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
new file mode 100644
index 0000000000..afb7ff2127
--- /dev/null
+++ b/src/main/java/gregtech/common/render/GT_MetaGenerated_Tool_Renderer.java
@@ -0,0 +1,214 @@
+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 java.util.HashMap;

+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.TextureManager;

+import net.minecraft.item.ItemStack;

+import net.minecraft.util.IIcon;

+import net.minecraftforge.client.IItemRenderer;

+import net.minecraftforge.client.IItemRenderer.ItemRenderType;

+import net.minecraftforge.client.IItemRenderer.ItemRendererHelper;

+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);

+  }

+}

+

+


+/* Location:           F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar


+ * Qualified Name:     gregtech.common.render.GT_MetaGenerated_Tool_Renderer


+ * JD-Core Version:    0.7.0.1


+ */
\ No newline at end of file
diff --git a/src/main/java/gregtech/common/render/GT_RenderUtil.java b/src/main/java/gregtech/common/render/GT_RenderUtil.java
new file mode 100644
index 0000000000..9a2fd8c259
--- /dev/null
+++ b/src/main/java/gregtech/common/render/GT_RenderUtil.java
@@ -0,0 +1,42 @@
+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();

+  }

+}

+

+


+/* Location:           F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar


+ * Qualified Name:     gregtech.common.render.GT_RenderUtil


+ * JD-Core Version:    0.7.0.1


+ */
\ No newline at end of file
diff --git a/src/main/java/gregtech/common/render/GT_Renderer_Block.java b/src/main/java/gregtech/common/render/GT_Renderer_Block.java
new file mode 100644
index 0000000000..b71c5abf97
--- /dev/null
+++ b/src/main/java/gregtech/common/render/GT_Renderer_Block.java
@@ -0,0 +1,657 @@
+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 final int mRenderID;
+  public static GT_Renderer_Block INSTANCE;
+  
+  public GT_Renderer_Block()
+  {
+    this.mRenderID = RenderingRegistry.getNextAvailableRenderId();
+    INSTANCE = this;RenderingRegistry.registerBlockHandler(this);
+  }
+  
+  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);
+  }
+  
+  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 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 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 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
new file mode 100644
index 0000000000..1d42fa065e
--- /dev/null
+++ b/src/main/java/gregtech/common/render/GT_Renderer_Entity_Arrow.java
@@ -0,0 +1,29 @@
+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;

+  }

+}

+

+


+/* Location:           F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar


+ * Qualified Name:     gregtech.common.render.GT_Renderer_Entity_Arrow


+ * JD-Core Version:    0.7.0.1


+ */
\ No newline at end of file