Merge pull request #65 from GTNewHorizons/unified-build-script2

Move sources and resources

3 files changed, 1270 insertions, 0 deletions

diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/render/GTPP_CapeRenderer.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/render/GTPP_CapeRenderer.java
new file mode 100644
index 0000000000..49537ab559
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/render/GTPP_CapeRenderer.java
@@ -0,0 +1,517 @@
+package gtPlusPlus.xmod.gregtech.common.render;
+
+import java.io.*;
+import java.net.URL;
+import java.util.Date;
+import java.util.List;
+import java.util.UUID;
+
+import org.apache.commons.io.IOUtils;
+import org.lwjgl.opengl.GL11;
+
+import com.mojang.authlib.GameProfile;
+
+import gregtech.api.util.GT_Utility;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.api.objects.data.Pair;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.lib.CORE.ConfigSwitches;
+import gtPlusPlus.core.proxy.ClientProxy;
+import gtPlusPlus.core.util.data.AES;
+import gtPlusPlus.core.util.data.FileUtils;
+import gtPlusPlus.core.util.math.MathUtils;
+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.server.MinecraftServer;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.client.event.RenderPlayerEvent;
+
+public class GTPP_CapeRenderer extends RenderPlayer {
+
+	private static final ResourceLocation[] mCapes = { 
+			new ResourceLocation("miscutils:textures/OrangeHD.png"),
+			new ResourceLocation("miscutils:textures/FancyCapeHD.png"),
+			new ResourceLocation("miscutils:textures/TesterCapeHD.png"),
+			new ResourceLocation("miscutils:textures/PatreonCapeHD.png"),
+			new ResourceLocation("miscutils:textures/DevCapeHD.png"),
+	};
+
+	private final boolean mInit;
+
+	public GTPP_CapeRenderer() {
+		mInit = init();		
+	}
+
+	private final boolean init() {
+		if (mInit) {
+			return false;
+		}
+		return CapeUtils.init();
+	}
+
+	private static boolean hasResourceChecked = false;
+	private static boolean hasSetRenderer = false;
+	private boolean hasCape = false;
+	private ResourceLocation tResource = null;
+
+	public synchronized void receiveRenderSpecialsEvent(RenderPlayerEvent.Specials.Pre aEvent) {
+
+		// Check we have set Render Manager
+		if (this.renderManager == null) {
+			hasSetRenderer = false;
+		}
+
+		// Set Render Manager
+		if (!hasSetRenderer) {
+			if (RenderManager.instance != null) {
+				setRenderManager(RenderManager.instance);
+				hasSetRenderer = true;
+			}
+		}	
+
+		// Actually Render
+		if (hasSetRenderer) {
+
+			// We have capes turned off, so let's not render.
+			if (!ConfigSwitches.enableCustomCapes) {
+				return;
+			}
+
+			// We have already checked if this player has a cape, but since they do not, we best not render.
+			if (hasResourceChecked) {
+				if (!hasCape && !CORE.DEVENV) {
+					return;
+				}
+			}
+
+			// Allocate client player object
+			AbstractClientPlayer aPlayer = (AbstractClientPlayer) aEvent.entityPlayer;
+
+			// Make sure we don't keep checking on clients who dont have capes.
+			if (!hasResourceChecked) {
+
+				// Get players UUID
+				String aPlayerUUID = aPlayer != null ? aPlayer.getGameProfile().getId().toString() : "BAD";
+
+				// If for whatever reason this fails, we just exit early.
+				if (aPlayerUUID.equals("BAD")) {
+					return;
+				}
+
+				// Automatically allocate a Dev cape while in Dev mode.
+				if (tResource == null && CORE.DEVENV) {
+					tResource = mCapes[4];
+					hasCape = true;
+				}
+
+				String aPlayerName = ClientProxy.playerName;
+
+				// Check cape lists for the cape this player owns.	
+				if (!hasCape) {
+					for (Pair<String, String> aData : CapeUtils.mOrangeCapes) {
+						if (aData.getKey().equals(aPlayerUUID) || aPlayerName .equals(aData.getValue())) {
+							tResource = mCapes[0];
+							hasCape = true;
+							break;
+						}
+					}	
+				}
+				if (!hasCape) {		
+					for (Pair<String, String> aData : CapeUtils.mMiscCapes) {
+						if (aData.getKey().equals(aPlayerUUID) || aPlayerName .equals(aData.getValue())) {
+							tResource = mCapes[1];
+							hasCape = true;
+							break;
+						}
+					}	
+				}
+				if (!hasCape) {			
+					for (Pair<String, String> aData : CapeUtils.mBetaTestCapes) {
+						if (aData.getKey().equals(aPlayerUUID) || aPlayerName .equals(aData.getValue())) {
+							tResource = mCapes[2];
+							hasCape = true;
+							break;
+						}
+					}	
+				}
+				if (!hasCape) {			
+					for (Pair<String, String> aData : CapeUtils.mPatreonCapes) {
+						if (aData.getKey().equals(aPlayerUUID) || aPlayerName .equals(aData.getValue())) {
+							tResource = mCapes[3];
+							hasCape = true;
+							break;
+						}
+					}	
+				}
+				if (!hasCape) {			
+					for (Pair<String, String> aData : CapeUtils.mDevCapes) {
+						if (aData.getKey().equals(aPlayerUUID) || aPlayerName .equals(aData.getValue())) {
+							tResource = mCapes[4];
+							hasCape = true;
+							break;
+						}
+					}	
+				}
+				hasResourceChecked = true;
+			}
+
+			if (hasResourceChecked) {
+				// We have met all the conditions, let's render that cape.
+				renderCapeOnPlayer(aEvent, aPlayer);
+			}
+		}
+
+	}
+
+	private final boolean renderCapeOnPlayer(RenderPlayerEvent.Specials.Pre aEvent, AbstractClientPlayer aPlayer) {
+		float aPartialTicks = aEvent.partialRenderTick;
+		try {
+			if (tResource == null && CORE.DEVENV) {
+				tResource = mCapes[3];
+			}
+			
+			// If player is invisible, don't render.
+			if (GT_Utility.getFullInvisibility(aPlayer) || aPlayer.isInvisible()
+					|| GT_Utility.getPotion(aPlayer, Integer.valueOf(Potion.invisibility.id).intValue())) {
+				aEvent.setCanceled(true);
+				return false;
+			}
+
+			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 * CORE.PI / 180.0F);
+				double d4 = -MathHelper.cos(f6 * CORE.PI / 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();
+				return true;
+			}
+		} catch (Throwable e) {
+
+		}
+		return false;
+	}
+
+	@SuppressWarnings("unused")
+	@Deprecated
+	/**
+	 * Should be able to get the username from a UUID
+	 * @param name - Players Name
+	 * @param uuid - Players known UUID
+	 * @return - The newest Player name
+	 */
+	private String getPlayerName(String name, String uuid) {
+		try {
+			Logger.WORLD("[Capes++] Trying to UUID check " + name + ".");
+			if (uuid != null) {
+				if (uuid.length() > 0) {
+					UUID g = UUID.fromString(uuid);
+					if (g != null) {
+						Logger.WORLD("[Capes++] Mojang/Cache checking for " + name + ".");
+						GameProfile profile = MinecraftServer.getServer().func_152358_ax().func_152652_a(g);
+						if (profile != null) {
+							Logger.WARNING("[Capes++] Found for UUID check: " + profile.getName() + ".");
+							return profile.getName();
+						}
+					} else {
+						g = UUID.fromString(uuid.replace("-", ""));
+						if (g != null) {
+							Logger.WORLD("[Capes++] Mojang/Cache checking for " + name + ".");
+							GameProfile profile = MinecraftServer.getServer().func_152358_ax().func_152652_a(g);
+							if (profile != null) {
+								Logger.WARNING("[Capes++] Found for UUID check 2: " + profile.getName() + ".");
+								return profile.getName();
+							}
+						}
+					}
+				}
+			}
+			if (name != null) {
+				if (name.length() > 0) {
+					Logger.WORLD("[Capes++] Mojang/Cache checking for " + name + ".");
+					GameProfile profile = MinecraftServer.getServer().func_152358_ax().func_152655_a(name);
+					if (profile != null) {
+						Logger.WARNING("[Capes++] Found for name check: " + profile.getName() + ".");
+						return profile.getName();
+					}
+				}
+			}
+			Logger.WORLD("[Capes++] Failed UUID check for " + name + ".");
+		} catch (Throwable t) {
+		}
+		return name;
+	}
+
+
+
+	private static class CapeUtils {
+
+		private static char SPLIT_CHARACTER = '§';
+		private static AES sAES;
+
+		// UUID - Username
+		private static final AutoMap<Pair<String, String>> mOrangeCapes = new AutoMap<Pair<String, String>>();
+		private static final AutoMap<Pair<String, String>> mMiscCapes = new AutoMap<Pair<String, String>>();
+		private static final AutoMap<Pair<String, String>> mBetaTestCapes = new AutoMap<Pair<String, String>>();
+		private static final AutoMap<Pair<String, String>> mPatreonCapes = new AutoMap<Pair<String, String>>();
+		private static final AutoMap<Pair<String, String>> mDevCapes = new AutoMap<Pair<String, String>>();
+
+		private static final boolean init() {	
+			CapeUtils.handleOldCapeCache();
+			if (CORE.DEVENV) {
+				return true;
+			}
+			try {
+				if (shouldDownloadCapeList()) {
+					downloadCapeList();
+				}
+			}				
+			catch (Exception e) {
+				return false;
+			}			
+			writeCacheToMaps();
+			return true;
+		}
+
+
+		private static boolean shouldDownloadCapeList() {
+			if (!doesCapeCacheExistLocally()) {
+				return true;
+			}
+			if (isCapeCacheWeekOld()) {
+				return true;
+			}				
+			return false;
+		}
+
+		private static final boolean isCapeCacheWeekOld() {
+			if (!doesCapeCacheExistLocally()) {
+				return true;
+			}
+			else {
+				File dat = CapeUtils.getCapeCache();
+				Date dateLastMod = new Date(dat.lastModified());
+				Date dateNow = new Date(System.currentTimeMillis() - (7l * 24 * 60 * 60 * 1000));
+				if (dateLastMod.before(dateNow)) {
+					return true;
+				}
+			}
+			return false;
+		}
+
+		private static final void downloadCapeList() {
+			try {			
+				File dat = getCapeCache();
+				File temp = allocateTempFile();					
+				InputStream inputStream = new URL("https://alkcorp.overminddl1.com/CapeCache.dat").openStream();
+				FileOutputStream fileOS = new FileOutputStream(temp);
+				IOUtils.copy(inputStream, fileOS);					
+				if (isDownloadedCapeListBigger(temp)) {
+					fileOS = new FileOutputStream(dat);
+					IOUtils.copy(inputStream, fileOS);
+				}
+			} catch (Throwable t) {
+				Logger.INFO("Unable to download GT++ cape list.");
+			}
+		}			
+
+		private static final boolean isDownloadedCapeListBigger(File aFile) {
+			double aExistingFileSize = (doesCapeCacheExistLocally() ? getCapeCache().length() : 0);
+			double aNewFileSize = aFile.length();				
+			if (aNewFileSize > aExistingFileSize) {
+				return true;
+			}				
+			return false;
+		}
+
+		private static void handleOldCapeCache() {				
+			File aCacheFile = FileUtils.getFile("GTPP", "dat");
+			if (FileUtils.doesFileExist(aCacheFile)) {
+				aCacheFile.delete();
+			}				
+		}	
+
+		private static final boolean doesCapeCacheExistLocally() {				
+			File aCacheFile = FileUtils.getFile("CapeCache", "dat");
+			if (FileUtils.doesFileExist(aCacheFile)) {
+				return true;
+			}
+			return false;	
+		}
+
+		private static final File getCapeCache() {				
+			File aCacheFile = FileUtils.getFile("CapeCache", "dat");
+			if (FileUtils.doesFileExist(aCacheFile)) {
+				FileUtils.createFile(aCacheFile);
+			}
+			return aCacheFile;	
+		}
+
+		public static final List<String> getDataFromCache(){
+			File aCacheFile = getCapeCache();
+			List<String> aCache = FileUtils.readLines(aCacheFile);
+			if (aCache != null && !aCache.isEmpty()) {
+				return aCache;
+			}
+			return new AutoMap<String>();		
+		}
+
+		private static final File allocateTempFile() {
+			File tempFile = null;
+			try {
+				tempFile = File.createTempFile("gtpp-", null);
+			}
+			catch (IOException e) {
+				e.printStackTrace();
+			}
+			if (tempFile == null) {
+				tempFile = FileUtils.createFile("", "gtpp-"+MathUtils.randInt(Short.MAX_VALUE, (Integer.MAX_VALUE/2)), "tmp");
+			}
+			tempFile.deleteOnExit();
+			return tempFile;
+		}
+
+
+		public static final void writeCacheToMaps() {
+			List<String> aCacheData = getDataFromCache();
+			if (aCacheData != null && !aCacheData.isEmpty()) {	
+				if (sAES == null) {
+					sAES = new AES();
+				}		
+				AutoMap<String> aDecodedData = new AutoMap<String>();
+				for (String aToDecode : aCacheData) {
+					aDecodedData.put(sAES.decode(aToDecode));
+				}
+				if (!aDecodedData.isEmpty()) {
+					AutoMap<Pair<String, String>> aCapeType1 = new AutoMap<Pair<String, String>>();
+					AutoMap<Pair<String, String>> aCapeType2 = new AutoMap<Pair<String, String>>();
+					AutoMap<Pair<String, String>> aCapeType3 = new AutoMap<Pair<String, String>>();
+					AutoMap<Pair<String, String>> aCapeType4 = new AutoMap<Pair<String, String>>();
+					AutoMap<Pair<String, String>> aCapeType5 = new AutoMap<Pair<String, String>>();
+					boolean didProcessStringData = false;
+					Logger.INFO("Decoded String Count: "+aDecodedData.size());
+					for (String aToSplit : aDecodedData) {
+						String[] aSplitData = aToSplit.split(""+SPLIT_CHARACTER);
+						if (aSplitData != null && aSplitData.length >= 2) {
+							if (aSplitData[0] != null) {
+								Integer aCapeTypeID2 = Integer.parseInt(aSplitData[0]);
+								if (aCapeTypeID2 != null) {
+									int aCapeTypeID = aCapeTypeID2;
+									Pair<String, String> aFinalString = new Pair<String, String>("UUID: "+aSplitData[1], "Username: "+(aSplitData[2] != null && aSplitData[0].length() > 0 ? aSplitData[2] : "Not Specified"));
+									Logger.INFO("Cape Type: "+aCapeTypeID);
+									switch (aCapeTypeID) {
+										case 0:
+											aCapeType1.add(aFinalString);
+											Logger.INFO("Added user to map "+aCapeTypeID+", map now holds "+aCapeType1.size()+" users.");
+											break;
+										case 1:
+											aCapeType2.add(aFinalString);
+											Logger.INFO("Added user to map "+aCapeTypeID+", map now holds "+aCapeType2.size()+" users.");
+											break;
+										case 2:
+											aCapeType3.add(aFinalString);
+											Logger.INFO("Added user to map "+aCapeTypeID+", map now holds "+aCapeType3.size()+" users.");
+											break;
+										case 3:
+											aCapeType4.add(aFinalString);
+											Logger.INFO("Added user to map "+aCapeTypeID+", map now holds "+aCapeType4.size()+" users.");
+											break;
+										case 4:
+											aCapeType5.add(aFinalString);
+											Logger.INFO("Added user to map "+aCapeTypeID+", map now holds "+aCapeType5.size()+" users.");
+											break;
+										default:
+											break;											
+									}
+								}
+							}
+						}
+					}
+					if (!aCapeType1.isEmpty() || !aCapeType2.isEmpty() || !aCapeType3.isEmpty() || !aCapeType4.isEmpty() || !aCapeType5.isEmpty()) {
+						didProcessStringData = true;
+					}	
+					else {
+						// did not process any data
+					}
+					if (didProcessStringData) {
+						if (!aCapeType1.isEmpty()) {
+							for (Pair<String, String> aUser : aCapeType1) {
+								Logger.INFO("Adding Generic cape for "+aUser.getKey());	
+								mOrangeCapes.add(aUser);
+							}
+						}
+						if (!aCapeType2.isEmpty()) {
+							for (Pair<String, String> aUser : aCapeType2) {
+								Logger.INFO("Adding Blue cape for "+aUser.getKey());
+								mMiscCapes.add(aUser);					
+							}
+						}
+						if (!aCapeType3.isEmpty()) {
+							for (Pair<String, String> aUser : aCapeType3) {
+								Logger.INFO("Adding Beta cape for "+aUser.getKey());
+								mBetaTestCapes.add(aUser);				
+							}
+						}
+						if (!aCapeType4.isEmpty()) {
+							for (Pair<String, String> aUser : aCapeType4) {
+								Logger.INFO("Adding Patreon cape for "+aUser.getKey());	
+								mPatreonCapes.add(aUser);			
+							}
+						}
+						if (!aCapeType5.isEmpty()) {
+							for (Pair<String, String> aUser : aCapeType5) {
+								Logger.INFO("Adding Dev cape for "+aUser.getKey());	
+								mDevCapes.add(aUser);			
+							}
+						}
+					}
+				}
+				else {
+					// No data decoded
+				}
+			}
+			else {
+				// Nothing was cached?
+			}
+		}
+	}
+
+
+}
\ No newline at end of file
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/render/GTPP_FlaskRenderer.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/render/GTPP_FlaskRenderer.java
new file mode 100644
index 0000000000..1561ba9f73
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/render/GTPP_FlaskRenderer.java
@@ -0,0 +1,94 @@
+package gtPlusPlus.xmod.gregtech.common.render;
+
+import cpw.mods.fml.relauncher.SideOnly;
+import gregtech.api.enums.ItemList;
+import gregtech.common.items.GT_VolumetricFlask;
+import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList;
+import ic2.core.util.DrawUtil;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.ItemRenderer;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.texture.TextureMap;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+import net.minecraftforge.client.IItemRenderer;
+import net.minecraftforge.client.MinecraftForgeClient;
+import net.minecraftforge.fluids.FluidStack;
+import org.lwjgl.opengl.GL11;
+
+@SideOnly(cpw.mods.fml.relauncher.Side.CLIENT)
+public final class GTPP_FlaskRenderer implements net.minecraftforge.client.IItemRenderer {
+	
+    public GTPP_FlaskRenderer() {
+        MinecraftForgeClient.registerItemRenderer(GregtechItemList.VOLUMETRIC_FLASK_8k.getItem(), this);
+        MinecraftForgeClient.registerItemRenderer(GregtechItemList.VOLUMETRIC_FLASK_32k.getItem(), this);
+    }
+
+    public boolean handleRenderType(ItemStack item, ItemRenderType type) {
+        return type != ItemRenderType.FIRST_PERSON_MAP;
+    }
+
+
+    public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, IItemRenderer.ItemRendererHelper helper) {
+        return type == ItemRenderType.ENTITY;
+    }
+
+    public void renderItem(ItemRenderType type, ItemStack item, Object... data) {
+        GT_VolumetricFlask cell = (GT_VolumetricFlask) item.getItem();
+        
+        int aType = cell.getMaxCapacity() == 8000 ? 0 : 1;
+        IIcon icon = item.getIconIndex();
+        GL11.glEnable(3042);
+        GL11.glEnable(3008);
+        if (type.equals(ItemRenderType.ENTITY)) {
+            GL11.glRotated(180.0D, 0.0D, 0.0D, 1.0D);
+            GL11.glRotated(90.0D, 0.0D, 1.0D, 0.0D);
+            GL11.glTranslated(-0.5D, -0.6D, 0.0D);
+        } else if (type.equals(ItemRenderType.EQUIPPED_FIRST_PERSON)) {
+            GL11.glTranslated(1.0D, 1.0D, 0.0D);
+            GL11.glRotated(180.0D, 0.0D, 0.0D, 1.0D);
+        } else if (type.equals(ItemRenderType.EQUIPPED)) {
+            GL11.glRotated(180.0D, 0.0D, 0.0D, 1.0D);
+            GL11.glTranslated(-1.0D, -1.0D, 0.0D);
+        }
+
+        FluidStack fs = cell.getFluid(item);
+        if (fs != null) {
+            IIcon iconWindow = cell.iconWindow;
+            IIcon fluidicon = fs.getFluid().getIcon(fs);
+            int fluidColor = fs.getFluid().getColor(fs);
+            Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationItemsTexture);
+            GL11.glBlendFunc(0, 1);
+            if (type.equals(ItemRenderType.INVENTORY)) {
+                DrawUtil.renderIcon(iconWindow, 16.0D, 0.0D, 0.0F, 0.0F, -1.0F);
+            } else {
+                DrawUtil.renderIcon(iconWindow, 1.0D, -0.001D, 0.0F, 0.0F, 1.0F);
+                DrawUtil.renderIcon(iconWindow, 1.0D, -0.0615D, 0.0F, 0.0F, -1.0F);
+            }
+
+            Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationBlocksTexture);
+            GL11.glBlendFunc(770, 771);
+            GL11.glDepthFunc(514);
+            GL11.glColor3ub((byte) (fluidColor >> 16), (byte) (fluidColor >> 8), (byte) fluidColor);
+            if (type.equals(ItemRenderType.INVENTORY)) {
+                DrawUtil.renderIcon(fluidicon, 16.0D, 0.0D, 0.0F, 0.0F, -1.0F);
+            } else {
+                DrawUtil.renderIcon(fluidicon, 1.0D, -0.001D, 0.0F, 0.0F, 1.0F);
+                DrawUtil.renderIcon(fluidicon, 1.0D, -0.0615D, 0.0F, 0.0F, -1.0F);
+            }
+
+            GL11.glColor3ub((byte) -1, (byte) -1, (byte) -1);
+            GL11.glDepthFunc(515);
+        }
+
+        Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationItemsTexture);
+        GL11.glBlendFunc(770, 771);
+        if (type.equals(ItemRenderType.INVENTORY)) {
+            DrawUtil.renderIcon(icon, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F);
+        } else {
+            ItemRenderer.renderItemIn2D(Tessellator.instance, icon.getMaxU(), icon.getMinV(), icon.getMinU(), icon.getMaxV(), icon.getIconWidth(), icon.getIconHeight(), 0.0625F);
+        }
+        GL11.glDisable(3008);
+        GL11.glDisable(3042);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/render/GTPP_Render_MachineBlock.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/render/GTPP_Render_MachineBlock.java
new file mode 100644
index 0000000000..35d78008c5
--- /dev/null
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/render/GTPP_Render_MachineBlock.java
@@ -0,0 +1,659 @@
+package gtPlusPlus.xmod.gregtech.common.render;
+
+import org.lwjgl.opengl.GL11;
+
+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.render.GT_Renderer_Block;
+import gtPlusPlus.xmod.gregtech.common.blocks.GTPP_Block_Machines;
+import gtPlusPlus.xmod.gregtech.common.helpers.GT_MethodHelper;
+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;
+
+public class GTPP_Render_MachineBlock extends GT_Renderer_Block {
+	
+	public static GTPP_Render_MachineBlock INSTANCE;
+	public final int mRenderID = RenderingRegistry.getNextAvailableRenderId();
+
+	public GTPP_Render_MachineBlock() {
+		INSTANCE = this;
+		RenderingRegistry.registerBlockHandler(this);
+	}
+	
+	private static ITexture[] getTexture(IMetaTileEntity arg0, int arg1, int arg2, int arg3, boolean arg4, boolean arg5) {
+		IGregTechTileEntity arg0b = arg0.getBaseMetaTileEntity();
+		return arg0.getTexture(arg0b, (byte) arg1, (byte) arg2, (byte) arg3, arg4, arg5);
+	}
+
+	private static void renderNormalInventoryMetaTileEntity(Block aBlock, int aMeta, RenderBlocks aRenderer) {
+		if (aMeta > 0 && aMeta < GregTech_API.METATILEENTITIES.length) {
+			IMetaTileEntity tMetaTileEntity = GregTech_API.METATILEENTITIES[aMeta];
+			if (tMetaTileEntity != null) {
+				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((IBlockAccess) null, aRenderer, aBlock, 0, 0, 0,
+							getTexture(tMetaTileEntity, 0, 9, -1, false, false),
+							true);
+					Tessellator.instance.draw();
+					Tessellator.instance.startDrawingQuads();
+					Tessellator.instance.setNormal(0.0F, 1.0F, 0.0F);
+					renderPositiveYFacing((IBlockAccess) null, aRenderer, aBlock, 0, 0, 0,
+							getTexture(tMetaTileEntity, 1, 9, -1, false, false),
+							true);
+					Tessellator.instance.draw();
+					Tessellator.instance.startDrawingQuads();
+					Tessellator.instance.setNormal(0.0F, 0.0F, -1.0F);
+					renderNegativeZFacing((IBlockAccess) null, aRenderer, aBlock, 0, 0, 0,
+							getTexture(tMetaTileEntity, 2, 9, -1, false, false),
+							true);
+					Tessellator.instance.draw();
+					Tessellator.instance.startDrawingQuads();
+					Tessellator.instance.setNormal(0.0F, 0.0F, 1.0F);
+					renderPositiveZFacing((IBlockAccess) null, aRenderer, aBlock, 0, 0, 0,
+							getTexture(tMetaTileEntity, 3, 9, -1, false, false),
+							true);
+					Tessellator.instance.draw();
+					Tessellator.instance.startDrawingQuads();
+					Tessellator.instance.setNormal(-1.0F, 0.0F, 0.0F);
+					renderNegativeXFacing((IBlockAccess) null, aRenderer, aBlock, 0, 0, 0,
+							getTexture(tMetaTileEntity, 4, 9, -1, true, false),
+							true);
+					Tessellator.instance.draw();
+					Tessellator.instance.startDrawingQuads();
+					Tessellator.instance.setNormal(1.0F, 0.0F, 0.0F);
+					renderPositiveXFacing((IBlockAccess) null, aRenderer, aBlock, 0, 0, 0,
+							getTexture(tMetaTileEntity, 5, 9, -1, true, false),
+							true);
+					Tessellator.instance.draw();
+				} else {
+					Tessellator.instance.startDrawingQuads();
+					Tessellator.instance.setNormal(0.0F, -1.0F, 0.0F);
+					renderNegativeYFacing((IBlockAccess) null, aRenderer, aBlock, 0, 0, 0,
+							getTexture(tMetaTileEntity, 0, 4, -1, true, false),
+							true);
+					Tessellator.instance.draw();
+					Tessellator.instance.startDrawingQuads();
+					Tessellator.instance.setNormal(0.0F, 1.0F, 0.0F);
+					renderPositiveYFacing((IBlockAccess) null, aRenderer, aBlock, 0, 0, 0,
+							getTexture(tMetaTileEntity, 1, 4, -1, true, false),
+							true);
+					Tessellator.instance.draw();
+					Tessellator.instance.startDrawingQuads();
+					Tessellator.instance.setNormal(0.0F, 0.0F, -1.0F);
+					renderNegativeZFacing((IBlockAccess) null, aRenderer, aBlock, 0, 0, 0,
+							getTexture(tMetaTileEntity, 2, 4, -1, true, false),
+							true);
+					Tessellator.instance.draw();
+					Tessellator.instance.startDrawingQuads();
+					Tessellator.instance.setNormal(0.0F, 0.0F, 1.0F);
+					renderPositiveZFacing((IBlockAccess) null, aRenderer, aBlock, 0, 0, 0,
+							getTexture(tMetaTileEntity, 3, 4, -1, true, false),
+							true);
+					Tessellator.instance.draw();
+					Tessellator.instance.startDrawingQuads();
+					Tessellator.instance.setNormal(-1.0F, 0.0F, 0.0F);
+					renderNegativeXFacing((IBlockAccess) null, aRenderer, aBlock, 0, 0, 0,
+							getTexture(tMetaTileEntity, 4, 4, -1, true, false),
+							true);
+					Tessellator.instance.draw();
+					Tessellator.instance.startDrawingQuads();
+					Tessellator.instance.setNormal(1.0F, 0.0F, 0.0F);
+					renderPositiveXFacing((IBlockAccess) null, aRenderer, aBlock, 0, 0, 0,
+							getTexture(tMetaTileEntity, 5, 4, -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);
+				
+		return tTileEntity instanceof ITexturedTileEntity
+				? renderStandardBlock(aWorld, aX, aY, aZ, aBlock, aRenderer,
+						new ITexture[][]{GT_MethodHelper.getTexture(tTileEntity, aBlock, (byte) 0),
+								GT_MethodHelper.getTexture(tTileEntity, aBlock, (byte) 1),
+								GT_MethodHelper.getTexture(tTileEntity, aBlock, (byte) 2),
+								GT_MethodHelper.getTexture(tTileEntity, aBlock, (byte) 3),
+								GT_MethodHelper.getTexture(tTileEntity, aBlock, (byte) 4),
+								GT_MethodHelper.getTexture(tTileEntity, aBlock, (byte) 5)})
+				: 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 & 192) != 0) {
+			return renderStandardBlock(aWorld, aX, aY, aZ, aBlock, aRenderer);
+		} else {
+			float tThickness = aTileEntity.getThickNess();
+			if (tThickness >= 0.99F) {
+				return renderStandardBlock(aWorld, aX, aY, aZ, aBlock, aRenderer);
+			} else {
+				float sp = (1.0F - tThickness) / 2.0F;
+				byte tConnections = 0;
+
+				for (byte tIsCovered = 0; tIsCovered < 6; ++tIsCovered) {
+					if ((aConnections & 1 << tIsCovered) != 0) {
+						tConnections = (byte) (tConnections | 1 << (tIsCovered + 2) % 6);
+					}
+				}
+
+				boolean[] arg14 = new boolean[6];
+
+				for (byte tIcons = 0; tIcons < 6; ++tIcons) {
+					arg14[tIcons] = aTileEntity.getCoverIDAtSide(tIcons) != 0;
+				}
+
+				if (arg14[0] && arg14[1] && arg14[2] && arg14[3] && arg14[4] && arg14[5]) {
+					return renderStandardBlock(aWorld, aX, aY, aZ, aBlock, aRenderer);
+				} else {
+					ITexture[][] arg15 = new ITexture[6][];
+					ITexture[][] tCovers = new ITexture[6][];
+
+					for (byte i = 0; i < 6; ++i) {
+						tCovers[i] = GT_MethodHelper.getTexture((TileEntity) aTileEntity, aBlock, i);
+						arg15[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, arg15[0], false);
+						renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[1], false);
+						renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[2], false);
+						renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[3], false);
+						renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[4], false);
+						renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[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, arg15[0], false);
+						renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[1], false);
+						renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[2], false);
+						renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[3], false);
+						if (!arg14[4]) {
+							renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[4], false);
+						}
+
+						if (!arg14[5]) {
+							renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[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, arg15[2], false);
+						renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[3], false);
+						renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[4], false);
+						renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[5], false);
+						if (!arg14[0]) {
+							renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[0], false);
+						}
+
+						if (!arg14[1]) {
+							renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[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, arg15[0], false);
+						renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[1], false);
+						renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[4], false);
+						renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[5], false);
+						if (!arg14[2]) {
+							renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[2], false);
+						}
+
+						if (!arg14[3]) {
+							renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[3], false);
+						}
+					} else {
+						if ((tConnections & 1) == 0) {
+							aBlock.setBlockBounds(sp, sp, sp, sp + tThickness, sp + tThickness, sp + tThickness);
+							aRenderer.setRenderBoundsFromBlock(aBlock);
+							renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[4], false);
+						} else {
+							aBlock.setBlockBounds(0.0F, sp, sp, sp, sp + tThickness, sp + tThickness);
+							aRenderer.setRenderBoundsFromBlock(aBlock);
+							renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[0], false);
+							renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[1], false);
+							renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[2], false);
+							renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[3], false);
+							if (!arg14[4]) {
+								renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[4], false);
+							}
+						}
+
+						if ((tConnections & 2) == 0) {
+							aBlock.setBlockBounds(sp, sp, sp, sp + tThickness, sp + tThickness, sp + tThickness);
+							aRenderer.setRenderBoundsFromBlock(aBlock);
+							renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[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, arg15[0], false);
+							renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[1], false);
+							renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[2], false);
+							renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[3], false);
+							if (!arg14[5]) {
+								renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[5], false);
+							}
+						}
+
+						if ((tConnections & 4) == 0) {
+							aBlock.setBlockBounds(sp, sp, sp, sp + tThickness, sp + tThickness, sp + tThickness);
+							aRenderer.setRenderBoundsFromBlock(aBlock);
+							renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[0], false);
+						} else {
+							aBlock.setBlockBounds(sp, 0.0F, sp, sp + tThickness, sp, sp + tThickness);
+							aRenderer.setRenderBoundsFromBlock(aBlock);
+							renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[2], false);
+							renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[3], false);
+							renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[4], false);
+							renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[5], false);
+							if (!arg14[0]) {
+								renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[0], false);
+							}
+						}
+
+						if ((tConnections & 8) == 0) {
+							aBlock.setBlockBounds(sp, sp, sp, sp + tThickness, sp + tThickness, sp + tThickness);
+							aRenderer.setRenderBoundsFromBlock(aBlock);
+							renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[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, arg15[2], false);
+							renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[3], false);
+							renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[4], false);
+							renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[5], false);
+							if (!arg14[1]) {
+								renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[1], false);
+							}
+						}
+
+						if ((tConnections & 16) == 0) {
+							aBlock.setBlockBounds(sp, sp, sp, sp + tThickness, sp + tThickness, sp + tThickness);
+							aRenderer.setRenderBoundsFromBlock(aBlock);
+							renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[2], false);
+						} else {
+							aBlock.setBlockBounds(sp, sp, 0.0F, sp + tThickness, sp + tThickness, sp);
+							aRenderer.setRenderBoundsFromBlock(aBlock);
+							renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[0], false);
+							renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[1], false);
+							renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[4], false);
+							renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[5], false);
+							if (!arg14[2]) {
+								renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[2], false);
+							}
+						}
+
+						if ((tConnections & 32) == 0) {
+							aBlock.setBlockBounds(sp, sp, sp, sp + tThickness, sp + tThickness, sp + tThickness);
+							aRenderer.setRenderBoundsFromBlock(aBlock);
+							renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[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, arg15[0], false);
+							renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[1], false);
+							renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[4], false);
+							renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[5], false);
+							if (!arg14[3]) {
+								renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, arg15[3], false);
+							}
+						}
+					}
+
+					if (arg14[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 (!arg14[2]) {
+							renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[0], false);
+						}
+
+						if (!arg14[3]) {
+							renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[0], false);
+						}
+
+						if (!arg14[4]) {
+							renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[0], false);
+						}
+
+						if (!arg14[5]) {
+							renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[0], false);
+						}
+					}
+
+					if (arg14[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 (!arg14[2]) {
+							renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[1], false);
+						}
+
+						if (!arg14[3]) {
+							renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[1], false);
+						}
+
+						if (!arg14[4]) {
+							renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[1], false);
+						}
+
+						if (!arg14[5]) {
+							renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[1], false);
+						}
+					}
+
+					if (arg14[2]) {
+						aBlock.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 0.125F);
+						aRenderer.setRenderBoundsFromBlock(aBlock);
+						if (!arg14[0]) {
+							renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[2], false);
+						}
+
+						if (!arg14[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 (!arg14[4]) {
+							renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[2], false);
+						}
+
+						if (!arg14[5]) {
+							renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[2], false);
+						}
+					}
+
+					if (arg14[3]) {
+						aBlock.setBlockBounds(0.0F, 0.0F, 0.875F, 1.0F, 1.0F, 1.0F);
+						aRenderer.setRenderBoundsFromBlock(aBlock);
+						if (!arg14[0]) {
+							renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[3], false);
+						}
+
+						if (!arg14[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 (!arg14[4]) {
+							renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[3], false);
+						}
+
+						if (!arg14[5]) {
+							renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[3], false);
+						}
+					}
+
+					if (arg14[4]) {
+						aBlock.setBlockBounds(0.0F, 0.0F, 0.0F, 0.125F, 1.0F, 1.0F);
+						aRenderer.setRenderBoundsFromBlock(aBlock);
+						if (!arg14[0]) {
+							renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[4], false);
+						}
+
+						if (!arg14[1]) {
+							renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[4], false);
+						}
+
+						if (!arg14[2]) {
+							renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[4], false);
+						}
+
+						if (!arg14[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 (arg14[5]) {
+						aBlock.setBlockBounds(0.875F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
+						aRenderer.setRenderBoundsFromBlock(aBlock);
+						if (!arg14[0]) {
+							renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[5], false);
+						}
+
+						if (!arg14[1]) {
+							renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[5], false);
+						}
+
+						if (!arg14[2]) {
+							renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tCovers[5], false);
+						}
+
+						if (!arg14[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) {
+		aMeta += 30400;
+		if (aBlock instanceof GT_Block_Machines || aBlock instanceof GTPP_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);
+			}
+		}
+		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);
+		return aTileEntity == null
+				? false
+				: (aTileEntity instanceof IGregTechTileEntity
+						&& ((IGregTechTileEntity) aTileEntity).getMetaTileEntity() != null
+						&& ((IGregTechTileEntity) aTileEntity).getMetaTileEntity().renderInWorld(aWorld, aX, aY, aZ,
+								aBlock, aRenderer)
+										? true
+										: (aTileEntity instanceof IPipeRenderedTileEntity
+												? renderPipeBlock(aWorld, aX, aY, aZ, aBlock,
+														(IPipeRenderedTileEntity) aTileEntity, aRenderer)
+												: renderStandardBlock(aWorld, aX, aY, aZ, aBlock, aRenderer)));
+	}
+
+	public boolean shouldRender3DInInventory(int aModel) {
+		return true;
+	}
+
+	public int getRenderId() {
+		return this.mRenderID;
+	}
+}
\ No newline at end of file