+ Added several new ore materials.

$ Fixed bug where ores generated fluids.
$ Fixed issue where old Fluorite ores still exist.
$ Fixed issue where ore processing recipes were generated incorrectly.
$ Partially implemented smooth lighting on GT++ Ores.

14 files changed, 2248 insertions, 116 deletions

diff --git a/src/Java/gtPlusPlus/GTplusplus.java b/src/Java/gtPlusPlus/GTplusplus.java
index f72d51205a..099c89c47e 100644
--- a/src/Java/gtPlusPlus/GTplusplus.java
+++ b/src/Java/gtPlusPlus/GTplusplus.java
@@ -30,6 +30,7 @@ import gtPlusPlus.core.handler.events.BlockEventHandler;
 import gtPlusPlus.core.handler.events.LoginEventHandler;
 import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.core.material.Material;
+import gtPlusPlus.core.material.nuclear.FLUORIDES;
 import gtPlusPlus.core.util.Utils;
 import gtPlusPlus.core.util.geo.GeoUtils;
 import gtPlusPlus.core.util.item.ItemUtils;
@@ -120,7 +121,7 @@ public class GTplusplus implements ActionListener {
 		Logger.INFO("Setting some Variables for the block break event handler.");
 		BlockEventHandler.oreLimestone = OreDictionary.getOres("oreLimestone");
 		BlockEventHandler.blockLimestone = OreDictionary.getOres("limestone");
-		BlockEventHandler.fluoriteOre = ItemUtils.getSimpleStack(Item.getItemFromBlock(ModBlocks.blockOreFluorite));
+		BlockEventHandler.fluoriteOre = FLUORIDES.FLUORITE.getOre(1);
 
 	}
 
diff --git a/src/Java/gtPlusPlus/GTplusplus_Secondary.java b/src/Java/gtPlusPlus/GTplusplus_Secondary.java
index 0c83df1b5c..6b91729938 100644
--- a/src/Java/gtPlusPlus/GTplusplus_Secondary.java
+++ b/src/Java/gtPlusPlus/GTplusplus_Secondary.java
@@ -73,12 +73,25 @@ public class GTplusplus_Secondary {
 	}
 	
 	public static void GenerateOreMaterials() {
+		//Lot 1
 		MaterialGenerator.generateOreMaterial(ORES.CROCROITE);
 		MaterialGenerator.generateOreMaterial(ORES.GEIKIELITE);
 		MaterialGenerator.generateOreMaterial(ORES.NICHROMITE);
 		MaterialGenerator.generateOreMaterial(ORES.TITANITE);
 		MaterialGenerator.generateOreMaterial(ORES.ZIMBABWEITE);
-		MaterialGenerator.generateOreMaterial(ORES.ZIRCONILITE);		
+		MaterialGenerator.generateOreMaterial(ORES.ZIRCONILITE);
+
+		//Lot 2
+		MaterialGenerator.generateOreMaterial(ORES.GADOLINITE_CE);
+		MaterialGenerator.generateOreMaterial(ORES.GADOLINITE_Y);
+		MaterialGenerator.generateOreMaterial(ORES.LEPERSONNITE);
+		MaterialGenerator.generateOreMaterial(ORES.SAMARSKITE_Y);
+		MaterialGenerator.generateOreMaterial(ORES.SAMARSKITE_YB);
+		MaterialGenerator.generateOreMaterial(ORES.XENOTIME);
+		MaterialGenerator.generateOreMaterial(ORES.YTTRIAITE);
+		MaterialGenerator.generateOreMaterial(ORES.YTTRIALITE);
+		MaterialGenerator.generateOreMaterial(ORES.YTTROCERITE);
+		MaterialGenerator.generateOreMaterial(ORES.ZIRCON);
 	}
 
 	void setVars(){
diff --git a/src/Java/gtPlusPlus/core/block/ModBlocks.java b/src/Java/gtPlusPlus/core/block/ModBlocks.java
index cbd21a8888..24e589ad97 100644
--- a/src/Java/gtPlusPlus/core/block/ModBlocks.java
+++ b/src/Java/gtPlusPlus/core/block/ModBlocks.java
@@ -88,7 +88,7 @@ public final class ModBlocks {
 		blockFirePit = new FirePit();
 		blockFishTrap = new FishTrap();
 		blockInfiniteFLuidTank = new FluidTankInfinite();
-		blockOreFluorite = new BlockBaseOre("oreFluorite", "Fluorite", Material.rock, BlockTypes.ORE, Utils.rgbtoHexValue(120, 120, 30), 3);
+		blockOreFluorite = new BlockBaseOre.oldOreBlock("oreFluorite", "Fluorite", Material.rock, BlockTypes.ORE, Utils.rgbtoHexValue(120, 120, 30), 3);
 		blockMiningExplosive = new MiningExplosives();
 		blockHellfire = new HellFire();
 		blockProjectTable =  new Machine_ProjectTable();
diff --git a/src/Java/gtPlusPlus/core/block/base/BlockBaseModular.java b/src/Java/gtPlusPlus/core/block/base/BlockBaseModular.java
index 9c58e1a930..c2b77ebdae 100644
--- a/src/Java/gtPlusPlus/core/block/base/BlockBaseModular.java
+++ b/src/Java/gtPlusPlus/core/block/base/BlockBaseModular.java
@@ -60,14 +60,6 @@ public class BlockBaseModular extends BasicBlock{
 			LanguageRegistry.addName(this, blockMaterial+ " Frame Box");
 			//Utils.LOG_INFO("Registered Block in Language Registry as: "+blockMaterial+ " Frame Box");
 		}
-		else if (this.thisBlockType.equals(BlockTypes.ORE.name().toUpperCase())){
-			LanguageRegistry.addName(this, blockMaterial+ " Ore");
-			//Utils.LOG_INFO("Registered Block in Language Registry as: "+blockMaterial+ " Frame Box");
-		}
-		else {
-			LanguageRegistry.addName(this, blockMaterial);
-			//Utils.LOG_INFO("Registered Block in Language Registry as: "+blockMaterial);
-		}
 
 		//setOreDict(unlocalizedName, blockType);
 		if (this.thisBlockType.equals(BlockTypes.STANDARD.name().toUpperCase())){
@@ -80,16 +72,6 @@ public class BlockBaseModular extends BasicBlock{
 			GT_OreDictUnificator.registerOre("frameGt"+getUnlocalizedName().replace("tile.", "").replace("tile.BlockGtFrame", "").replace("-", "").replace("_", "").replace(" ", "").replace("FrameBox", ""), ItemUtils.getSimpleStack(this));
 			//Utils.LOG_INFO("Registered Block in Block Registry as: "+blockMaterial+" Frame Box");
 		}
-		else if (this.thisBlockType.equals(BlockTypes.ORE.name().toUpperCase())){
-			GameRegistry.registerBlock(this, ItemBlockGtBlock.class, Utils.sanitizeString(blockType.getTexture()+unlocalizedName));
-			GT_OreDictUnificator.registerOre("block"+getUnlocalizedName().replace("tile.block", "").replace("tile.", "").replace("of", "").replace("Of", "").replace("Block", "").replace("-", "").replace("_", "").replace(" ", ""), ItemUtils.getSimpleStack(this));
-			//Utils.LOG_INFO("Registered Block in Block Registry as: "+blockMaterial+" Frame Box");
-		}
-		else {
-			GameRegistry.registerBlock(this, ItemBlockGtBlock.class, Utils.sanitizeString(blockType.getTexture()+unlocalizedName));
-			GT_OreDictUnificator.registerOre("block"+getUnlocalizedName().replace("tile.block", "").replace("tile.", "").replace("of", "").replace("Of", "").replace("Block", "").replace("-", "").replace("_", "").replace(" ", ""), ItemUtils.getSimpleStack(this));
-			//Utils.LOG_INFO("Registered Block in Block Registry as: "+blockMaterial);
-		}
 
 
 	}
diff --git a/src/Java/gtPlusPlus/core/block/base/BlockBaseOre.java b/src/Java/gtPlusPlus/core/block/base/BlockBaseOre.java
index cb0961eb66..c0847c798d 100644
--- a/src/Java/gtPlusPlus/core/block/base/BlockBaseOre.java
+++ b/src/Java/gtPlusPlus/core/block/base/BlockBaseOre.java
@@ -1,5 +1,9 @@
 package gtPlusPlus.core.block.base;
 
+import cpw.mods.fml.common.registry.GameRegistry;
+import cpw.mods.fml.common.registry.LanguageRegistry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
 import gregtech.api.enums.Materials;
 import gregtech.api.enums.OrePrefixes;
 import gregtech.api.enums.Textures;
@@ -7,10 +11,17 @@ import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.tileentity.ITexturedTileEntity;
 import gregtech.api.objects.GT_CopiedBlockTexture;
 import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_OreDictUnificator;
 import gtPlusPlus.api.objects.Logger;
 import gtPlusPlus.core.client.renderer.CustomOreBlockRenderer;
+import gtPlusPlus.core.item.base.itemblock.ItemBlockGtBlock;
+import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.core.material.Material;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.item.ItemUtils;
+import gtPlusPlus.core.util.math.MathUtils;
 import net.minecraft.block.Block;
+import net.minecraft.client.renderer.texture.IIconRegister;
 import net.minecraft.entity.EnumCreatureType;
 import net.minecraft.init.Blocks;
 import net.minecraft.util.IIcon;
@@ -23,79 +34,54 @@ public class BlockBaseOre extends BlockBaseModular implements ITexturedTileEntit
 	@SuppressWarnings("unused")
 	private IIcon overlay;
 
-	/*@Override
-	public boolean renderAsNormalBlock() {
-		return true;
-	}*/
-
 	protected Material blockMaterial;
 
 	protected int blockColour;
 	protected BlockTypes thisBlock;
-	protected String thisBlockMaterial;
-	protected final String thisBlockType;
 
 	public BlockBaseOre(final Material material, final BlockTypes blockType, final int colour) {
 		this(material.getUnlocalizedName(), material.getLocalizedName(), net.minecraft.block.material.Material.iron, blockType, colour, 3);
 		blockMaterial = material;
 	}
 
-
 	public BlockBaseOre(final String unlocalizedName, final String blockMaterial,  final BlockTypes blockType, final int colour) {
 		this(unlocalizedName, blockMaterial, net.minecraft.block.material.Material.iron, blockType, colour, 2);
 	}
 
 	public BlockBaseOre(final String unlocalizedName, final String blockMaterial, final net.minecraft.block.material.Material vanillaMaterial,  final BlockTypes blockType, final int colour, final int miningLevel) {
 		super(unlocalizedName, blockMaterial, vanillaMaterial, blockType, colour, miningLevel);
+		try {
+		if (blockMaterial == null){
+			Logger.DEBUG_MATERIALS("Failed to generate "+unlocalizedName+" due to invalid material variable.");
+		}
+		
 		this.blockColour = colour;
 		this.thisBlock = blockType;
-		this.thisBlockMaterial = blockMaterial;
-		this.thisBlockType = blockType.name().toUpperCase();
+		
+		if (this == null || this.blockMaterial == null){
+			Logger.DEBUG_MATERIALS("Issue during Ore construction, Material or Block is null.");
+		}
+		
+		GameRegistry.registerBlock(this, ItemBlockGtBlock.class, Utils.sanitizeString("ore"+Utils.sanitizeString(this.blockMaterial.getLocalizedName())));
+		GT_OreDictUnificator.registerOre("ore"+Utils.sanitizeString(this.blockMaterial.getLocalizedName()), ItemUtils.getSimpleStack(this));
+		LanguageRegistry.addName(this, blockMaterial+ " Ore");
+		}
+		catch (Throwable t){
+			t.printStackTrace();
+		}
 	}
 
 	/**
 	 * Returns which pass should this block be rendered on. 0 for solids and 1 for alpha
 	 */
 
-	/*@Override
+	@Override
 	@SideOnly(Side.CLIENT)
-	public int getRenderBlockPass()
-	{
+	public int getRenderBlockPass(){
 		return 0;
-	}	*/
-
-	/*@Override
-	public boolean isOpaqueCube()
-    {
-	    return true;
-    }*/
-
-	/*@Override
-	@SideOnly(Side.CLIENT)
-	public void registerBlockIcons(final IIconRegister iIcon)
-	{
-		this.blockIcon = iIcon.registerIcon(CORE.MODID + ":" + this.thisBlock.getTexture());
-		//this.base = iIcon.registerIcon(CORE.MODID + ":" + "blockStone");
-		//this.overlay = iIcon.registerIcon(CORE.MODID + ":" + "blockOre_Overlay");
-	}*/
-
-	/*@Override
-	public int colorMultiplier(final IBlockAccess par1IBlockAccess, final int par2, final int par3, final int par4){
-		if (this.blockColour == 0){
-			return MathUtils.generateSingularRandomHexValue();
-		}
-		return this.blockColour;
 	}
 
 	@Override
-	public int getRenderColor(final int aMeta) {
-		if (this.blockColour == 0){
-			return MathUtils.generateSingularRandomHexValue();
-		}
-		return this.blockColour;
-	}*/
-
-	@Override
 	public boolean canCreatureSpawn(final EnumCreatureType type, final IBlockAccess world, final int x, final int y, final int z) {
 		return false;
 	}
@@ -131,6 +117,90 @@ public class BlockBaseOre extends BlockBaseModular implements ITexturedTileEntit
 		return new ITexture[]{new GT_RenderedTexture(Textures.BlockIcons.STONES[0], new short[]{240, 240, 240, 0})};			
 	}
 
+	public static class oldOreBlock extends BlockBaseModular{
+		@SuppressWarnings("unused")
+		private IIcon base;
+		@SuppressWarnings("unused")
+		private IIcon overlay;
+
+		protected Material blockMaterial;
+
+		protected int blockColour;
+		protected BlockTypes thisBlock;
+		protected String thisBlockMaterial;
+		protected final String thisBlockType;
+
+		public oldOreBlock(final Material material, final BlockTypes blockType, final int colour) {
+			this(material.getUnlocalizedName(), material.getLocalizedName(), net.minecraft.block.material.Material.iron, blockType, colour, 3);
+			blockMaterial = material;
+		}
+
+		public oldOreBlock(final String unlocalizedName, final String blockMaterial,  final BlockTypes blockType, final int colour) {
+			this(unlocalizedName, blockMaterial, net.minecraft.block.material.Material.iron, blockType, colour, 2);
+		}
+
+		public oldOreBlock(final String unlocalizedName, final String blockMaterial, final net.minecraft.block.material.Material vanillaMaterial,  final BlockTypes blockType, final int colour, final int miningLevel) {
+			super(unlocalizedName, blockMaterial, vanillaMaterial, blockType, colour, miningLevel);
+			this.blockColour = colour;
+			this.thisBlock = blockType;
+			this.thisBlockMaterial = blockMaterial;
+			this.thisBlockType = blockType.name().toUpperCase();
+			this.setBlockTextureName(CORE.MODID+":"+blockType.getTexture());
+		}
 
+		/**
+		 * Returns which pass should this block be rendered on. 0 for solids and 1 for alpha
+		 */
+
+		@Override
+		@SideOnly(Side.CLIENT)
+		public int getRenderBlockPass(){
+			return 0;
+		}
+
+		@Override
+		public boolean canCreatureSpawn(final EnumCreatureType type, final IBlockAccess world, final int x, final int y, final int z) {
+			return false;
+		}
+
+		@Override
+		public int getRenderType() {
+			return 0;
+		}
+
+		@Override
+		public IIcon getIcon(IBlockAccess aIBlockAccess, int aX, int aY, int aZ, int aSide) {
+			return Blocks.stone.getIcon(0, 0);
+		}
+
+		@Override
+		public IIcon getIcon(int aSide, int aMeta) {
+			return Blocks.stone.getIcon(0, 0);
+		}
+
+		@Override
+		@SideOnly(Side.CLIENT)
+		public void registerBlockIcons(final IIconRegister iIcon)
+		{
+			this.blockIcon = iIcon.registerIcon(CORE.MODID + ":" + this.thisBlock.getTexture());
+		}
+
+		@Override
+		public int colorMultiplier(final IBlockAccess par1IBlockAccess, final int par2, final int par3, final int par4){
+			if (this.blockColour == 0){
+				return MathUtils.generateSingularRandomHexValue();
+			}
+			return this.blockColour;
+		}
+
+		@Override
+		public int getRenderColor(final int aMeta) {
+			if (this.blockColour == 0){
+				return MathUtils.generateSingularRandomHexValue();
+			}
+			return this.blockColour;
+		}
+
+	}
 
 }
diff --git a/src/Java/gtPlusPlus/core/client/renderer/CustomOreBlockRenderer.java b/src/Java/gtPlusPlus/core/client/renderer/CustomOreBlockRenderer.java
index 0c94cfe993..d517bdfae3 100644
--- a/src/Java/gtPlusPlus/core/client/renderer/CustomOreBlockRenderer.java
+++ b/src/Java/gtPlusPlus/core/client/renderer/CustomOreBlockRenderer.java
@@ -8,12 +8,14 @@ import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.tileentity.ITexturedTileEntity;
 import gtPlusPlus.api.objects.Logger;
 import net.minecraft.block.Block;
+import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.RenderBlocks;
 import net.minecraft.client.renderer.Tessellator;
-import net.minecraft.tileentity.TileEntity;
+import net.minecraft.client.renderer.texture.TextureMap;
+import net.minecraft.util.IIcon;
 import net.minecraft.world.IBlockAccess;
 
-public class CustomOreBlockRenderer implements ISimpleBlockRenderingHandler{
+public class CustomOreBlockRenderer implements ISimpleBlockRenderingHandler {
 
 	public static CustomOreBlockRenderer INSTANCE;
 	public final int mRenderID;
@@ -25,7 +27,7 @@ public class CustomOreBlockRenderer implements ISimpleBlockRenderingHandler{
 		Logger.INFO("Registered Custom Ore Block Renderer.");
 	}
 
-	public static boolean renderStandardBlock(IBlockAccess aWorld, int aX, int aY, int aZ, Block aBlock, RenderBlocks aRenderer) {
+	public boolean renderStandardBlock(IBlockAccess aWorld, int aX, int aY, int aZ, Block aBlock, RenderBlocks aRenderer) {
 		Block tTileEntity = aBlock;
 		if ((tTileEntity instanceof ITexturedTileEntity)) {
 			return renderStandardBlock(aWorld, aX, aY, aZ, aBlock, aRenderer, new ITexture[][]{((ITexturedTileEntity) tTileEntity).getTexture(aBlock, (byte) 0), ((ITexturedTileEntity) tTileEntity).getTexture(aBlock, (byte) 1), ((ITexturedTileEntity) tTileEntity).getTexture(aBlock, (byte) 2), ((ITexturedTileEntity) tTileEntity).getTexture(aBlock, (byte) 3), ((ITexturedTileEntity) tTileEntity).getTexture(aBlock, (byte) 4), ((ITexturedTileEntity) tTileEntity).getTexture(aBlock, (byte) 5)});
@@ -33,19 +35,52 @@ public class CustomOreBlockRenderer implements ISimpleBlockRenderingHandler{
 		return false;
 	}
 
-	public static boolean renderStandardBlock(IBlockAccess aWorld, int aX, int aY, int aZ, Block aBlock, RenderBlocks aRenderer, ITexture[][] aTextures) {
+	public 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);
+		int l = aBlock.colorMultiplier(aWorld, aX, aY, aZ);
+        float RED = (float)(l >> 16 & 255) / 255.0F;
+        float GREEN = (float)(l >> 8 & 255) / 255.0F;
+        float BLUE = (float)(l & 255) / 255.0F;
+		
+		if (Minecraft.isAmbientOcclusionEnabled() && aBlock.getLightValue() == 0){
+			if (RenderBlocks.getInstance().partialRenderBounds){
+				return INSTANCE.renderStandardBlockWithAmbientOcclusionPartial(aWorld, aRenderer, aTextures, aBlock, aX, aY, aZ, RED, GREEN, BLUE);
+			}
+			else {
+				return INSTANCE.renderStandardBlockWithAmbientOcclusion(aWorld, aRenderer, aTextures, aBlock, aX, aY, aZ, RED, GREEN, BLUE);
+			}
+		}
+		else {
+			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 void renderFaceYNeg(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[][] aIcon) {
+		renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, aIcon[0], true);
+	}
+	public static void renderFaceYPos(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[][] aIcon) {
+		renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, aIcon[1], true);
+	}
+	public static void renderFaceZNeg(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[][] aIcon) {
+		renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, aIcon[2], true);
+	}
+	public static void renderFaceZPos(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[][] aIcon) {
+		renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, aIcon[3], true);
+	}
+	public static void renderFaceXNeg(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[][] aIcon) {
+		renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, aIcon[4], true);
+	}
+	public static void renderFaceXPos(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[][] aIcon) {
+		renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, aIcon[5], 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))) {
@@ -185,6 +220,7 @@ public class CustomOreBlockRenderer implements ISimpleBlockRenderingHandler{
 	}
 
 	public boolean renderWorldBlock(IBlockAccess aWorld, int aX, int aY, int aZ, Block aBlock, int aModelID, RenderBlocks aRenderer) {
+		blockAccess = aWorld;
 		return renderStandardBlock(aWorld, aX, aY, aZ, aBlock, aRenderer);
 	}
 
@@ -195,5 +231,1853 @@ public class CustomOreBlockRenderer implements ISimpleBlockRenderingHandler{
 	public int getRenderId() {
 		return this.mRenderID;
 	}
+	
+	public void setRenderBounds(double p_147782_1_, double p_147782_3_, double p_147782_5_, double p_147782_7_, double p_147782_9_, double p_147782_11_)
+	{
+		if (!this.lockBlockBounds)
+		{
+			this.renderMinX = p_147782_1_;
+			this.renderMaxX = p_147782_7_;
+			this.renderMinY = p_147782_3_;
+			this.renderMaxY = p_147782_9_;
+			this.renderMinZ = p_147782_5_;
+			this.renderMaxZ = p_147782_11_;
+			this.partialRenderBounds = this.minecraftRB.gameSettings.ambientOcclusion >= 2 && (this.renderMinX > 0.0D || this.renderMaxX < 1.0D || this.renderMinY > 0.0D || this.renderMaxY < 1.0D || this.renderMinZ > 0.0D || this.renderMaxZ < 1.0D);
+		}
+	}
+
+	/**
+	 * Like setRenderBounds, but automatically pulling the bounds from the given Block.
+	 */
+	public void setRenderBoundsFromBlock(Block block)
+	{
+		if (!this.lockBlockBounds)
+		{
+			this.renderMinX = block.getBlockBoundsMinX();
+			this.renderMaxX = block.getBlockBoundsMaxX();
+			this.renderMinY = block.getBlockBoundsMinY();
+			this.renderMaxY = block.getBlockBoundsMaxY();
+			this.renderMinZ = block.getBlockBoundsMinZ();
+			this.renderMaxZ = block.getBlockBoundsMaxZ();
+			this.partialRenderBounds = this.minecraftRB.gameSettings.ambientOcclusion >= 2 && (this.renderMinX > 0.0D || this.renderMaxX < 1.0D || this.renderMinY > 0.0D || this.renderMaxY < 1.0D || this.renderMinZ > 0.0D || this.renderMaxZ < 1.0D);
+		}
+	}
+
+	/**
+	 * Vanilla Variables
+	 */
+
+	/** The minimum X value for rendering (default 0.0). */
+	public double renderMinX;
+	/** The maximum X value for rendering (default 1.0). */
+	public double renderMaxX;
+	/** The minimum Y value for rendering (default 0.0). */
+	public double renderMinY;
+	/** The maximum Y value for rendering (default 1.0). */
+	public double renderMaxY;
+	/** The minimum Z value for rendering (default 0.0). */
+	public double renderMinZ;
+	/** The maximum Z value for rendering (default 1.0). */
+	public double renderMaxZ;
+	public boolean lockBlockBounds;
+	public boolean partialRenderBounds;
+	public final Minecraft minecraftRB = RenderBlocks.getInstance().minecraftRB;
+	public int uvRotateEast;
+	public int uvRotateWest;
+	public int uvRotateSouth;
+	public int uvRotateNorth;
+	public int uvRotateTop;
+	public int uvRotateBottom;
+	/** Whether ambient occlusion is enabled or not */
+	public boolean enableAO;
+	/** Used as a scratch variable for ambient occlusion on the north/bottom/east corner. */
+	public float aoLightValueScratchXYZNNN;
+	/** Used as a scratch variable for ambient occlusion between the bottom face and the north face. */
+	public float aoLightValueScratchXYNN;
+	/** Used as a scratch variable for ambient occlusion on the north/bottom/west corner. */
+	public float aoLightValueScratchXYZNNP;
+	/** Used as a scratch variable for ambient occlusion between the bottom face and the east face. */
+	public float aoLightValueScratchYZNN;
+	/** Used as a scratch variable for ambient occlusion between the bottom face and the west face. */
+	public float aoLightValueScratchYZNP;
+	/** Used as a scratch variable for ambient occlusion on the south/bottom/east corner. */
+	public float aoLightValueScratchXYZPNN;
+	/** Used as a scratch variable for ambient occlusion between the bottom face and the south face. */
+	public float aoLightValueScratchXYPN;
+	/** Used as a scratch variable for ambient occlusion on the south/bottom/west corner. */
+	public float aoLightValueScratchXYZPNP;
+	/** Used as a scratch variable for ambient occlusion on the north/top/east corner. */
+	public float aoLightValueScratchXYZNPN;
+	/** Used as a scratch variable for ambient occlusion between the top face and the north face. */
+	public float aoLightValueScratchXYNP;
+	/** Used as a scratch variable for ambient occlusion on the north/top/west corner. */
+	public float aoLightValueScratchXYZNPP;
+	/** Used as a scratch variable for ambient occlusion between the top face and the east face. */
+	public float aoLightValueScratchYZPN;
+	/** Used as a scratch variable for ambient occlusion on the south/top/east corner. */
+	public float aoLightValueScratchXYZPPN;
+	/** Used as a scratch variable for ambient occlusion between the top face and the south face. */
+	public float aoLightValueScratchXYPP;
+	/** Used as a scratch variable for ambient occlusion between the top face and the west face. */
+	public float aoLightValueScratchYZPP;
+	/** Used as a scratch variable for ambient occlusion on the south/top/west corner. */
+	public float aoLightValueScratchXYZPPP;
+	/** Used as a scratch variable for ambient occlusion between the north face and the east face. */
+	public float aoLightValueScratchXZNN;
+	/** Used as a scratch variable for ambient occlusion between the south face and the east face. */
+	public float aoLightValueScratchXZPN;
+	/** Used as a scratch variable for ambient occlusion between the north face and the west face. */
+	public float aoLightValueScratchXZNP;
+	/** Used as a scratch variable for ambient occlusion between the south face and the west face. */
+	public float aoLightValueScratchXZPP;
+	/** Ambient occlusion brightness XYZNNN */
+	public int aoBrightnessXYZNNN;
+	/** Ambient occlusion brightness XYNN */
+	public int aoBrightnessXYNN;
+	/** Ambient occlusion brightness XYZNNP */
+	public int aoBrightnessXYZNNP;
+	/** Ambient occlusion brightness YZNN */
+	public int aoBrightnessYZNN;
+	/** Ambient occlusion brightness YZNP */
+	public int aoBrightnessYZNP;
+	/** Ambient occlusion brightness XYZPNN */
+	public int aoBrightnessXYZPNN;
+	/** Ambient occlusion brightness XYPN */
+	public int aoBrightnessXYPN;
+	/** Ambient occlusion brightness XYZPNP */
+	public int aoBrightnessXYZPNP;
+	/** Ambient occlusion brightness XYZNPN */
+	public int aoBrightnessXYZNPN;
+	/** Ambient occlusion brightness XYNP */
+	public int aoBrightnessXYNP;
+	/** Ambient occlusion brightness XYZNPP */
+	public int aoBrightnessXYZNPP;
+	/** Ambient occlusion brightness YZPN */
+	public int aoBrightnessYZPN;
+	/** Ambient occlusion brightness XYZPPN */
+	public int aoBrightnessXYZPPN;
+	/** Ambient occlusion brightness XYPP */
+	public int aoBrightnessXYPP;
+	/** Ambient occlusion brightness YZPP */
+	public int aoBrightnessYZPP;
+	/** Ambient occlusion brightness XYZPPP */
+	public int aoBrightnessXYZPPP;
+	/** Ambient occlusion brightness XZNN */
+	public int aoBrightnessXZNN;
+	/** Ambient occlusion brightness XZPN */
+	public int aoBrightnessXZPN;
+	/** Ambient occlusion brightness XZNP */
+	public int aoBrightnessXZNP;
+	/** Ambient occlusion brightness XZPP */
+	public int aoBrightnessXZPP;
+	/** Brightness top left */
+	public int brightnessTopLeft;
+	/** Brightness bottom left */
+	public int brightnessBottomLeft;
+	/** Brightness bottom right */
+	public int brightnessBottomRight;
+	/** Brightness top right */
+	public int brightnessTopRight;
+	/** Red color value for the top left corner */
+	public float colorRedTopLeft;
+	/** Red color value for the bottom left corner */
+	public float colorRedBottomLeft;
+	/** Red color value for the bottom right corner */
+	public float colorRedBottomRight;
+	/** Red color value for the top right corner */
+	public float colorRedTopRight;
+	/** Green color value for the top left corner */
+	public float colorGreenTopLeft;
+	/** Green color value for the bottom left corner */
+	public float colorGreenBottomLeft;
+	/** Green color value for the bottom right corner */
+	public float colorGreenBottomRight;
+	/** Green color value for the top right corner */
+	public float colorGreenTopRight;
+	/** Blue color value for the top left corner */
+	public float colorBlueTopLeft;
+	/** Blue color value for the bottom left corner */
+	public float colorBlueBottomLeft;
+	/** Blue color value for the bottom right corner */
+	public float colorBlueBottomRight;
+	/** Blue color value for the top right corner */
+	public float colorBlueTopRight;
+	/** If set to >=0, all block faces will be rendered using this texture index */
+	public IIcon overrideBlockTexture;
+	/**
+	 * Clear override block texture
+	 */
+	public void clearOverrideBlockTexture()
+	{
+		this.overrideBlockTexture = null;
+	}
+
+	public boolean hasOverrideBlockTexture()
+	{
+		return this.overrideBlockTexture != null;
+	}
+
+	public IIcon getBlockIcon(Block block, IBlockAccess access, int x, int y, int z, int side)
+	{
+		return this.getIconSafe(block.getIcon(access, x, y, z, side));
+	}
+
+	public IIcon getBlockIconFromSideAndMetadata(Block block, int side, int meta)
+	{
+		return this.getIconSafe(block.getIcon(side, meta));
+	}
+
+	public IIcon getBlockIconFromSide(Block block, int side)
+	{
+		return this.getIconSafe(block.getBlockTextureFromSide(side));
+	}
+
+	public IIcon getBlockIcon(Block block)
+	{
+		return this.getIconSafe(block.getBlockTextureFromSide(1));
+	}
+
+	public IIcon getIconSafe(IIcon iicon)
+	{
+		if (iicon == null)
+		{
+			iicon = ((TextureMap) Minecraft.getMinecraft().getTextureManager().getTexture(TextureMap.locationBlocksTexture)).getAtlasSprite("missingno");
+		}
+
+		return (IIcon)iicon;
+	}
+
+	IBlockAccess blockAccess = RenderBlocks.getInstance().blockAccess;
+	
+	public boolean renderStandardBlockWithAmbientOcclusion(IBlockAccess aWorld, RenderBlocks aRenderer, ITexture[][] aTextures, Block block, int xPos, int yPos, int zPos, float R, float G, float B)
+	{
+        this.enableAO = true;
+        boolean flag = false;
+        float f3 = 0.0F;
+        float f4 = 0.0F;
+        float f5 = 0.0F;
+        float f6 = 0.0F;
+        boolean flag1 = true;
+        int l = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos, zPos);
+        Tessellator tessellator = Tessellator.instance;
+        tessellator.setBrightness(983055);
+
+        if (this.getBlockIcon(block).getIconName().equals("grass_top"))
+        {
+            flag1 = false;
+        }
+        else if (this.hasOverrideBlockTexture())
+        {
+            flag1 = false;
+        }
+
+        boolean flag2;
+        boolean flag3;
+        boolean flag4;
+        boolean flag5;
+        int i1;
+        float f7;
+
+        if (RenderBlocks.getInstance().renderAllFaces || block.shouldSideBeRendered(blockAccess, xPos, yPos - 1, zPos, 0))
+        {
+            if (this.renderMinY <= 0.0D)
+            {
+                --yPos;
+            }
+
+            this.aoBrightnessXYNN = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos, zPos);
+            this.aoBrightnessYZNN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos, zPos - 1);
+            this.aoBrightnessYZNP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos, zPos + 1);
+            this.aoBrightnessXYPN = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos, zPos);
+            this.aoLightValueScratchXYNN = blockAccess.getBlock(xPos - 1, yPos, zPos).getAmbientOcclusionLightValue();
+            this.aoLightValueScratchYZNN = blockAccess.getBlock(xPos, yPos, zPos - 1).getAmbientOcclusionLightValue();
+            this.aoLightValueScratchYZNP = blockAccess.getBlock(xPos, yPos, zPos + 1).getAmbientOcclusionLightValue();
+            this.aoLightValueScratchXYPN = blockAccess.getBlock(xPos + 1, yPos, zPos).getAmbientOcclusionLightValue();
+            flag2 = blockAccess.getBlock(xPos + 1, yPos - 1, zPos).getCanBlockGrass();
+            flag3 = blockAccess.getBlock(xPos - 1, yPos - 1, zPos).getCanBlockGrass();
+            flag4 = blockAccess.getBlock(xPos, yPos - 1, zPos + 1).getCanBlockGrass();
+            flag5 = blockAccess.getBlock(xPos, yPos - 1, zPos - 1).getCanBlockGrass();
+
+            if (!flag5 && !flag3)
+            {
+                this.aoLightValueScratchXYZNNN = this.aoLightValueScratchXYNN;
+                this.aoBrightnessXYZNNN = this.aoBrightnessXYNN;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZNNN = blockAccess.getBlock(xPos - 1, yPos, zPos - 1).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZNNN = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos, zPos - 1);
+            }
+
+            if (!flag4 && !flag3)
+            {
+                this.aoLightValueScratchXYZNNP = this.aoLightValueScratchXYNN;
+                this.aoBrightnessXYZNNP = this.aoBrightnessXYNN;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZNNP = blockAccess.getBlock(xPos - 1, yPos, zPos + 1).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZNNP = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos, zPos + 1);
+            }
+
+            if (!flag5 && !flag2)
+            {
+                this.aoLightValueScratchXYZPNN = this.aoLightValueScratchXYPN;
+                this.aoBrightnessXYZPNN = this.aoBrightnessXYPN;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZPNN = blockAccess.getBlock(xPos + 1, yPos, zPos - 1).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZPNN = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos, zPos - 1);
+            }
+
+            if (!flag4 && !flag2)
+            {
+                this.aoLightValueScratchXYZPNP = this.aoLightValueScratchXYPN;
+                this.aoBrightnessXYZPNP = this.aoBrightnessXYPN;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZPNP = blockAccess.getBlock(xPos + 1, yPos, zPos + 1).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZPNP = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos, zPos + 1);
+            }
+
+            if (this.renderMinY <= 0.0D)
+            {
+                ++yPos;
+            }
+
+            i1 = l;
+
+            if (this.renderMinY <= 0.0D || !blockAccess.getBlock(xPos, yPos - 1, zPos).isOpaqueCube())
+            {
+                i1 = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos - 1, zPos);
+            }
+
+            f7 = blockAccess.getBlock(xPos, yPos - 1, zPos).getAmbientOcclusionLightValue();
+            f3 = (this.aoLightValueScratchXYZNNP + this.aoLightValueScratchXYNN + this.aoLightValueScratchYZNP + f7) / 4.0F;
+            f6 = (this.aoLightValueScratchYZNP + f7 + this.aoLightValueScratchXYZPNP + this.aoLightValueScratchXYPN) / 4.0F;
+            f5 = (f7 + this.aoLightValueScratchYZNN + this.aoLightValueScratchXYPN + this.aoLightValueScratchXYZPNN) / 4.0F;
+            f4 = (this.aoLightValueScratchXYNN + this.aoLightValueScratchXYZNNN + f7 + this.aoLightValueScratchYZNN) / 4.0F;
+            this.brightnessTopLeft = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXYZNNP, this.aoBrightnessXYNN, this.aoBrightnessYZNP, i1);
+            this.brightnessTopRight = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessYZNP, this.aoBrightnessXYZPNP, this.aoBrightnessXYPN, i1);
+            this.brightnessBottomRight = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessYZNN, this.aoBrightnessXYPN, this.aoBrightnessXYZPNN, i1);
+            this.brightnessBottomLeft = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXYNN, this.aoBrightnessXYZNNN, this.aoBrightnessYZNN, i1);
+
+            if (flag1)
+            {
+                this.colorRedTopLeft = this.colorRedBottomLeft = this.colorRedBottomRight = this.colorRedTopRight = R * 0.5F;
+                this.colorGreenTopLeft = this.colorGreenBottomLeft = this.colorGreenBottomRight = this.colorGreenTopRight = G * 0.5F;
+                this.colorBlueTopLeft = this.colorBlueBottomLeft = this.colorBlueBottomRight = this.colorBlueTopRight = B * 0.5F;
+            }
+            else
+            {
+                this.colorRedTopLeft = this.colorRedBottomLeft = this.colorRedBottomRight = this.colorRedTopRight = 0.5F;
+                this.colorGreenTopLeft = this.colorGreenBottomLeft = this.colorGreenBottomRight = this.colorGreenTopRight = 0.5F;
+                this.colorBlueTopLeft = this.colorBlueBottomLeft = this.colorBlueBottomRight = this.colorBlueTopRight = 0.5F;
+            }
+
+            this.colorRedTopLeft *= f3;
+            this.colorGreenTopLeft *= f3;
+            this.colorBlueTopLeft *= f3;
+            this.colorRedBottomLeft *= f4;
+            this.colorGreenBottomLeft *= f4;
+            this.colorBlueBottomLeft *= f4;
+            this.colorRedBottomRight *= f5;
+            this.colorGreenBottomRight *= f5;
+            this.colorBlueBottomRight *= f5;
+            this.colorRedTopRight *= f6;
+            this.colorGreenTopRight *= f6;
+            this.colorBlueTopRight *= f6;
+            CustomOreBlockRenderer.renderFaceYNeg(aWorld, aRenderer, block, xPos, yPos, zPos, aTextures);
+            flag = true;
+        }
+
+        if (RenderBlocks.getInstance().renderAllFaces || block.shouldSideBeRendered(blockAccess, xPos, yPos + 1, zPos, 1))
+        {
+            if (this.renderMaxY >= 1.0D)
+            {
+                ++yPos;
+            }
+
+            this.aoBrightnessXYNP = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos, zPos);
+            this.aoBrightnessXYPP = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos, zPos);
+            this.aoBrightnessYZPN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos, zPos - 1);
+            this.aoBrightnessYZPP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos, zPos + 1);
+            this.aoLightValueScratchXYNP = blockAccess.getBlock(xPos - 1, yPos, zPos).getAmbientOcclusionLightValue();
+            this.aoLightValueScratchXYPP = blockAccess.getBlock(xPos + 1, yPos, zPos).getAmbientOcclusionLightValue();
+            this.aoLightValueScratchYZPN = blockAccess.getBlock(xPos, yPos, zPos - 1).getAmbientOcclusionLightValue();
+            this.aoLightValueScratchYZPP = blockAccess.getBlock(xPos, yPos, zPos + 1).getAmbientOcclusionLightValue();
+            flag2 = blockAccess.getBlock(xPos + 1, yPos + 1, zPos).getCanBlockGrass();
+            flag3 = blockAccess.getBlock(xPos - 1, yPos + 1, zPos).getCanBlockGrass();
+            flag4 = blockAccess.getBlock(xPos, yPos + 1, zPos + 1).getCanBlockGrass();
+            flag5 = blockAccess.getBlock(xPos, yPos + 1, zPos - 1).getCanBlockGrass();
+
+            if (!flag5 && !flag3)
+            {
+                this.aoLightValueScratchXYZNPN = this.aoLightValueScratchXYNP;
+                this.aoBrightnessXYZNPN = this.aoBrightnessXYNP;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZNPN = blockAccess.getBlock(xPos - 1, yPos, zPos - 1).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZNPN = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos, zPos - 1);
+            }
+
+            if (!flag5 && !flag2)
+            {
+                this.aoLightValueScratchXYZPPN = this.aoLightValueScratchXYPP;
+                this.aoBrightnessXYZPPN = this.aoBrightnessXYPP;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZPPN = blockAccess.getBlock(xPos + 1, yPos, zPos - 1).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZPPN = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos, zPos - 1);
+            }
+
+            if (!flag4 && !flag3)
+            {
+                this.aoLightValueScratchXYZNPP = this.aoLightValueScratchXYNP;
+                this.aoBrightnessXYZNPP = this.aoBrightnessXYNP;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZNPP = blockAccess.getBlock(xPos - 1, yPos, zPos + 1).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZNPP = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos, zPos + 1);
+            }
+
+            if (!flag4 && !flag2)
+            {
+                this.aoLightValueScratchXYZPPP = this.aoLightValueScratchXYPP;
+                this.aoBrightnessXYZPPP = this.aoBrightnessXYPP;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZPPP = blockAccess.getBlock(xPos + 1, yPos, zPos + 1).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZPPP = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos, zPos + 1);
+            }
+
+            if (this.renderMaxY >= 1.0D)
+            {
+                --yPos;
+            }
+
+            i1 = l;
+
+            if (this.renderMaxY >= 1.0D || !blockAccess.getBlock(xPos, yPos + 1, zPos).isOpaqueCube())
+            {
+                i1 = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos + 1, zPos);
+            }
+
+            f7 = blockAccess.getBlock(xPos, yPos + 1, zPos).getAmbientOcclusionLightValue();
+            f6 = (this.aoLightValueScratchXYZNPP + this.aoLightValueScratchXYNP + this.aoLightValueScratchYZPP + f7) / 4.0F;
+            f3 = (this.aoLightValueScratchYZPP + f7 + this.aoLightValueScratchXYZPPP + this.aoLightValueScratchXYPP) / 4.0F;
+            f4 = (f7 + this.aoLightValueScratchYZPN + this.aoLightValueScratchXYPP + this.aoLightValueScratchXYZPPN) / 4.0F;
+            f5 = (this.aoLightValueScratchXYNP + this.aoLightValueScratchXYZNPN + f7 + this.aoLightValueScratchYZPN) / 4.0F;
+            this.brightnessTopRight = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXYZNPP, this.aoBrightnessXYNP, this.aoBrightnessYZPP, i1);
+            this.brightnessTopLeft = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessYZPP, this.aoBrightnessXYZPPP, this.aoBrightnessXYPP, i1);
+            this.brightnessBottomLeft = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessYZPN, this.aoBrightnessXYPP, this.aoBrightnessXYZPPN, i1);
+            this.brightnessBottomRight = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXYNP, this.aoBrightnessXYZNPN, this.aoBrightnessYZPN, i1);
+            this.colorRedTopLeft = this.colorRedBottomLeft = this.colorRedBottomRight = this.colorRedTopRight = R;
+            this.colorGreenTopLeft = this.colorGreenBottomLeft = this.colorGreenBottomRight = this.colorGreenTopRight = G;
+            this.colorBlueTopLeft = this.colorBlueBottomLeft = this.colorBlueBottomRight = this.colorBlueTopRight = B;
+            this.colorRedTopLeft *= f3;
+            this.colorGreenTopLeft *= f3;
+            this.colorBlueTopLeft *= f3;
+            this.colorRedBottomLeft *= f4;
+            this.colorGreenBottomLeft *= f4;
+            this.colorBlueBottomLeft *= f4;
+            this.colorRedBottomRight *= f5;
+            this.colorGreenBottomRight *= f5;
+            this.colorBlueBottomRight *= f5;
+            this.colorRedTopRight *= f6;
+            this.colorGreenTopRight *= f6;
+            this.colorBlueTopRight *= f6;
+            CustomOreBlockRenderer.renderFaceYPos(aWorld, aRenderer, block, xPos, yPos, zPos, aTextures);
+            flag = true;
+        }
+
+        IIcon iicon;
+
+        if (RenderBlocks.getInstance().renderAllFaces || block.shouldSideBeRendered(blockAccess, xPos, yPos, zPos - 1, 2))
+        {
+            if (this.renderMinZ <= 0.0D)
+            {
+                --zPos;
+            }
+
+            this.aoLightValueScratchXZNN = blockAccess.getBlock(xPos - 1, yPos, zPos).getAmbientOcclusionLightValue();
+            this.aoLightValueScratchYZNN = blockAccess.getBlock(xPos, yPos - 1, zPos).getAmbientOcclusionLightValue();
+            this.aoLightValueScratchYZPN = blockAccess.getBlock(xPos, yPos + 1, zPos).getAmbientOcclusionLightValue();
+            this.aoLightValueScratchXZPN = blockAccess.getBlock(xPos + 1, yPos, zPos).getAmbientOcclusionLightValue();
+            this.aoBrightnessXZNN = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos, zPos);
+            this.aoBrightnessYZNN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos - 1, zPos);
+            this.aoBrightnessYZPN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos + 1, zPos);
+            this.aoBrightnessXZPN = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos, zPos);
+            flag2 = blockAccess.getBlock(xPos + 1, yPos, zPos - 1).getCanBlockGrass();
+            flag3 = blockAccess.getBlock(xPos - 1, yPos, zPos - 1).getCanBlockGrass();
+            flag4 = blockAccess.getBlock(xPos, yPos + 1, zPos - 1).getCanBlockGrass();
+            flag5 = blockAccess.getBlock(xPos, yPos - 1, zPos - 1).getCanBlockGrass();
+
+            if (!flag3 && !flag5)
+            {
+                this.aoLightValueScratchXYZNNN = this.aoLightValueScratchXZNN;
+                this.aoBrightnessXYZNNN = this.aoBrightnessXZNN;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZNNN = blockAccess.getBlock(xPos - 1, yPos - 1, zPos).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZNNN = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos - 1, zPos);
+            }
+
+            if (!flag3 && !flag4)
+            {
+                this.aoLightValueScratchXYZNPN = this.aoLightValueScratchXZNN;
+                this.aoBrightnessXYZNPN = this.aoBrightnessXZNN;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZNPN = blockAccess.getBlock(xPos - 1, yPos + 1, zPos).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZNPN = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos + 1, zPos);
+            }
+
+            if (!flag2 && !flag5)
+            {
+                this.aoLightValueScratchXYZPNN = this.aoLightValueScratchXZPN;
+                this.aoBrightnessXYZPNN = this.aoBrightnessXZPN;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZPNN = blockAccess.getBlock(xPos + 1, yPos - 1, zPos).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZPNN = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos - 1, zPos);
+            }
+
+            if (!flag2 && !flag4)
+            {
+                this.aoLightValueScratchXYZPPN = this.aoLightValueScratchXZPN;
+                this.aoBrightnessXYZPPN = this.aoBrightnessXZPN;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZPPN = blockAccess.getBlock(xPos + 1, yPos + 1, zPos).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZPPN = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos + 1, zPos);
+            }
+
+            if (this.renderMinZ <= 0.0D)
+            {
+                ++zPos;
+            }
+
+            i1 = l;
+
+            if (this.renderMinZ <= 0.0D || !blockAccess.getBlock(xPos, yPos, zPos - 1).isOpaqueCube())
+            {
+                i1 = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos, zPos - 1);
+            }
+
+            f7 = blockAccess.getBlock(xPos, yPos, zPos - 1).getAmbientOcclusionLightValue();
+            f3 = (this.aoLightValueScratchXZNN + this.aoLightValueScratchXYZNPN + f7 + this.aoLightValueScratchYZPN) / 4.0F;
+            f4 = (f7 + this.aoLightValueScratchYZPN + this.aoLightValueScratchXZPN + this.aoLightValueScratchXYZPPN) / 4.0F;
+            f5 = (this.aoLightValueScratchYZNN + f7 + this.aoLightValueScratchXYZPNN + this.aoLightValueScratchXZPN) / 4.0F;
+            f6 = (this.aoLightValueScratchXYZNNN + this.aoLightValueScratchXZNN + this.aoLightValueScratchYZNN + f7) / 4.0F;
+            this.brightnessTopLeft = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXZNN, this.aoBrightnessXYZNPN, this.aoBrightnessYZPN, i1);
+            this.brightnessBottomLeft = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessYZPN, this.aoBrightnessXZPN, this.aoBrightnessXYZPPN, i1);
+            this.brightnessBottomRight = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessYZNN, this.aoBrightnessXYZPNN, this.aoBrightnessXZPN, i1);
+            this.brightnessTopRight = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXYZNNN, this.aoBrightnessXZNN, this.aoBrightnessYZNN, i1);
+
+            if (flag1)
+            {
+                this.colorRedTopLeft = this.colorRedBottomLeft = this.colorRedBottomRight = this.colorRedTopRight = R * 0.8F;
+                this.colorGreenTopLeft = this.colorGreenBottomLeft = this.colorGreenBottomRight = this.colorGreenTopRight = G * 0.8F;
+                this.colorBlueTopLeft = this.colorBlueBottomLeft = this.colorBlueBottomRight = this.colorBlueTopRight = B * 0.8F;
+            }
+            else
+            {
+                this.colorRedTopLeft = this.colorRedBottomLeft = this.colorRedBottomRight = this.colorRedTopRight = 0.8F;
+                this.colorGreenTopLeft = this.colorGreenBottomLeft = this.colorGreenBottomRight = this.colorGreenTopRight = 0.8F;
+                this.colorBlueTopLeft = this.colorBlueBottomLeft = this.colorBlueBottomRight = this.colorBlueTopRight = 0.8F;
+            }
+
+            this.colorRedTopLeft *= f3;
+            this.colorGreenTopLeft *= f3;
+            this.colorBlueTopLeft *= f3;
+            this.colorRedBottomLeft *= f4;
+            this.colorGreenBottomLeft *= f4;
+            this.colorBlueBottomLeft *= f4;
+            this.colorRedBottomRight *= f5;
+            this.colorGreenBottomRight *= f5;
+            this.colorBlueBottomRight *= f5;
+            this.colorRedTopRight *= f6;
+            this.colorGreenTopRight *= f6;
+            this.colorBlueTopRight *= f6;
+            iicon = this.getBlockIcon(block, blockAccess, xPos, yPos, zPos, 2);
+            CustomOreBlockRenderer.renderFaceZNeg(aWorld, aRenderer, block, xPos, yPos, zPos, aTextures);
+
+            RenderBlocks.getInstance();
+			if (RenderBlocks.fancyGrass && iicon.getIconName().equals("grass_side") && !this.hasOverrideBlockTexture())
+            {
+                this.colorRedTopLeft *= R;
+                this.colorRedBottomLeft *= R;
+                this.colorRedBottomRight *= R;
+                this.colorRedTopRight *= R;
+                this.colorGreenTopLeft *= G;
+                this.colorGreenBottomLeft *= G;
+                this.colorGreenBottomRight *= G;
+                this.colorGreenTopRight *= G;
+                this.colorBlueTopLeft *= B;
+                this.colorBlueBottomLeft *= B;
+                this.colorBlueBottomRight *= B;
+                this.colorBlueTopRight *= B;
+                CustomOreBlockRenderer.renderFaceZNeg(aWorld, aRenderer, block, xPos, yPos, zPos, aTextures);
+            }
+
+            flag = true;
+        }
+
+        if (RenderBlocks.getInstance().renderAllFaces || block.shouldSideBeRendered(blockAccess, xPos, yPos, zPos + 1, 3))
+        {
+            if (this.renderMaxZ >= 1.0D)
+            {
+                ++zPos;
+            }
+
+            this.aoLightValueScratchXZNP = blockAccess.getBlock(xPos - 1, yPos, zPos).getAmbientOcclusionLightValue();
+            this.aoLightValueScratchXZPP = blockAccess.getBlock(xPos + 1, yPos, zPos).getAmbientOcclusionLightValue();
+            this.aoLightValueScratchYZNP = blockAccess.getBlock(xPos, yPos - 1, zPos).getAmbientOcclusionLightValue();
+            this.aoLightValueScratchYZPP = blockAccess.getBlock(xPos, yPos + 1, zPos).getAmbientOcclusionLightValue();
+            this.aoBrightnessXZNP = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos, zPos);
+            this.aoBrightnessXZPP = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos, zPos);
+            this.aoBrightnessYZNP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos - 1, zPos);
+            this.aoBrightnessYZPP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos + 1, zPos);
+            flag2 = blockAccess.getBlock(xPos + 1, yPos, zPos + 1).getCanBlockGrass();
+            flag3 = blockAccess.getBlock(xPos - 1, yPos, zPos + 1).getCanBlockGrass();
+            flag4 = blockAccess.getBlock(xPos, yPos + 1, zPos + 1).getCanBlockGrass();
+            flag5 = blockAccess.getBlock(xPos, yPos - 1, zPos + 1).getCanBlockGrass();
+
+            if (!flag3 && !flag5)
+            {
+                this.aoLightValueScratchXYZNNP = this.aoLightValueScratchXZNP;
+                this.aoBrightnessXYZNNP = this.aoBrightnessXZNP;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZNNP = blockAccess.getBlock(xPos - 1, yPos - 1, zPos).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZNNP = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos - 1, zPos);
+            }
+
+            if (!flag3 && !flag4)
+            {
+                this.aoLightValueScratchXYZNPP = this.aoLightValueScratchXZNP;
+                this.aoBrightnessXYZNPP = this.aoBrightnessXZNP;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZNPP = blockAccess.getBlock(xPos - 1, yPos + 1, zPos).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZNPP = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos + 1, zPos);
+            }
+
+            if (!flag2 && !flag5)
+            {
+                this.aoLightValueScratchXYZPNP = this.aoLightValueScratchXZPP;
+                this.aoBrightnessXYZPNP = this.aoBrightnessXZPP;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZPNP = blockAccess.getBlock(xPos + 1, yPos - 1, zPos).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZPNP = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos - 1, zPos);
+            }
+
+            if (!flag2 && !flag4)
+            {
+                this.aoLightValueScratchXYZPPP = this.aoLightValueScratchXZPP;
+                this.aoBrightnessXYZPPP = this.aoBrightnessXZPP;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZPPP = blockAccess.getBlock(xPos + 1, yPos + 1, zPos).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZPPP = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos + 1, zPos);
+            }
+
+            if (this.renderMaxZ >= 1.0D)
+            {
+                --zPos;
+            }
+
+            i1 = l;
+
+            if (this.renderMaxZ >= 1.0D || !blockAccess.getBlock(xPos, yPos, zPos + 1).isOpaqueCube())
+            {
+                i1 = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos, zPos + 1);
+            }
+
+            f7 = blockAccess.getBlock(xPos, yPos, zPos + 1).getAmbientOcclusionLightValue();
+            f3 = (this.aoLightValueScratchXZNP + this.aoLightValueScratchXYZNPP + f7 + this.aoLightValueScratchYZPP) / 4.0F;
+            f6 = (f7 + this.aoLightValueScratchYZPP + this.aoLightValueScratchXZPP + this.aoLightValueScratchXYZPPP) / 4.0F;
+            f5 = (this.aoLightValueScratchYZNP + f7 + this.aoLightValueScratchXYZPNP + this.aoLightValueScratchXZPP) / 4.0F;
+            f4 = (this.aoLightValueScratchXYZNNP + this.aoLightValueScratchXZNP + this.aoLightValueScratchYZNP + f7) / 4.0F;
+            this.brightnessTopLeft = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXZNP, this.aoBrightnessXYZNPP, this.aoBrightnessYZPP, i1);
+            this.brightnessTopRight = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessYZPP, this.aoBrightnessXZPP, this.aoBrightnessXYZPPP, i1);
+            this.brightnessBottomRight = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessYZNP, this.aoBrightnessXYZPNP, this.aoBrightnessXZPP, i1);
+            this.brightnessBottomLeft = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXYZNNP, this.aoBrightnessXZNP, this.aoBrightnessYZNP, i1);
+
+            if (flag1)
+            {
+                this.colorRedTopLeft = this.colorRedBottomLeft = this.colorRedBottomRight = this.colorRedTopRight = R * 0.8F;
+                this.colorGreenTopLeft = this.colorGreenBottomLeft = this.colorGreenBottomRight = this.colorGreenTopRight = G * 0.8F;
+                this.colorBlueTopLeft = this.colorBlueBottomLeft = this.colorBlueBottomRight = this.colorBlueTopRight = B * 0.8F;
+            }
+            else
+            {
+                this.colorRedTopLeft = this.colorRedBottomLeft = this.colorRedBottomRight = this.colorRedTopRight = 0.8F;
+                this.colorGreenTopLeft = this.colorGreenBottomLeft = this.colorGreenBottomRight = this.colorGreenTopRight = 0.8F;
+                this.colorBlueTopLeft = this.colorBlueBottomLeft = this.colorBlueBottomRight = this.colorBlueTopRight = 0.8F;
+            }
+
+            this.colorRedTopLeft *= f3;
+            this.colorGreenTopLeft *= f3;
+            this.colorBlueTopLeft *= f3;
+            this.colorRedBottomLeft *= f4;
+            this.colorGreenBottomLeft *= f4;
+            this.colorBlueBottomLeft *= f4;
+            this.colorRedBottomRight *= f5;
+            this.colorGreenBottomRight *= f5;
+            this.colorBlueBottomRight *= f5;
+            this.colorRedTopRight *= f6;
+            this.colorGreenTopRight *= f6;
+            this.colorBlueTopRight *= f6;
+            iicon = this.getBlockIcon(block, blockAccess, xPos, yPos, zPos, 3);
+            CustomOreBlockRenderer.renderFaceZPos(aWorld, aRenderer, block, xPos, yPos, zPos, aTextures);
+
+            RenderBlocks.getInstance();
+			if (RenderBlocks.fancyGrass && iicon.getIconName().equals("grass_side") && !this.hasOverrideBlockTexture())
+            {
+                this.colorRedTopLeft *= R;
+                this.colorRedBottomLeft *= R;
+                this.colorRedBottomRight *= R;
+                this.colorRedTopRight *= R;
+                this.colorGreenTopLeft *= G;
+                this.colorGreenBottomLeft *= G;
+                this.colorGreenBottomRight *= G;
+                this.colorGreenTopRight *= G;
+                this.colorBlueTopLeft *= B;
+                this.colorBlueBottomLeft *= B;
+                this.colorBlueBottomRight *= B;
+                this.colorBlueTopRight *= B;
+                CustomOreBlockRenderer.renderFaceZPos(aWorld, aRenderer, block, xPos, yPos, zPos, aTextures);
+            }
+
+            flag = true;
+        }
+
+        if (RenderBlocks.getInstance().renderAllFaces || block.shouldSideBeRendered(blockAccess, xPos - 1, yPos, zPos, 4))
+        {
+            if (this.renderMinX <= 0.0D)
+            {
+                --xPos;
+            }
+
+            this.aoLightValueScratchXYNN = blockAccess.getBlock(xPos, yPos - 1, zPos).getAmbientOcclusionLightValue();
+            this.aoLightValueScratchXZNN = blockAccess.getBlock(xPos, yPos, zPos - 1).getAmbientOcclusionLightValue();
+            this.aoLightValueScratchXZNP = blockAccess.getBlock(xPos, yPos, zPos + 1).getAmbientOcclusionLightValue();
+            this.aoLightValueScratchXYNP = blockAccess.getBlock(xPos, yPos + 1, zPos).getAmbientOcclusionLightValue();
+            this.aoBrightnessXYNN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos - 1, zPos);
+            this.aoBrightnessXZNN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos, zPos - 1);
+            this.aoBrightnessXZNP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos, zPos + 1);
+            this.aoBrightnessXYNP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos + 1, zPos);
+            flag2 = blockAccess.getBlock(xPos - 1, yPos + 1, zPos).getCanBlockGrass();
+            flag3 = blockAccess.getBlock(xPos - 1, yPos - 1, zPos).getCanBlockGrass();
+            flag4 = blockAccess.getBlock(xPos - 1, yPos, zPos - 1).getCanBlockGrass();
+            flag5 = blockAccess.getBlock(xPos - 1, yPos, zPos + 1).getCanBlockGrass();
+
+            if (!flag4 && !flag3)
+            {
+                this.aoLightValueScratchXYZNNN = this.aoLightValueScratchXZNN;
+                this.aoBrightnessXYZNNN = this.aoBrightnessXZNN;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZNNN = blockAccess.getBlock(xPos, yPos - 1, zPos - 1).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZNNN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos - 1, zPos - 1);
+            }
+
+            if (!flag5 && !flag3)
+            {
+                this.aoLightValueScratchXYZNNP = this.aoLightValueScratchXZNP;
+                this.aoBrightnessXYZNNP = this.aoBrightnessXZNP;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZNNP = blockAccess.getBlock(xPos, yPos - 1, zPos + 1).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZNNP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos - 1, zPos + 1);
+            }
+
+            if (!flag4 && !flag2)
+            {
+                this.aoLightValueScratchXYZNPN = this.aoLightValueScratchXZNN;
+                this.aoBrightnessXYZNPN = this.aoBrightnessXZNN;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZNPN = blockAccess.getBlock(xPos, yPos + 1, zPos - 1).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZNPN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos + 1, zPos - 1);
+            }
+
+            if (!flag5 && !flag2)
+            {
+                this.aoLightValueScratchXYZNPP = this.aoLightValueScratchXZNP;
+                this.aoBrightnessXYZNPP = this.aoBrightnessXZNP;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZNPP = blockAccess.getBlock(xPos, yPos + 1, zPos + 1).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZNPP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos + 1, zPos + 1);
+            }
+
+            if (this.renderMinX <= 0.0D)
+            {
+                ++xPos;
+            }
+
+            i1 = l;
+
+            if (this.renderMinX <= 0.0D || !blockAccess.getBlock(xPos - 1, yPos, zPos).isOpaqueCube())
+            {
+                i1 = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos, zPos);
+            }
+
+            f7 = blockAccess.getBlock(xPos - 1, yPos, zPos).getAmbientOcclusionLightValue();
+            f6 = (this.aoLightValueScratchXYNN + this.aoLightValueScratchXYZNNP + f7 + this.aoLightValueScratchXZNP) / 4.0F;
+            f3 = (f7 + this.aoLightValueScratchXZNP + this.aoLightValueScratchXYNP + this.aoLightValueScratchXYZNPP) / 4.0F;
+            f4 = (this.aoLightValueScratchXZNN + f7 + this.aoLightValueScratchXYZNPN + this.aoLightValueScratchXYNP) / 4.0F;
+            f5 = (this.aoLightValueScratchXYZNNN + this.aoLightValueScratchXYNN + this.aoLightValueScratchXZNN + f7) / 4.0F;
+            this.brightnessTopRight = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXYNN, this.aoBrightnessXYZNNP, this.aoBrightnessXZNP, i1);
+            this.brightnessTopLeft = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXZNP, this.aoBrightnessXYNP, this.aoBrightnessXYZNPP, i1);
+            this.brightnessBottomLeft = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXZNN, this.aoBrightnessXYZNPN, this.aoBrightnessXYNP, i1);
+            this.brightnessBottomRight = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXYZNNN, this.aoBrightnessXYNN, this.aoBrightnessXZNN, i1);
+
+            if (flag1)
+            {
+                this.colorRedTopLeft = this.colorRedBottomLeft = this.colorRedBottomRight = this.colorRedTopRight = R * 0.6F;
+                this.colorGreenTopLeft = this.colorGreenBottomLeft = this.colorGreenBottomRight = this.colorGreenTopRight = G * 0.6F;
+                this.colorBlueTopLeft = this.colorBlueBottomLeft = this.colorBlueBottomRight = this.colorBlueTopRight = B * 0.6F;
+            }
+            else
+            {
+                this.colorRedTopLeft = this.colorRedBottomLeft = this.colorRedBottomRight = this.colorRedTopRight = 0.6F;
+                this.colorGreenTopLeft = this.colorGreenBottomLeft = this.colorGreenBottomRight = this.colorGreenTopRight = 0.6F;
+                this.colorBlueTopLeft = this.colorBlueBottomLeft = this.colorBlueBottomRight = this.colorBlueTopRight = 0.6F;
+            }
+
+            this.colorRedTopLeft *= f3;
+            this.colorGreenTopLeft *= f3;
+            this.colorBlueTopLeft *= f3;
+            this.colorRedBottomLeft *= f4;
+            this.colorGreenBottomLeft *= f4;
+            this.colorBlueBottomLeft *= f4;
+            this.colorRedBottomRight *= f5;
+            this.colorGreenBottomRight *= f5;
+            this.colorBlueBottomRight *= f5;
+            this.colorRedTopRight *= f6;
+            this.colorGreenTopRight *= f6;
+            this.colorBlueTopRight *= f6;
+            iicon = this.getBlockIcon(block, blockAccess, xPos, yPos, zPos, 4);
+            CustomOreBlockRenderer.renderFaceXNeg(aWorld, aRenderer, block, xPos, yPos, zPos, aTextures);
+
+            RenderBlocks.getInstance();
+			if (RenderBlocks.fancyGrass && iicon.getIconName().equals("grass_side") && !this.hasOverrideBlockTexture())
+            {
+                this.colorRedTopLeft *= R;
+                this.colorRedBottomLeft *= R;
+                this.colorRedBottomRight *= R;
+                this.colorRedTopRight *= R;
+                this.colorGreenTopLeft *= G;
+                this.colorGreenBottomLeft *= G;
+                this.colorGreenBottomRight *= G;
+                this.colorGreenTopRight *= G;
+                this.colorBlueTopLeft *= B;
+                this.colorBlueBottomLeft *= B;
+                this.colorBlueBottomRight *= B;
+                this.colorBlueTopRight *= B;
+                CustomOreBlockRenderer.renderFaceXNeg(aWorld, aRenderer, block, xPos, yPos, zPos, aTextures);
+            }
+
+            flag = true;
+        }
+
+        if (RenderBlocks.getInstance().renderAllFaces || block.shouldSideBeRendered(blockAccess, xPos + 1, yPos, zPos, 5))
+        {
+            if (this.renderMaxX >= 1.0D)
+            {
+                ++xPos;
+            }
+
+            this.aoLightValueScratchXYPN = blockAccess.getBlock(xPos, yPos - 1, zPos).getAmbientOcclusionLightValue();
+            this.aoLightValueScratchXZPN = blockAccess.getBlock(xPos, yPos, zPos - 1).getAmbientOcclusionLightValue();
+            this.aoLightValueScratchXZPP = blockAccess.getBlock(xPos, yPos, zPos + 1).getAmbientOcclusionLightValue();
+            this.aoLightValueScratchXYPP = blockAccess.getBlock(xPos, yPos + 1, zPos).getAmbientOcclusionLightValue();
+            this.aoBrightnessXYPN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos - 1, zPos);
+            this.aoBrightnessXZPN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos, zPos - 1);
+            this.aoBrightnessXZPP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos, zPos + 1);
+            this.aoBrightnessXYPP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos + 1, zPos);
+            flag2 = blockAccess.getBlock(xPos + 1, yPos + 1, zPos).getCanBlockGrass();
+            flag3 = blockAccess.getBlock(xPos + 1, yPos - 1, zPos).getCanBlockGrass();
+            flag4 = blockAccess.getBlock(xPos + 1, yPos, zPos + 1).getCanBlockGrass();
+            flag5 = blockAccess.getBlock(xPos + 1, yPos, zPos - 1).getCanBlockGrass();
+
+            if (!flag3 && !flag5)
+            {
+                this.aoLightValueScratchXYZPNN = this.aoLightValueScratchXZPN;
+                this.aoBrightnessXYZPNN = this.aoBrightnessXZPN;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZPNN = blockAccess.getBlock(xPos, yPos - 1, zPos - 1).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZPNN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos - 1, zPos - 1);
+            }
+
+            if (!flag3 && !flag4)
+            {
+                this.aoLightValueScratchXYZPNP = this.aoLightValueScratchXZPP;
+                this.aoBrightnessXYZPNP = this.aoBrightnessXZPP;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZPNP = blockAccess.getBlock(xPos, yPos - 1, zPos + 1).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZPNP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos - 1, zPos + 1);
+            }
+
+            if (!flag2 && !flag5)
+            {
+                this.aoLightValueScratchXYZPPN = this.aoLightValueScratchXZPN;
+                this.aoBrightnessXYZPPN = this.aoBrightnessXZPN;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZPPN = blockAccess.getBlock(xPos, yPos + 1, zPos - 1).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZPPN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos + 1, zPos - 1);
+            }
+
+            if (!flag2 && !flag4)
+            {
+                this.aoLightValueScratchXYZPPP = this.aoLightValueScratchXZPP;
+                this.aoBrightnessXYZPPP = this.aoBrightnessXZPP;
+            }
+            else
+            {
+                this.aoLightValueScratchXYZPPP = blockAccess.getBlock(xPos, yPos + 1, zPos + 1).getAmbientOcclusionLightValue();
+                this.aoBrightnessXYZPPP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos + 1, zPos + 1);
+            }
+
+            if (this.renderMaxX >= 1.0D)
+            {
+                --xPos;
+            }
+
+            i1 = l;
+
+            if (this.renderMaxX >= 1.0D || !blockAccess.getBlock(xPos + 1, yPos, zPos).isOpaqueCube())
+            {
+                i1 = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos, zPos);
+            }
+
+            f7 = blockAccess.getBlock(xPos + 1, yPos, zPos).getAmbientOcclusionLightValue();
+            f3 = (this.aoLightValueScratchXYPN + this.aoLightValueScratchXYZPNP + f7 + this.aoLightValueScratchXZPP) / 4.0F;
+            f4 = (this.aoLightValueScratchXYZPNN + this.aoLightValueScratchXYPN + this.aoLightValueScratchXZPN + f7) / 4.0F;
+            f5 = (this.aoLightValueScratchXZPN + f7 + this.aoLightValueScratchXYZPPN + this.aoLightValueScratchXYPP) / 4.0F;
+            f6 = (f7 + this.aoLightValueScratchXZPP + this.aoLightValueScratchXYPP + this.aoLightValueScratchXYZPPP) / 4.0F;
+            this.brightnessTopLeft = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXYPN, this.aoBrightnessXYZPNP, this.aoBrightnessXZPP, i1);
+            this.brightnessTopRight = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXZPP, this.aoBrightnessXYPP, this.aoBrightnessXYZPPP, i1);
+            this.brightnessBottomRight = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXZPN, this.aoBrightnessXYZPPN, this.aoBrightnessXYPP, i1);
+            this.brightnessBottomLeft = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXYZPNN, this.aoBrightnessXYPN, this.aoBrightnessXZPN, i1);
+
+            if (flag1)
+            {
+                this.colorRedTopLeft = this.colorRedBottomLeft = this.colorRedBottomRight = this.colorRedTopRight = R * 0.6F;
+                this.colorGreenTopLeft = this.colorGreenBottomLeft = this.colorGreenBottomRight = this.colorGreenTopRight = G * 0.6F;
+                this.colorBlueTopLeft = this.colorBlueBottomLeft = this.colorBlueBottomRight = this.colorBlueTopRight = B * 0.6F;
+            }
+            else
+            {
+                this.colorRedTopLeft = this.colorRedBottomLeft = this.colorRedBottomRight = this.colorRedTopRight = 0.6F;
+                this.colorGreenTopLeft = this.colorGreenBottomLeft = this.colorGreenBottomRight = this.colorGreenTopRight = 0.6F;
+                this.colorBlueTopLeft = this.colorBlueBottomLeft = this.colorBlueBottomRight = this.colorBlueTopRight = 0.6F;
+            }
+
+            this.colorRedTopLeft *= f3;
+            this.colorGreenTopLeft *= f3;
+            this.colorBlueTopLeft *= f3;
+            this.colorRedBottomLeft *= f4;
+            this.colorGreenBottomLeft *= f4;
+            this.colorBlueBottomLeft *= f4;
+            this.colorRedBottomRight *= f5;
+            this.colorGreenBottomRight *= f5;
+            this.colorBlueBottomRight *= f5;
+            this.colorRedTopRight *= f6;
+            this.colorGreenTopRight *= f6;
+            this.colorBlueTopRight *= f6;
+            iicon = this.getBlockIcon(block, blockAccess, xPos, yPos, zPos, 5);
+            CustomOreBlockRenderer.renderFaceXPos(aWorld, aRenderer, block, xPos, yPos, zPos, aTextures);
+
+            RenderBlocks.getInstance();
+			if (RenderBlocks.fancyGrass && iicon.getIconName().equals("grass_side") && !this.hasOverrideBlockTexture())
+            {
+                this.colorRedTopLeft *= R;
+                this.colorRedBottomLeft *= R;
+                this.colorRedBottomRight *= R;
+                this.colorRedTopRight *= R;
+                this.colorGreenTopLeft *= G;
+                this.colorGreenBottomLeft *= G;
+                this.colorGreenBottomRight *= G;
+                this.colorGreenTopRight *= G;
+                this.colorBlueTopLeft *= B;
+                this.colorBlueBottomLeft *= B;
+                this.colorBlueBottomRight *= B;
+                this.colorBlueTopRight *= B;
+                CustomOreBlockRenderer.renderFaceXPos(aWorld, aRenderer, block, xPos, yPos, zPos, aTextures);
+            }
+
+            flag = true;
+        }
+
+        this.enableAO = false;
+        return flag;
+    }
+	
+	/**
+	 * Renders non-full-cube block with ambient occusion.  Args: block, x, y, z, red, green, blue (lighting)
+	 */
+	public boolean renderStandardBlockWithAmbientOcclusionPartial(IBlockAccess aWorld, RenderBlocks aRenderer, ITexture[][] aTextures, Block block, int xPos, int yPos, int zPos, float R, float G, float B)
+	{
+		this.enableAO = true;
+		boolean flag = false;
+		float f3 = 0.0F;
+		float f4 = 0.0F;
+		float f5 = 0.0F;
+		float f6 = 0.0F;
+		boolean flag1 = true;
+		int l = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos, zPos);
+		Tessellator tessellator = Tessellator.instance;
+		tessellator.setBrightness(983055);
+
+		if (this.getBlockIcon(block).getIconName().equals("grass_top"))
+		{
+			flag1 = false;
+		}
+		else if (this.hasOverrideBlockTexture())
+		{
+			flag1 = false;
+		}
+
+		boolean flag2;
+		boolean flag3;
+		boolean flag4;
+		boolean flag5;
+		int i1;
+		float f7;
+
+		if (RenderBlocks.getInstance().renderAllFaces || block.shouldSideBeRendered(blockAccess, xPos, yPos - 1, zPos, 0))
+		{
+			if (this.renderMinY <= 0.0D)
+			{
+				--yPos;
+			}
+
+			this.aoBrightnessXYNN = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos, zPos);
+			this.aoBrightnessYZNN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos, zPos - 1);
+			this.aoBrightnessYZNP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos, zPos + 1);
+			this.aoBrightnessXYPN = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos, zPos);
+			this.aoLightValueScratchXYNN = blockAccess.getBlock(xPos - 1, yPos, zPos).getAmbientOcclusionLightValue();
+			this.aoLightValueScratchYZNN = blockAccess.getBlock(xPos, yPos, zPos - 1).getAmbientOcclusionLightValue();
+			this.aoLightValueScratchYZNP = blockAccess.getBlock(xPos, yPos, zPos + 1).getAmbientOcclusionLightValue();
+			this.aoLightValueScratchXYPN = blockAccess.getBlock(xPos + 1, yPos, zPos).getAmbientOcclusionLightValue();
+			flag2 = blockAccess.getBlock(xPos + 1, yPos - 1, zPos).getCanBlockGrass();
+			flag3 = blockAccess.getBlock(xPos - 1, yPos - 1, zPos).getCanBlockGrass();
+			flag4 = blockAccess.getBlock(xPos, yPos - 1, zPos + 1).getCanBlockGrass();
+			flag5 = blockAccess.getBlock(xPos, yPos - 1, zPos - 1).getCanBlockGrass();
+
+			if (!flag5 && !flag3)
+			{
+				this.aoLightValueScratchXYZNNN = this.aoLightValueScratchXYNN;
+				this.aoBrightnessXYZNNN = this.aoBrightnessXYNN;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZNNN = blockAccess.getBlock(xPos - 1, yPos, zPos - 1).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZNNN = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos, zPos - 1);
+			}
+
+			if (!flag4 && !flag3)
+			{
+				this.aoLightValueScratchXYZNNP = this.aoLightValueScratchXYNN;
+				this.aoBrightnessXYZNNP = this.aoBrightnessXYNN;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZNNP = blockAccess.getBlock(xPos - 1, yPos, zPos + 1).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZNNP = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos, zPos + 1);
+			}
+
+			if (!flag5 && !flag2)
+			{
+				this.aoLightValueScratchXYZPNN = this.aoLightValueScratchXYPN;
+				this.aoBrightnessXYZPNN = this.aoBrightnessXYPN;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZPNN = blockAccess.getBlock(xPos + 1, yPos, zPos - 1).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZPNN = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos, zPos - 1);
+			}
+
+			if (!flag4 && !flag2)
+			{
+				this.aoLightValueScratchXYZPNP = this.aoLightValueScratchXYPN;
+				this.aoBrightnessXYZPNP = this.aoBrightnessXYPN;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZPNP = blockAccess.getBlock(xPos + 1, yPos, zPos + 1).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZPNP = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos, zPos + 1);
+			}
+
+			if (this.renderMinY <= 0.0D)
+			{
+				++yPos;
+			}
+
+			i1 = l;
+
+			if (this.renderMinY <= 0.0D || !blockAccess.getBlock(xPos, yPos - 1, zPos).isOpaqueCube())
+			{
+				i1 = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos - 1, zPos);
+			}
+
+			f7 = blockAccess.getBlock(xPos, yPos - 1, zPos).getAmbientOcclusionLightValue();
+			f3 = (this.aoLightValueScratchXYZNNP + this.aoLightValueScratchXYNN + this.aoLightValueScratchYZNP + f7) / 4.0F;
+			f6 = (this.aoLightValueScratchYZNP + f7 + this.aoLightValueScratchXYZPNP + this.aoLightValueScratchXYPN) / 4.0F;
+			f5 = (f7 + this.aoLightValueScratchYZNN + this.aoLightValueScratchXYPN + this.aoLightValueScratchXYZPNN) / 4.0F;
+			f4 = (this.aoLightValueScratchXYNN + this.aoLightValueScratchXYZNNN + f7 + this.aoLightValueScratchYZNN) / 4.0F;
+			this.brightnessTopLeft = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXYZNNP, this.aoBrightnessXYNN, this.aoBrightnessYZNP, i1);
+			this.brightnessTopRight = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessYZNP, this.aoBrightnessXYZPNP, this.aoBrightnessXYPN, i1);
+			this.brightnessBottomRight = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessYZNN, this.aoBrightnessXYPN, this.aoBrightnessXYZPNN, i1);
+			this.brightnessBottomLeft = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXYNN, this.aoBrightnessXYZNNN, this.aoBrightnessYZNN, i1);
+
+			if (flag1)
+			{
+				this.colorRedTopLeft = this.colorRedBottomLeft = this.colorRedBottomRight = this.colorRedTopRight = R * 0.5F;
+				this.colorGreenTopLeft = this.colorGreenBottomLeft = this.colorGreenBottomRight = this.colorGreenTopRight = G * 0.5F;
+				this.colorBlueTopLeft = this.colorBlueBottomLeft = this.colorBlueBottomRight = this.colorBlueTopRight = B * 0.5F;
+			}
+			else
+			{
+				this.colorRedTopLeft = this.colorRedBottomLeft = this.colorRedBottomRight = this.colorRedTopRight = 0.5F;
+				this.colorGreenTopLeft = this.colorGreenBottomLeft = this.colorGreenBottomRight = this.colorGreenTopRight = 0.5F;
+				this.colorBlueTopLeft = this.colorBlueBottomLeft = this.colorBlueBottomRight = this.colorBlueTopRight = 0.5F;
+			}
+
+			this.colorRedTopLeft *= f3;
+			this.colorGreenTopLeft *= f3;
+			this.colorBlueTopLeft *= f3;
+			this.colorRedBottomLeft *= f4;
+			this.colorGreenBottomLeft *= f4;
+			this.colorBlueBottomLeft *= f4;
+			this.colorRedBottomRight *= f5;
+			this.colorGreenBottomRight *= f5;
+			this.colorBlueBottomRight *= f5;
+			this.colorRedTopRight *= f6;
+			this.colorGreenTopRight *= f6;
+			this.colorBlueTopRight *= f6;
+			CustomOreBlockRenderer.renderFaceYNeg(aWorld, aRenderer, block, xPos, yPos, zPos, aTextures);
+			flag = true;
+		}
+
+		if (RenderBlocks.getInstance().renderAllFaces || block.shouldSideBeRendered(blockAccess, xPos, yPos + 1, zPos, 1))
+		{
+			if (this.renderMaxY >= 1.0D)
+			{
+				++yPos;
+			}
+
+			this.aoBrightnessXYNP = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos, zPos);
+			this.aoBrightnessXYPP = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos, zPos);
+			this.aoBrightnessYZPN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos, zPos - 1);
+			this.aoBrightnessYZPP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos, zPos + 1);
+			this.aoLightValueScratchXYNP = blockAccess.getBlock(xPos - 1, yPos, zPos).getAmbientOcclusionLightValue();
+			this.aoLightValueScratchXYPP = blockAccess.getBlock(xPos + 1, yPos, zPos).getAmbientOcclusionLightValue();
+			this.aoLightValueScratchYZPN = blockAccess.getBlock(xPos, yPos, zPos - 1).getAmbientOcclusionLightValue();
+			this.aoLightValueScratchYZPP = blockAccess.getBlock(xPos, yPos, zPos + 1).getAmbientOcclusionLightValue();
+			flag2 = blockAccess.getBlock(xPos + 1, yPos + 1, zPos).getCanBlockGrass();
+			flag3 = blockAccess.getBlock(xPos - 1, yPos + 1, zPos).getCanBlockGrass();
+			flag4 = blockAccess.getBlock(xPos, yPos + 1, zPos + 1).getCanBlockGrass();
+			flag5 = blockAccess.getBlock(xPos, yPos + 1, zPos - 1).getCanBlockGrass();
+
+			if (!flag5 && !flag3)
+			{
+				this.aoLightValueScratchXYZNPN = this.aoLightValueScratchXYNP;
+				this.aoBrightnessXYZNPN = this.aoBrightnessXYNP;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZNPN = blockAccess.getBlock(xPos - 1, yPos, zPos - 1).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZNPN = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos, zPos - 1);
+			}
+
+			if (!flag5 && !flag2)
+			{
+				this.aoLightValueScratchXYZPPN = this.aoLightValueScratchXYPP;
+				this.aoBrightnessXYZPPN = this.aoBrightnessXYPP;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZPPN = blockAccess.getBlock(xPos + 1, yPos, zPos - 1).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZPPN = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos, zPos - 1);
+			}
+
+			if (!flag4 && !flag3)
+			{
+				this.aoLightValueScratchXYZNPP = this.aoLightValueScratchXYNP;
+				this.aoBrightnessXYZNPP = this.aoBrightnessXYNP;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZNPP = blockAccess.getBlock(xPos - 1, yPos, zPos + 1).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZNPP = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos, zPos + 1);
+			}
+
+			if (!flag4 && !flag2)
+			{
+				this.aoLightValueScratchXYZPPP = this.aoLightValueScratchXYPP;
+				this.aoBrightnessXYZPPP = this.aoBrightnessXYPP;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZPPP = blockAccess.getBlock(xPos + 1, yPos, zPos + 1).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZPPP = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos, zPos + 1);
+			}
+
+			if (this.renderMaxY >= 1.0D)
+			{
+				--yPos;
+			}
+
+			i1 = l;
+
+			if (this.renderMaxY >= 1.0D || !blockAccess.getBlock(xPos, yPos + 1, zPos).isOpaqueCube())
+			{
+				i1 = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos + 1, zPos);
+			}
+
+			f7 = blockAccess.getBlock(xPos, yPos + 1, zPos).getAmbientOcclusionLightValue();
+			f6 = (this.aoLightValueScratchXYZNPP + this.aoLightValueScratchXYNP + this.aoLightValueScratchYZPP + f7) / 4.0F;
+			f3 = (this.aoLightValueScratchYZPP + f7 + this.aoLightValueScratchXYZPPP + this.aoLightValueScratchXYPP) / 4.0F;
+			f4 = (f7 + this.aoLightValueScratchYZPN + this.aoLightValueScratchXYPP + this.aoLightValueScratchXYZPPN) / 4.0F;
+			f5 = (this.aoLightValueScratchXYNP + this.aoLightValueScratchXYZNPN + f7 + this.aoLightValueScratchYZPN) / 4.0F;
+			this.brightnessTopRight = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXYZNPP, this.aoBrightnessXYNP, this.aoBrightnessYZPP, i1);
+			this.brightnessTopLeft = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessYZPP, this.aoBrightnessXYZPPP, this.aoBrightnessXYPP, i1);
+			this.brightnessBottomLeft = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessYZPN, this.aoBrightnessXYPP, this.aoBrightnessXYZPPN, i1);
+			this.brightnessBottomRight = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXYNP, this.aoBrightnessXYZNPN, this.aoBrightnessYZPN, i1);
+			this.colorRedTopLeft = this.colorRedBottomLeft = this.colorRedBottomRight = this.colorRedTopRight = R;
+			this.colorGreenTopLeft = this.colorGreenBottomLeft = this.colorGreenBottomRight = this.colorGreenTopRight = G;
+			this.colorBlueTopLeft = this.colorBlueBottomLeft = this.colorBlueBottomRight = this.colorBlueTopRight = B;
+			this.colorRedTopLeft *= f3;
+			this.colorGreenTopLeft *= f3;
+			this.colorBlueTopLeft *= f3;
+			this.colorRedBottomLeft *= f4;
+			this.colorGreenBottomLeft *= f4;
+			this.colorBlueBottomLeft *= f4;
+			this.colorRedBottomRight *= f5;
+			this.colorGreenBottomRight *= f5;
+			this.colorBlueBottomRight *= f5;
+			this.colorRedTopRight *= f6;
+			this.colorGreenTopRight *= f6;
+			this.colorBlueTopRight *= f6;
+			CustomOreBlockRenderer.renderFaceYPos(aWorld, aRenderer, block, xPos, yPos, zPos, aTextures);
+			flag = true;
+		}
+
+		float f8;
+		float f9;
+		float f10;
+		float f11;
+		int j1;
+		int k1;
+		int l1;
+		int i2;
+		IIcon iicon;
+
+		if (RenderBlocks.getInstance().renderAllFaces || block.shouldSideBeRendered(blockAccess, xPos, yPos, zPos - 1, 2))
+		{
+			if (this.renderMinZ <= 0.0D)
+			{
+				--zPos;
+			}
+
+			this.aoLightValueScratchXZNN = blockAccess.getBlock(xPos - 1, yPos, zPos).getAmbientOcclusionLightValue();
+			this.aoLightValueScratchYZNN = blockAccess.getBlock(xPos, yPos - 1, zPos).getAmbientOcclusionLightValue();
+			this.aoLightValueScratchYZPN = blockAccess.getBlock(xPos, yPos + 1, zPos).getAmbientOcclusionLightValue();
+			this.aoLightValueScratchXZPN = blockAccess.getBlock(xPos + 1, yPos, zPos).getAmbientOcclusionLightValue();
+			this.aoBrightnessXZNN = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos, zPos);
+			this.aoBrightnessYZNN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos - 1, zPos);
+			this.aoBrightnessYZPN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos + 1, zPos);
+			this.aoBrightnessXZPN = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos, zPos);
+			flag2 = blockAccess.getBlock(xPos + 1, yPos, zPos - 1).getCanBlockGrass();
+			flag3 = blockAccess.getBlock(xPos - 1, yPos, zPos - 1).getCanBlockGrass();
+			flag4 = blockAccess.getBlock(xPos, yPos + 1, zPos - 1).getCanBlockGrass();
+			flag5 = blockAccess.getBlock(xPos, yPos - 1, zPos - 1).getCanBlockGrass();
+
+			if (!flag3 && !flag5)
+			{
+				this.aoLightValueScratchXYZNNN = this.aoLightValueScratchXZNN;
+				this.aoBrightnessXYZNNN = this.aoBrightnessXZNN;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZNNN = blockAccess.getBlock(xPos - 1, yPos - 1, zPos).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZNNN = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos - 1, zPos);
+			}
+
+			if (!flag3 && !flag4)
+			{
+				this.aoLightValueScratchXYZNPN = this.aoLightValueScratchXZNN;
+				this.aoBrightnessXYZNPN = this.aoBrightnessXZNN;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZNPN = blockAccess.getBlock(xPos - 1, yPos + 1, zPos).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZNPN = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos + 1, zPos);
+			}
+
+			if (!flag2 && !flag5)
+			{
+				this.aoLightValueScratchXYZPNN = this.aoLightValueScratchXZPN;
+				this.aoBrightnessXYZPNN = this.aoBrightnessXZPN;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZPNN = blockAccess.getBlock(xPos + 1, yPos - 1, zPos).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZPNN = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos - 1, zPos);
+			}
+
+			if (!flag2 && !flag4)
+			{
+				this.aoLightValueScratchXYZPPN = this.aoLightValueScratchXZPN;
+				this.aoBrightnessXYZPPN = this.aoBrightnessXZPN;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZPPN = blockAccess.getBlock(xPos + 1, yPos + 1, zPos).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZPPN = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos + 1, zPos);
+			}
+
+			if (this.renderMinZ <= 0.0D)
+			{
+				++zPos;
+			}
+
+			i1 = l;
+
+			if (this.renderMinZ <= 0.0D || !blockAccess.getBlock(xPos, yPos, zPos - 1).isOpaqueCube())
+			{
+				i1 = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos, zPos - 1);
+			}
+
+			f7 = blockAccess.getBlock(xPos, yPos, zPos - 1).getAmbientOcclusionLightValue();
+			f8 = (this.aoLightValueScratchXZNN + this.aoLightValueScratchXYZNPN + f7 + this.aoLightValueScratchYZPN) / 4.0F;
+			f9 = (f7 + this.aoLightValueScratchYZPN + this.aoLightValueScratchXZPN + this.aoLightValueScratchXYZPPN) / 4.0F;
+			f10 = (this.aoLightValueScratchYZNN + f7 + this.aoLightValueScratchXYZPNN + this.aoLightValueScratchXZPN) / 4.0F;
+			f11 = (this.aoLightValueScratchXYZNNN + this.aoLightValueScratchXZNN + this.aoLightValueScratchYZNN + f7) / 4.0F;
+			f3 = (float)((double)f8 * this.renderMaxY * (1.0D - this.renderMinX) + (double)f9 * this.renderMaxY * this.renderMinX + (double)f10 * (1.0D - this.renderMaxY) * this.renderMinX + (double)f11 * (1.0D - this.renderMaxY) * (1.0D - this.renderMinX));
+			f4 = (float)((double)f8 * this.renderMaxY * (1.0D - this.renderMaxX) + (double)f9 * this.renderMaxY * this.renderMaxX + (double)f10 * (1.0D - this.renderMaxY) * this.renderMaxX + (double)f11 * (1.0D - this.renderMaxY) * (1.0D - this.renderMaxX));
+			f5 = (float)((double)f8 * this.renderMinY * (1.0D - this.renderMaxX) + (double)f9 * this.renderMinY * this.renderMaxX + (double)f10 * (1.0D - this.renderMinY) * this.renderMaxX + (double)f11 * (1.0D - this.renderMinY) * (1.0D - this.renderMaxX));
+			f6 = (float)((double)f8 * this.renderMinY * (1.0D - this.renderMinX) + (double)f9 * this.renderMinY * this.renderMinX + (double)f10 * (1.0D - this.renderMinY) * this.renderMinX + (double)f11 * (1.0D - this.renderMinY) * (1.0D - this.renderMinX));
+			j1 = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXZNN, this.aoBrightnessXYZNPN, this.aoBrightnessYZPN, i1);
+			k1 = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessYZPN, this.aoBrightnessXZPN, this.aoBrightnessXYZPPN, i1);
+			l1 = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessYZNN, this.aoBrightnessXYZPNN, this.aoBrightnessXZPN, i1);
+			i2 = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXYZNNN, this.aoBrightnessXZNN, this.aoBrightnessYZNN, i1);
+			this.brightnessTopLeft = RenderBlocks.getInstance().mixAoBrightness(j1, k1, l1, i2, this.renderMaxY * (1.0D - this.renderMinX), this.renderMaxY * this.renderMinX, (1.0D - this.renderMaxY) * this.renderMinX, (1.0D - this.renderMaxY) * (1.0D - this.renderMinX));
+			this.brightnessBottomLeft = RenderBlocks.getInstance().mixAoBrightness(j1, k1, l1, i2, this.renderMaxY * (1.0D - this.renderMaxX), this.renderMaxY * this.renderMaxX, (1.0D - this.renderMaxY) * this.renderMaxX, (1.0D - this.renderMaxY) * (1.0D - this.renderMaxX));
+			this.brightnessBottomRight = RenderBlocks.getInstance().mixAoBrightness(j1, k1, l1, i2, this.renderMinY * (1.0D - this.renderMaxX), this.renderMinY * this.renderMaxX, (1.0D - this.renderMinY) * this.renderMaxX, (1.0D - this.renderMinY) * (1.0D - this.renderMaxX));
+			this.brightnessTopRight = RenderBlocks.getInstance().mixAoBrightness(j1, k1, l1, i2, this.renderMinY * (1.0D - this.renderMinX), this.renderMinY * this.renderMinX, (1.0D - this.renderMinY) * this.renderMinX, (1.0D - this.renderMinY) * (1.0D - this.renderMinX));
+
+			if (flag1)
+			{
+				this.colorRedTopLeft = this.colorRedBottomLeft = this.colorRedBottomRight = this.colorRedTopRight = R * 0.8F;
+				this.colorGreenTopLeft = this.colorGreenBottomLeft = this.colorGreenBottomRight = this.colorGreenTopRight = G * 0.8F;
+				this.colorBlueTopLeft = this.colorBlueBottomLeft = this.colorBlueBottomRight = this.colorBlueTopRight = B * 0.8F;
+			}
+			else
+			{
+				this.colorRedTopLeft = this.colorRedBottomLeft = this.colorRedBottomRight = this.colorRedTopRight = 0.8F;
+				this.colorGreenTopLeft = this.colorGreenBottomLeft = this.colorGreenBottomRight = this.colorGreenTopRight = 0.8F;
+				this.colorBlueTopLeft = this.colorBlueBottomLeft = this.colorBlueBottomRight = this.colorBlueTopRight = 0.8F;
+			}
+
+			this.colorRedTopLeft *= f3;
+			this.colorGreenTopLeft *= f3;
+			this.colorBlueTopLeft *= f3;
+			this.colorRedBottomLeft *= f4;
+			this.colorGreenBottomLeft *= f4;
+			this.colorBlueBottomLeft *= f4;
+			this.colorRedBottomRight *= f5;
+			this.colorGreenBottomRight *= f5;
+			this.colorBlueBottomRight *= f5;
+			this.colorRedTopRight *= f6;
+			this.colorGreenTopRight *= f6;
+			this.colorBlueTopRight *= f6;
+			iicon = this.getBlockIcon(block, blockAccess, xPos, yPos, zPos, 2);
+			CustomOreBlockRenderer.renderFaceZNeg(aWorld, aRenderer, block, xPos, yPos, zPos, aTextures);
+
+			RenderBlocks.getInstance();
+			if (RenderBlocks.fancyGrass && iicon.getIconName().equals("grass_side") && !this.hasOverrideBlockTexture())
+			{
+				this.colorRedTopLeft *= R;
+				this.colorRedBottomLeft *= R;
+				this.colorRedBottomRight *= R;
+				this.colorRedTopRight *= R;
+				this.colorGreenTopLeft *= G;
+				this.colorGreenBottomLeft *= G;
+				this.colorGreenBottomRight *= G;
+				this.colorGreenTopRight *= G;
+				this.colorBlueTopLeft *= B;
+				this.colorBlueBottomLeft *= B;
+				this.colorBlueBottomRight *= B;
+				this.colorBlueTopRight *= B;
+				CustomOreBlockRenderer.renderFaceZNeg(aWorld, aRenderer, block, xPos, yPos, zPos, aTextures);
+			}
+
+			flag = true;
+		}
+
+		if (RenderBlocks.getInstance().renderAllFaces || block.shouldSideBeRendered(blockAccess, xPos, yPos, zPos + 1, 3))
+		{
+			if (this.renderMaxZ >= 1.0D)
+			{
+				++zPos;
+			}
+
+			this.aoLightValueScratchXZNP = blockAccess.getBlock(xPos - 1, yPos, zPos).getAmbientOcclusionLightValue();
+			this.aoLightValueScratchXZPP = blockAccess.getBlock(xPos + 1, yPos, zPos).getAmbientOcclusionLightValue();
+			this.aoLightValueScratchYZNP = blockAccess.getBlock(xPos, yPos - 1, zPos).getAmbientOcclusionLightValue();
+			this.aoLightValueScratchYZPP = blockAccess.getBlock(xPos, yPos + 1, zPos).getAmbientOcclusionLightValue();
+			this.aoBrightnessXZNP = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos, zPos);
+			this.aoBrightnessXZPP = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos, zPos);
+			this.aoBrightnessYZNP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos - 1, zPos);
+			this.aoBrightnessYZPP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos + 1, zPos);
+			flag2 = blockAccess.getBlock(xPos + 1, yPos, zPos + 1).getCanBlockGrass();
+			flag3 = blockAccess.getBlock(xPos - 1, yPos, zPos + 1).getCanBlockGrass();
+			flag4 = blockAccess.getBlock(xPos, yPos + 1, zPos + 1).getCanBlockGrass();
+			flag5 = blockAccess.getBlock(xPos, yPos - 1, zPos + 1).getCanBlockGrass();
+
+			if (!flag3 && !flag5)
+			{
+				this.aoLightValueScratchXYZNNP = this.aoLightValueScratchXZNP;
+				this.aoBrightnessXYZNNP = this.aoBrightnessXZNP;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZNNP = blockAccess.getBlock(xPos - 1, yPos - 1, zPos).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZNNP = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos - 1, zPos);
+			}
+
+			if (!flag3 && !flag4)
+			{
+				this.aoLightValueScratchXYZNPP = this.aoLightValueScratchXZNP;
+				this.aoBrightnessXYZNPP = this.aoBrightnessXZNP;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZNPP = blockAccess.getBlock(xPos - 1, yPos + 1, zPos).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZNPP = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos + 1, zPos);
+			}
+
+			if (!flag2 && !flag5)
+			{
+				this.aoLightValueScratchXYZPNP = this.aoLightValueScratchXZPP;
+				this.aoBrightnessXYZPNP = this.aoBrightnessXZPP;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZPNP = blockAccess.getBlock(xPos + 1, yPos - 1, zPos).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZPNP = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos - 1, zPos);
+			}
+
+			if (!flag2 && !flag4)
+			{
+				this.aoLightValueScratchXYZPPP = this.aoLightValueScratchXZPP;
+				this.aoBrightnessXYZPPP = this.aoBrightnessXZPP;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZPPP = blockAccess.getBlock(xPos + 1, yPos + 1, zPos).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZPPP = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos + 1, zPos);
+			}
+
+			if (this.renderMaxZ >= 1.0D)
+			{
+				--zPos;
+			}
+
+			i1 = l;
+
+			if (this.renderMaxZ >= 1.0D || !blockAccess.getBlock(xPos, yPos, zPos + 1).isOpaqueCube())
+			{
+				i1 = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos, zPos + 1);
+			}
+
+			f7 = blockAccess.getBlock(xPos, yPos, zPos + 1).getAmbientOcclusionLightValue();
+			f8 = (this.aoLightValueScratchXZNP + this.aoLightValueScratchXYZNPP + f7 + this.aoLightValueScratchYZPP) / 4.0F;
+			f9 = (f7 + this.aoLightValueScratchYZPP + this.aoLightValueScratchXZPP + this.aoLightValueScratchXYZPPP) / 4.0F;
+			f10 = (this.aoLightValueScratchYZNP + f7 + this.aoLightValueScratchXYZPNP + this.aoLightValueScratchXZPP) / 4.0F;
+			f11 = (this.aoLightValueScratchXYZNNP + this.aoLightValueScratchXZNP + this.aoLightValueScratchYZNP + f7) / 4.0F;
+			f3 = (float)((double)f8 * this.renderMaxY * (1.0D - this.renderMinX) + (double)f9 * this.renderMaxY * this.renderMinX + (double)f10 * (1.0D - this.renderMaxY) * this.renderMinX + (double)f11 * (1.0D - this.renderMaxY) * (1.0D - this.renderMinX));
+			f4 = (float)((double)f8 * this.renderMinY * (1.0D - this.renderMinX) + (double)f9 * this.renderMinY * this.renderMinX + (double)f10 * (1.0D - this.renderMinY) * this.renderMinX + (double)f11 * (1.0D - this.renderMinY) * (1.0D - this.renderMinX));
+			f5 = (float)((double)f8 * this.renderMinY * (1.0D - this.renderMaxX) + (double)f9 * this.renderMinY * this.renderMaxX + (double)f10 * (1.0D - this.renderMinY) * this.renderMaxX + (double)f11 * (1.0D - this.renderMinY) * (1.0D - this.renderMaxX));
+			f6 = (float)((double)f8 * this.renderMaxY * (1.0D - this.renderMaxX) + (double)f9 * this.renderMaxY * this.renderMaxX + (double)f10 * (1.0D - this.renderMaxY) * this.renderMaxX + (double)f11 * (1.0D - this.renderMaxY) * (1.0D - this.renderMaxX));
+			j1 = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXZNP, this.aoBrightnessXYZNPP, this.aoBrightnessYZPP, i1);
+			k1 = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessYZPP, this.aoBrightnessXZPP, this.aoBrightnessXYZPPP, i1);
+			l1 = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessYZNP, this.aoBrightnessXYZPNP, this.aoBrightnessXZPP, i1);
+			i2 = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXYZNNP, this.aoBrightnessXZNP, this.aoBrightnessYZNP, i1);
+			this.brightnessTopLeft = RenderBlocks.getInstance().mixAoBrightness(j1, i2, l1, k1, this.renderMaxY * (1.0D - this.renderMinX), (1.0D - this.renderMaxY) * (1.0D - this.renderMinX), (1.0D - this.renderMaxY) * this.renderMinX, this.renderMaxY * this.renderMinX);
+			this.brightnessBottomLeft = RenderBlocks.getInstance().mixAoBrightness(j1, i2, l1, k1, this.renderMinY * (1.0D - this.renderMinX), (1.0D - this.renderMinY) * (1.0D - this.renderMinX), (1.0D - this.renderMinY) * this.renderMinX, this.renderMinY * this.renderMinX);
+			this.brightnessBottomRight = RenderBlocks.getInstance().mixAoBrightness(j1, i2, l1, k1, this.renderMinY * (1.0D - this.renderMaxX), (1.0D - this.renderMinY) * (1.0D - this.renderMaxX), (1.0D - this.renderMinY) * this.renderMaxX, this.renderMinY * this.renderMaxX);
+			this.brightnessTopRight = RenderBlocks.getInstance().mixAoBrightness(j1, i2, l1, k1, this.renderMaxY * (1.0D - this.renderMaxX), (1.0D - this.renderMaxY) * (1.0D - this.renderMaxX), (1.0D - this.renderMaxY) * this.renderMaxX, this.renderMaxY * this.renderMaxX);
+
+			if (flag1)
+			{
+				this.colorRedTopLeft = this.colorRedBottomLeft = this.colorRedBottomRight = this.colorRedTopRight = R * 0.8F;
+				this.colorGreenTopLeft = this.colorGreenBottomLeft = this.colorGreenBottomRight = this.colorGreenTopRight = G * 0.8F;
+				this.colorBlueTopLeft = this.colorBlueBottomLeft = this.colorBlueBottomRight = this.colorBlueTopRight = B * 0.8F;
+			}
+			else
+			{
+				this.colorRedTopLeft = this.colorRedBottomLeft = this.colorRedBottomRight = this.colorRedTopRight = 0.8F;
+				this.colorGreenTopLeft = this.colorGreenBottomLeft = this.colorGreenBottomRight = this.colorGreenTopRight = 0.8F;
+				this.colorBlueTopLeft = this.colorBlueBottomLeft = this.colorBlueBottomRight = this.colorBlueTopRight = 0.8F;
+			}
+
+			this.colorRedTopLeft *= f3;
+			this.colorGreenTopLeft *= f3;
+			this.colorBlueTopLeft *= f3;
+			this.colorRedBottomLeft *= f4;
+			this.colorGreenBottomLeft *= f4;
+			this.colorBlueBottomLeft *= f4;
+			this.colorRedBottomRight *= f5;
+			this.colorGreenBottomRight *= f5;
+			this.colorBlueBottomRight *= f5;
+			this.colorRedTopRight *= f6;
+			this.colorGreenTopRight *= f6;
+			this.colorBlueTopRight *= f6;
+			iicon = this.getBlockIcon(block, blockAccess, xPos, yPos, zPos, 3);
+			CustomOreBlockRenderer.renderFaceZPos(aWorld, aRenderer, block, xPos, yPos, zPos, aTextures);
+
+			RenderBlocks.getInstance();
+			if (RenderBlocks.fancyGrass && iicon.getIconName().equals("grass_side") && !this.hasOverrideBlockTexture())
+			{
+				this.colorRedTopLeft *= R;
+				this.colorRedBottomLeft *= R;
+				this.colorRedBottomRight *= R;
+				this.colorRedTopRight *= R;
+				this.colorGreenTopLeft *= G;
+				this.colorGreenBottomLeft *= G;
+				this.colorGreenBottomRight *= G;
+				this.colorGreenTopRight *= G;
+				this.colorBlueTopLeft *= B;
+				this.colorBlueBottomLeft *= B;
+				this.colorBlueBottomRight *= B;
+				this.colorBlueTopRight *= B;
+				CustomOreBlockRenderer.renderFaceZPos(aWorld, aRenderer, block, xPos, yPos, zPos, aTextures);
+			}
+
+			flag = true;
+		}
+
+		if (RenderBlocks.getInstance().renderAllFaces || block.shouldSideBeRendered(blockAccess, xPos - 1, yPos, zPos, 4))
+		{
+			if (this.renderMinX <= 0.0D)
+			{
+				--xPos;
+			}
+
+			this.aoLightValueScratchXYNN = blockAccess.getBlock(xPos, yPos - 1, zPos).getAmbientOcclusionLightValue();
+			this.aoLightValueScratchXZNN = blockAccess.getBlock(xPos, yPos, zPos - 1).getAmbientOcclusionLightValue();
+			this.aoLightValueScratchXZNP = blockAccess.getBlock(xPos, yPos, zPos + 1).getAmbientOcclusionLightValue();
+			this.aoLightValueScratchXYNP = blockAccess.getBlock(xPos, yPos + 1, zPos).getAmbientOcclusionLightValue();
+			this.aoBrightnessXYNN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos - 1, zPos);
+			this.aoBrightnessXZNN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos, zPos - 1);
+			this.aoBrightnessXZNP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos, zPos + 1);
+			this.aoBrightnessXYNP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos + 1, zPos);
+			flag2 = blockAccess.getBlock(xPos - 1, yPos + 1, zPos).getCanBlockGrass();
+			flag3 = blockAccess.getBlock(xPos - 1, yPos - 1, zPos).getCanBlockGrass();
+			flag4 = blockAccess.getBlock(xPos - 1, yPos, zPos - 1).getCanBlockGrass();
+			flag5 = blockAccess.getBlock(xPos - 1, yPos, zPos + 1).getCanBlockGrass();
+
+			if (!flag4 && !flag3)
+			{
+				this.aoLightValueScratchXYZNNN = this.aoLightValueScratchXZNN;
+				this.aoBrightnessXYZNNN = this.aoBrightnessXZNN;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZNNN = blockAccess.getBlock(xPos, yPos - 1, zPos - 1).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZNNN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos - 1, zPos - 1);
+			}
+
+			if (!flag5 && !flag3)
+			{
+				this.aoLightValueScratchXYZNNP = this.aoLightValueScratchXZNP;
+				this.aoBrightnessXYZNNP = this.aoBrightnessXZNP;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZNNP = blockAccess.getBlock(xPos, yPos - 1, zPos + 1).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZNNP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos - 1, zPos + 1);
+			}
+
+			if (!flag4 && !flag2)
+			{
+				this.aoLightValueScratchXYZNPN = this.aoLightValueScratchXZNN;
+				this.aoBrightnessXYZNPN = this.aoBrightnessXZNN;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZNPN = blockAccess.getBlock(xPos, yPos + 1, zPos - 1).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZNPN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos + 1, zPos - 1);
+			}
+
+			if (!flag5 && !flag2)
+			{
+				this.aoLightValueScratchXYZNPP = this.aoLightValueScratchXZNP;
+				this.aoBrightnessXYZNPP = this.aoBrightnessXZNP;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZNPP = blockAccess.getBlock(xPos, yPos + 1, zPos + 1).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZNPP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos + 1, zPos + 1);
+			}
+
+			if (this.renderMinX <= 0.0D)
+			{
+				++xPos;
+			}
+
+			i1 = l;
+
+			if (this.renderMinX <= 0.0D || !blockAccess.getBlock(xPos - 1, yPos, zPos).isOpaqueCube())
+			{
+				i1 = block.getMixedBrightnessForBlock(blockAccess, xPos - 1, yPos, zPos);
+			}
+
+			f7 = blockAccess.getBlock(xPos - 1, yPos, zPos).getAmbientOcclusionLightValue();
+			f8 = (this.aoLightValueScratchXYNN + this.aoLightValueScratchXYZNNP + f7 + this.aoLightValueScratchXZNP) / 4.0F;
+			f9 = (f7 + this.aoLightValueScratchXZNP + this.aoLightValueScratchXYNP + this.aoLightValueScratchXYZNPP) / 4.0F;
+			f10 = (this.aoLightValueScratchXZNN + f7 + this.aoLightValueScratchXYZNPN + this.aoLightValueScratchXYNP) / 4.0F;
+			f11 = (this.aoLightValueScratchXYZNNN + this.aoLightValueScratchXYNN + this.aoLightValueScratchXZNN + f7) / 4.0F;
+			f3 = (float)((double)f9 * this.renderMaxY * this.renderMaxZ + (double)f10 * this.renderMaxY * (1.0D - this.renderMaxZ) + (double)f11 * (1.0D - this.renderMaxY) * (1.0D - this.renderMaxZ) + (double)f8 * (1.0D - this.renderMaxY) * this.renderMaxZ);
+			f4 = (float)((double)f9 * this.renderMaxY * this.renderMinZ + (double)f10 * this.renderMaxY * (1.0D - this.renderMinZ) + (double)f11 * (1.0D - this.renderMaxY) * (1.0D - this.renderMinZ) + (double)f8 * (1.0D - this.renderMaxY) * this.renderMinZ);
+			f5 = (float)((double)f9 * this.renderMinY * this.renderMinZ + (double)f10 * this.renderMinY * (1.0D - this.renderMinZ) + (double)f11 * (1.0D - this.renderMinY) * (1.0D - this.renderMinZ) + (double)f8 * (1.0D - this.renderMinY) * this.renderMinZ);
+			f6 = (float)((double)f9 * this.renderMinY * this.renderMaxZ + (double)f10 * this.renderMinY * (1.0D - this.renderMaxZ) + (double)f11 * (1.0D - this.renderMinY) * (1.0D - this.renderMaxZ) + (double)f8 * (1.0D - this.renderMinY) * this.renderMaxZ);
+			j1 = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXYNN, this.aoBrightnessXYZNNP, this.aoBrightnessXZNP, i1);
+			k1 = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXZNP, this.aoBrightnessXYNP, this.aoBrightnessXYZNPP, i1);
+			l1 = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXZNN, this.aoBrightnessXYZNPN, this.aoBrightnessXYNP, i1);
+			i2 = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXYZNNN, this.aoBrightnessXYNN, this.aoBrightnessXZNN, i1);
+			this.brightnessTopLeft = RenderBlocks.getInstance().mixAoBrightness(k1, l1, i2, j1, this.renderMaxY * this.renderMaxZ, this.renderMaxY * (1.0D - this.renderMaxZ), (1.0D - this.renderMaxY) * (1.0D - this.renderMaxZ), (1.0D - this.renderMaxY) * this.renderMaxZ);
+			this.brightnessBottomLeft = RenderBlocks.getInstance().mixAoBrightness(k1, l1, i2, j1, this.renderMaxY * this.renderMinZ, this.renderMaxY * (1.0D - this.renderMinZ), (1.0D - this.renderMaxY) * (1.0D - this.renderMinZ), (1.0D - this.renderMaxY) * this.renderMinZ);
+			this.brightnessBottomRight = RenderBlocks.getInstance().mixAoBrightness(k1, l1, i2, j1, this.renderMinY * this.renderMinZ, this.renderMinY * (1.0D - this.renderMinZ), (1.0D - this.renderMinY) * (1.0D - this.renderMinZ), (1.0D - this.renderMinY) * this.renderMinZ);
+			this.brightnessTopRight = RenderBlocks.getInstance().mixAoBrightness(k1, l1, i2, j1, this.renderMinY * this.renderMaxZ, this.renderMinY * (1.0D - this.renderMaxZ), (1.0D - this.renderMinY) * (1.0D - this.renderMaxZ), (1.0D - this.renderMinY) * this.renderMaxZ);
+
+			if (flag1)
+			{
+				this.colorRedTopLeft = this.colorRedBottomLeft = this.colorRedBottomRight = this.colorRedTopRight = R * 0.6F;
+				this.colorGreenTopLeft = this.colorGreenBottomLeft = this.colorGreenBottomRight = this.colorGreenTopRight = G * 0.6F;
+				this.colorBlueTopLeft = this.colorBlueBottomLeft = this.colorBlueBottomRight = this.colorBlueTopRight = B * 0.6F;
+			}
+			else
+			{
+				this.colorRedTopLeft = this.colorRedBottomLeft = this.colorRedBottomRight = this.colorRedTopRight = 0.6F;
+				this.colorGreenTopLeft = this.colorGreenBottomLeft = this.colorGreenBottomRight = this.colorGreenTopRight = 0.6F;
+				this.colorBlueTopLeft = this.colorBlueBottomLeft = this.colorBlueBottomRight = this.colorBlueTopRight = 0.6F;
+			}
+
+			this.colorRedTopLeft *= f3;
+			this.colorGreenTopLeft *= f3;
+			this.colorBlueTopLeft *= f3;
+			this.colorRedBottomLeft *= f4;
+			this.colorGreenBottomLeft *= f4;
+			this.colorBlueBottomLeft *= f4;
+			this.colorRedBottomRight *= f5;
+			this.colorGreenBottomRight *= f5;
+			this.colorBlueBottomRight *= f5;
+			this.colorRedTopRight *= f6;
+			this.colorGreenTopRight *= f6;
+			this.colorBlueTopRight *= f6;
+			iicon = this.getBlockIcon(block, blockAccess, xPos, yPos, zPos, 4);
+			CustomOreBlockRenderer.renderFaceXNeg(aWorld, aRenderer, block, xPos, yPos, zPos, aTextures);
+
+			RenderBlocks.getInstance();
+			if (RenderBlocks.fancyGrass && iicon.getIconName().equals("grass_side") && !this.hasOverrideBlockTexture())
+			{
+				this.colorRedTopLeft *= R;
+				this.colorRedBottomLeft *= R;
+				this.colorRedBottomRight *= R;
+				this.colorRedTopRight *= R;
+				this.colorGreenTopLeft *= G;
+				this.colorGreenBottomLeft *= G;
+				this.colorGreenBottomRight *= G;
+				this.colorGreenTopRight *= G;
+				this.colorBlueTopLeft *= B;
+				this.colorBlueBottomLeft *= B;
+				this.colorBlueBottomRight *= B;
+				this.colorBlueTopRight *= B;
+				CustomOreBlockRenderer.renderFaceXNeg(aWorld, aRenderer, block, xPos, yPos, zPos, aTextures);
+			}
+
+			flag = true;
+		}
+
+		if (RenderBlocks.getInstance().renderAllFaces || block.shouldSideBeRendered(blockAccess, xPos + 1, yPos, zPos, 5))
+		{
+			if (this.renderMaxX >= 1.0D)
+			{
+				++xPos;
+			}
+
+			this.aoLightValueScratchXYPN = blockAccess.getBlock(xPos, yPos - 1, zPos).getAmbientOcclusionLightValue();
+			this.aoLightValueScratchXZPN = blockAccess.getBlock(xPos, yPos, zPos - 1).getAmbientOcclusionLightValue();
+			this.aoLightValueScratchXZPP = blockAccess.getBlock(xPos, yPos, zPos + 1).getAmbientOcclusionLightValue();
+			this.aoLightValueScratchXYPP = blockAccess.getBlock(xPos, yPos + 1, zPos).getAmbientOcclusionLightValue();
+			this.aoBrightnessXYPN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos - 1, zPos);
+			this.aoBrightnessXZPN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos, zPos - 1);
+			this.aoBrightnessXZPP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos, zPos + 1);
+			this.aoBrightnessXYPP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos + 1, zPos);
+			flag2 = blockAccess.getBlock(xPos + 1, yPos + 1, zPos).getCanBlockGrass();
+			flag3 = blockAccess.getBlock(xPos + 1, yPos - 1, zPos).getCanBlockGrass();
+			flag4 = blockAccess.getBlock(xPos + 1, yPos, zPos + 1).getCanBlockGrass();
+			flag5 = blockAccess.getBlock(xPos + 1, yPos, zPos - 1).getCanBlockGrass();
+
+			if (!flag3 && !flag5)
+			{
+				this.aoLightValueScratchXYZPNN = this.aoLightValueScratchXZPN;
+				this.aoBrightnessXYZPNN = this.aoBrightnessXZPN;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZPNN = blockAccess.getBlock(xPos, yPos - 1, zPos - 1).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZPNN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos - 1, zPos - 1);
+			}
+
+			if (!flag3 && !flag4)
+			{
+				this.aoLightValueScratchXYZPNP = this.aoLightValueScratchXZPP;
+				this.aoBrightnessXYZPNP = this.aoBrightnessXZPP;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZPNP = blockAccess.getBlock(xPos, yPos - 1, zPos + 1).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZPNP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos - 1, zPos + 1);
+			}
+
+			if (!flag2 && !flag5)
+			{
+				this.aoLightValueScratchXYZPPN = this.aoLightValueScratchXZPN;
+				this.aoBrightnessXYZPPN = this.aoBrightnessXZPN;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZPPN = blockAccess.getBlock(xPos, yPos + 1, zPos - 1).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZPPN = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos + 1, zPos - 1);
+			}
+
+			if (!flag2 && !flag4)
+			{
+				this.aoLightValueScratchXYZPPP = this.aoLightValueScratchXZPP;
+				this.aoBrightnessXYZPPP = this.aoBrightnessXZPP;
+			}
+			else
+			{
+				this.aoLightValueScratchXYZPPP = blockAccess.getBlock(xPos, yPos + 1, zPos + 1).getAmbientOcclusionLightValue();
+				this.aoBrightnessXYZPPP = block.getMixedBrightnessForBlock(blockAccess, xPos, yPos + 1, zPos + 1);
+			}
+
+			if (this.renderMaxX >= 1.0D)
+			{
+				--xPos;
+			}
+
+			i1 = l;
+
+			if (this.renderMaxX >= 1.0D || !blockAccess.getBlock(xPos + 1, yPos, zPos).isOpaqueCube())
+			{
+				i1 = block.getMixedBrightnessForBlock(blockAccess, xPos + 1, yPos, zPos);
+			}
+
+			f7 = blockAccess.getBlock(xPos + 1, yPos, zPos).getAmbientOcclusionLightValue();
+			f8 = (this.aoLightValueScratchXYPN + this.aoLightValueScratchXYZPNP + f7 + this.aoLightValueScratchXZPP) / 4.0F;
+			f9 = (this.aoLightValueScratchXYZPNN + this.aoLightValueScratchXYPN + this.aoLightValueScratchXZPN + f7) / 4.0F;
+			f10 = (this.aoLightValueScratchXZPN + f7 + this.aoLightValueScratchXYZPPN + this.aoLightValueScratchXYPP) / 4.0F;
+			f11 = (f7 + this.aoLightValueScratchXZPP + this.aoLightValueScratchXYPP + this.aoLightValueScratchXYZPPP) / 4.0F;
+			f3 = (float)((double)f8 * (1.0D - this.renderMinY) * this.renderMaxZ + (double)f9 * (1.0D - this.renderMinY) * (1.0D - this.renderMaxZ) + (double)f10 * this.renderMinY * (1.0D - this.renderMaxZ) + (double)f11 * this.renderMinY * this.renderMaxZ);
+			f4 = (float)((double)f8 * (1.0D - this.renderMinY) * this.renderMinZ + (double)f9 * (1.0D - this.renderMinY) * (1.0D - this.renderMinZ) + (double)f10 * this.renderMinY * (1.0D - this.renderMinZ) + (double)f11 * this.renderMinY * this.renderMinZ);
+			f5 = (float)((double)f8 * (1.0D - this.renderMaxY) * this.renderMinZ + (double)f9 * (1.0D - this.renderMaxY) * (1.0D - this.renderMinZ) + (double)f10 * this.renderMaxY * (1.0D - this.renderMinZ) + (double)f11 * this.renderMaxY * this.renderMinZ);
+			f6 = (float)((double)f8 * (1.0D - this.renderMaxY) * this.renderMaxZ + (double)f9 * (1.0D - this.renderMaxY) * (1.0D - this.renderMaxZ) + (double)f10 * this.renderMaxY * (1.0D - this.renderMaxZ) + (double)f11 * this.renderMaxY * this.renderMaxZ);
+			j1 = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXYPN, this.aoBrightnessXYZPNP, this.aoBrightnessXZPP, i1);
+			k1 = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXZPP, this.aoBrightnessXYPP, this.aoBrightnessXYZPPP, i1);
+			l1 = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXZPN, this.aoBrightnessXYZPPN, this.aoBrightnessXYPP, i1);
+			i2 = RenderBlocks.getInstance().getAoBrightness(this.aoBrightnessXYZPNN, this.aoBrightnessXYPN, this.aoBrightnessXZPN, i1);
+			this.brightnessTopLeft = RenderBlocks.getInstance().mixAoBrightness(j1, i2, l1, k1, (1.0D - this.renderMinY) * this.renderMaxZ, (1.0D - this.renderMinY) * (1.0D - this.renderMaxZ), this.renderMinY * (1.0D - this.renderMaxZ), this.renderMinY * this.renderMaxZ);
+			this.brightnessBottomLeft = RenderBlocks.getInstance().mixAoBrightness(j1, i2, l1, k1, (1.0D - this.renderMinY) * this.renderMinZ, (1.0D - this.renderMinY) * (1.0D - this.renderMinZ), this.renderMinY * (1.0D - this.renderMinZ), this.renderMinY * this.renderMinZ);
+			this.brightnessBottomRight = RenderBlocks.getInstance().mixAoBrightness(j1, i2, l1, k1, (1.0D - this.renderMaxY) * this.renderMinZ, (1.0D - this.renderMaxY) * (1.0D - this.renderMinZ), this.renderMaxY * (1.0D - this.renderMinZ), this.renderMaxY * this.renderMinZ);
+			this.brightnessTopRight = RenderBlocks.getInstance().mixAoBrightness(j1, i2, l1, k1, (1.0D - this.renderMaxY) * this.renderMaxZ, (1.0D - this.renderMaxY) * (1.0D - this.renderMaxZ), this.renderMaxY * (1.0D - this.renderMaxZ), this.renderMaxY * this.renderMaxZ);
+
+			if (flag1)
+			{
+				this.colorRedTopLeft = this.colorRedBottomLeft = this.colorRedBottomRight = this.colorRedTopRight = R * 0.6F;
+				this.colorGreenTopLeft = this.colorGreenBottomLeft = this.colorGreenBottomRight = this.colorGreenTopRight = G * 0.6F;
+				this.colorBlueTopLeft = this.colorBlueBottomLeft = this.colorBlueBottomRight = this.colorBlueTopRight = B * 0.6F;
+			}
+			else
+			{
+				this.colorRedTopLeft = this.colorRedBottomLeft = this.colorRedBottomRight = this.colorRedTopRight = 0.6F;
+				this.colorGreenTopLeft = this.colorGreenBottomLeft = this.colorGreenBottomRight = this.colorGreenTopRight = 0.6F;
+				this.colorBlueTopLeft = this.colorBlueBottomLeft = this.colorBlueBottomRight = this.colorBlueTopRight = 0.6F;
+			}
+
+			this.colorRedTopLeft *= f3;
+			this.colorGreenTopLeft *= f3;
+			this.colorBlueTopLeft *= f3;
+			this.colorRedBottomLeft *= f4;
+			this.colorGreenBottomLeft *= f4;
+			this.colorBlueBottomLeft *= f4;
+			this.colorRedBottomRight *= f5;
+			this.colorGreenBottomRight *= f5;
+			this.colorBlueBottomRight *= f5;
+			this.colorRedTopRight *= f6;
+			this.colorGreenTopRight *= f6;
+			this.colorBlueTopRight *= f6;
+			iicon = this.getBlockIcon(block, blockAccess, xPos, yPos, zPos, 5);
+			CustomOreBlockRenderer.renderFaceXPos(aWorld, aRenderer, block, xPos, yPos, zPos, aTextures);
+
+			RenderBlocks.getInstance();
+			if (RenderBlocks.fancyGrass && iicon.getIconName().equals("grass_side") && !this.hasOverrideBlockTexture())
+			{
+				this.colorRedTopLeft *= R;
+				this.colorRedBottomLeft *= R;
+				this.colorRedBottomRight *= R;
+				this.colorRedTopRight *= R;
+				this.colorGreenTopLeft *= G;
+				this.colorGreenBottomLeft *= G;
+				this.colorGreenBottomRight *= G;
+				this.colorGreenTopRight *= G;
+				this.colorBlueTopLeft *= B;
+				this.colorBlueBottomLeft *= B;
+				this.colorBlueBottomRight *= B;
+				this.colorBlueTopRight *= B;
+				CustomOreBlockRenderer.renderFaceXPos(aWorld, aRenderer, block, xPos, yPos, zPos, aTextures);
+			}
+
+			flag = true;
+		}
+
+		this.enableAO = false;
+		return flag;
+	}
 
 }
diff --git a/src/Java/gtPlusPlus/core/item/ModItems.java b/src/Java/gtPlusPlus/core/item/ModItems.java
index 54236365f2..09b7dc3b21 100644
--- a/src/Java/gtPlusPlus/core/item/ModItems.java
+++ b/src/Java/gtPlusPlus/core/item/ModItems.java
@@ -423,7 +423,6 @@ public final class ModItems {
 			MaterialGenerator.generate(FLUORIDES.AMMONIUM_TETRAFLUOROBERYLLATE); //LFTR fuel component
 
 			//Generate Fluorides
-			MaterialGenerator.generateNuclearMaterial(FLUORIDES.FLUORITE);
 			MaterialGenerator.generateNuclearMaterial(FLUORIDES.BERYLLIUM_FLUORIDE);
 			MaterialGenerator.generateNuclearMaterial(FLUORIDES.LITHIUM_FLUORIDE);
 			MaterialGenerator.generateNuclearMaterial(FLUORIDES.THORIUM_TETRAFLUORIDE);
@@ -504,6 +503,7 @@ public final class ModItems {
 			
 			
 			//Ores
+			MaterialGenerator.generateOreMaterial(FLUORIDES.FLUORITE);
 			GTplusplus_Secondary.GenerateOreMaterials();
 
 
diff --git a/src/Java/gtPlusPlus/core/material/Material.java b/src/Java/gtPlusPlus/core/material/Material.java
index 751a371bdb..62fd0ebb80 100644
--- a/src/Java/gtPlusPlus/core/material/Material.java
+++ b/src/Java/gtPlusPlus/core/material/Material.java
@@ -661,7 +661,10 @@ public class Material {
 	}
 
 	public final Fluid generateFluid(){
-
+		if (this.materialState == MaterialState.ORE){
+			return null;
+		}
+		
 		final Materials isValid = Materials.get(this.getLocalizedName());
 		Logger.INFO("Is "+this.getLocalizedName()+" a Gregtech material? "+(isValid != null && isValid != Materials._NULL)+" | Found "+isValid.mDefaultLocalName);
 		if (isValid != Materials._NULL){
@@ -781,6 +784,9 @@ public class Material {
 	}
 
 	public final Fluid generatePlasma(){
+		if (this.materialState == MaterialState.ORE){
+			return null;
+		}
 		final Materials isValid = Materials.get(this.getLocalizedName());		
 
 		if (!this.vGenerateCells){
diff --git a/src/Java/gtPlusPlus/core/material/MaterialGenerator.java b/src/Java/gtPlusPlus/core/material/MaterialGenerator.java
index cfb6fbf9ee..f1acdb2308 100644
--- a/src/Java/gtPlusPlus/core/material/MaterialGenerator.java
+++ b/src/Java/gtPlusPlus/core/material/MaterialGenerator.java
@@ -132,18 +132,7 @@ public class MaterialGenerator {
 				return true;
 			}
 			else if (matInfo.getState() == MaterialState.ORE){
-					if (sRadiation >= 1){
-						Item temp;
-						Block tempBlock;
-						//tempBlock = new BlockBaseModular(matInfo ,BlockTypes.ORE, Colour);
-						tempBlock = new BlockBaseOre(matInfo ,BlockTypes.ORE, Colour);
-						
-
-						temp = new BaseItemDust("itemDust"+unlocalizedName, materialName, matInfo, Colour, "Dust", materialTier, sRadiation);
-						temp = new BaseItemDust("itemDustTiny"+unlocalizedName, materialName, matInfo, Colour, "Tiny", materialTier, sRadiation);
-						temp = new BaseItemDust("itemDustSmall"+unlocalizedName, materialName, matInfo, Colour, "Small", materialTier, sRadiation);
-						temp = new BaseItemCrushedOre(matInfo);
-					}
+					
 			}
 
 			//Add A jillion Recipes - old code
@@ -237,29 +226,28 @@ public class MaterialGenerator {
 			Logger.WARNING(""+matInfo.getLocalizedName()+" failed to generate.");
 		}
 	}
-	
-
-	public static void generateOreMaterial(final Material matInfo){
-		generateOreMaterial(matInfo, true);
-	}
 
 	@SuppressWarnings("unused")
-	public static void generateOreMaterial(final Material matInfo, final boolean generatePlates){
+	public static void generateOreMaterial(final Material matInfo){
 		try {
 			final String unlocalizedName = matInfo.getUnlocalizedName();
 			final String materialName = matInfo.getLocalizedName();
 			final short[] C = matInfo.getRGBA();
-			final int Colour = Utils.rgbtoHexValue(C[0], C[1], C[2]);
+			final Integer Colour = Utils.rgbtoHexValue(C[0], C[1], C[2]);
 
 			int sRadiation = 0;
-			if (matInfo.vRadiationLevel != 0){
+			if (matInfo.vRadiationLevel > 0){
 				sRadiation = matInfo.vRadiationLevel;
 			}
 
 			Item temp;
 			Block tempBlock;
+			
+			if (matInfo == null || Colour == null){
+				Logger.DEBUG_MATERIALS("Invalid Material while constructing "+materialName+".");
+			}
 
-			tempBlock = new BlockBaseOre(matInfo ,BlockTypes.ORE, Colour);			
+			tempBlock = new BlockBaseOre(matInfo, BlockTypes.ORE, Colour.intValue());			
 
 			temp = new BaseItemDust("itemDust"+unlocalizedName, materialName, matInfo, Colour, "Dust", matInfo.vTier, sRadiation, false);
 			temp = new BaseItemDust("itemDustTiny"+unlocalizedName, materialName, matInfo, Colour, "Tiny", matInfo.vTier, sRadiation, false);
@@ -273,7 +261,8 @@ public class MaterialGenerator {
 			RecipeGen_Ore.generateRecipes(matInfo);
 			
 		} catch (final Throwable t){
-			Logger.WARNING(""+matInfo.getLocalizedName()+" failed to generate.");
+			Logger.MATERIALS("[Error] "+matInfo.getLocalizedName()+" failed to generate.");
+			t.printStackTrace();
 		}
 	}
 
diff --git a/src/Java/gtPlusPlus/core/material/ORES.java b/src/Java/gtPlusPlus/core/material/ORES.java
index 346934060f..6812c0a293 100644
--- a/src/Java/gtPlusPlus/core/material/ORES.java
+++ b/src/Java/gtPlusPlus/core/material/ORES.java
@@ -6,7 +6,7 @@ public final class ORES {
 
 	public static final Material GEIKIELITE = new Material(
 			"Geikielite", //Material Name
-			MaterialState.SOLID, //State
+			MaterialState.ORE, //State
 			new short[]{187, 193, 204, 0}, //Material Colour
 			500,
 			1500,
@@ -21,7 +21,7 @@ public final class ORES {
 
 	public static final Material ZIMBABWEITE = new Material(
 			"Zimbabweite", //Material Name
-			MaterialState.SOLID, //State
+			MaterialState.ORE, //State
 			new short[]{193, 187, 131, 0}, //Material Colour
 			500,
 			1500,
@@ -38,10 +38,10 @@ public final class ORES {
 					new MaterialStack(ELEMENT.getInstance().TITANIUM, 4),
 					new MaterialStack(ELEMENT.getInstance().OXYGEN, 18)
 			});	
-	
+
 	public static final Material TITANITE = new Material(
 			"Titanite", //Material Name
-			MaterialState.SOLID, //State
+			MaterialState.ORE, //State
 			new short[]{184, 198, 105, 0}, //Material Colour
 			500,
 			1500,
@@ -55,10 +55,10 @@ public final class ORES {
 					new MaterialStack(ELEMENT.getInstance().THORIUM, 1),
 					new MaterialStack(ELEMENT.getInstance().OXYGEN, 10)
 			});	
-	
+
 	public static final Material ZIRCONILITE = new Material(
 			"Zirconolite", //Material Name
-			MaterialState.SOLID, //State
+			MaterialState.ORE, //State
 			new short[]{45, 26, 0, 0}, //Material Colour
 			500,
 			1500,
@@ -72,10 +72,10 @@ public final class ORES {
 					new MaterialStack(ELEMENT.getInstance().CERIUM, 1),
 					new MaterialStack(ELEMENT.getInstance().OXYGEN, 14)
 			});	
-	
+
 	public static final Material CROCROITE = new Material(
 			"Crocoite", //Material Name
-			MaterialState.SOLID, //State
+			MaterialState.ORE, //State
 			new short[]{255, 143, 84, 0}, //Material Colour
 			500,
 			1500,
@@ -87,10 +87,10 @@ public final class ORES {
 					new MaterialStack(ELEMENT.getInstance().CHROMIUM, 1),
 					new MaterialStack(ELEMENT.getInstance().OXYGEN, 4)
 			});	
-	
+
 	public static final Material NICHROMITE = new Material(
 			"Nichromite", //Material Name
-			MaterialState.SOLID, //State
+			MaterialState.ORE, //State
 			new short[]{22, 19, 19, 0}, //Material Colour
 			500,
 			1500,
@@ -105,4 +105,184 @@ public final class ORES {
 					new MaterialStack(ELEMENT.getInstance().CHROMIUM, 2),
 					new MaterialStack(ELEMENT.getInstance().OXYGEN, 8)
 			});	
+
+	public static final Material YTTRIAITE = new Material(
+			"Yttriaite", //Material Name
+			MaterialState.ORE, //State
+			new short[]{255, 143, 84, 0}, //Material Colour
+			500,
+			1500,
+			50,
+			75,
+			0, //Radiation
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.getInstance().YTTRIUM, 1), //Y not YT/YB
+					new MaterialStack(ELEMENT.getInstance().OXYGEN, 3)
+			});	
+
+	//Samarskite_Y
+	public static final Material SAMARSKITE_Y = new Material(
+			"Samarskite (Y)", //Material Name
+			MaterialState.ORE, //State
+			new short[]{65, 163, 164, 0}, //Material Colour
+			500,
+			1500,
+			50,
+			75,
+			1, //Radiation
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.getInstance().YTTRIUM, 2), //Y not YT/YB
+					new MaterialStack(ELEMENT.getInstance().IRON, 10),
+					new MaterialStack(ELEMENT.getInstance().URANIUM235, 2),
+					new MaterialStack(ELEMENT.getInstance().THORIUM, 3),
+					new MaterialStack(ELEMENT.getInstance().NIOBIUM, 2),
+					new MaterialStack(ELEMENT.getInstance().TANTALUM, 3)
+			});
+
+	//Samarskite_YB
+	public static final Material SAMARSKITE_YB = new Material(
+			"Samarskite (Yb)", //Material Name
+			MaterialState.ORE, //State
+			new short[]{95, 193, 194, 0}, //Material Colour
+			500,
+			1500,
+			50,
+			75,
+			1, //Radiation
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.getInstance().YTTERBIUM, 2), //Y not YT/YB
+					new MaterialStack(ELEMENT.getInstance().IRON, 9),
+					new MaterialStack(ELEMENT.getInstance().URANIUM235, 3),
+					new MaterialStack(ELEMENT.getInstance().THORIUM, 2),
+					new MaterialStack(ELEMENT.getInstance().NIOBIUM, 3),
+					new MaterialStack(ELEMENT.getInstance().TANTALUM, 2)
+			});
+
+	public static final Material ZIRCON = new Material(
+			"Zircon", //Material Name
+			MaterialState.ORE, //State
+			new short[]{195, 19, 19, 0}, //Material Colour
+			500,
+			1500,
+			50,
+			75,
+			0, //Radiation
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.getInstance().ZIRCONIUM, 1),
+					new MaterialStack(ELEMENT.getInstance().SILICON, 1),
+					new MaterialStack(ELEMENT.getInstance().OXYGEN, 4),
+			});
+
+	//Gadolinite_Ce
+	public static final Material GADOLINITE_CE = new Material(
+			"Gadolinite (Ce)", //Material Name
+			MaterialState.ORE, //State
+			new short[]{15, 159, 59, 0}, //Material Colour
+			500,
+			1500,
+			50,
+			75,
+			0, //Radiation
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.getInstance().CERIUM, 4),
+					new MaterialStack(ELEMENT.getInstance().LANTHANUM, 2),
+					new MaterialStack(ELEMENT.getInstance().NEODYMIUM, 2),
+					new MaterialStack(ELEMENT.getInstance().YTTRIUM, 2),
+					new MaterialStack(ELEMENT.getInstance().IRON, 1),
+					new MaterialStack(ELEMENT.getInstance().BERYLLIUM, 2),
+					new MaterialStack(ELEMENT.getInstance().SILICON, 7),
+					new MaterialStack(ELEMENT.getInstance().OXYGEN, 14),
+			});
+
+	//Gadolinite_Y
+	public static final Material GADOLINITE_Y = new Material(
+			"Gadolinite (Y)", //Material Name
+			MaterialState.ORE, //State
+			new short[]{35, 189, 99, 0}, //Material Colour
+			500,
+			1500,
+			50,
+			75,
+			0, //Radiation
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.getInstance().CERIUM, 2),
+					new MaterialStack(ELEMENT.getInstance().LANTHANUM, 2),
+					new MaterialStack(ELEMENT.getInstance().NEODYMIUM, 2),
+					new MaterialStack(ELEMENT.getInstance().YTTRIUM, 4),
+					new MaterialStack(ELEMENT.getInstance().IRON, 2),
+					new MaterialStack(ELEMENT.getInstance().BERYLLIUM, 3),
+					new MaterialStack(ELEMENT.getInstance().SILICON, 4),
+					new MaterialStack(ELEMENT.getInstance().OXYGEN, 9),
+			});
+
+	public static final Material LEPERSONNITE = new Material(
+			"Lepersonnite", //Material Name
+			MaterialState.ORE, //State
+			new short[]{175, 175, 20, 0}, //Material Colour
+			500,
+			1500,
+			50,
+			75,
+			0, //Radiation
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.getInstance().CALCIUM, 1),
+					new MaterialStack(ELEMENT.getInstance().GADOLINIUM, 2),
+					new MaterialStack(ELEMENT.getInstance().DYSPROSIUM, 2),
+					new MaterialStack(ELEMENT.getInstance().URANIUM235, 2),
+					new MaterialStack(ELEMENT.getInstance().OXYGEN,32),
+					new MaterialStack(ELEMENT.getInstance().HYDROGEN, 24)
+			});
+
+	public static final Material XENOTIME = new Material(
+			"Xenotime", //Material Name
+			MaterialState.ORE, //State
+			new short[]{235, 89, 199, 0}, //Material Colour
+			500,
+			1500,
+			50,
+			75,
+			0, //Radiation
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.getInstance().YTTRIUM, 1),
+					new MaterialStack(ELEMENT.getInstance().PHOSPHORUS, 1),
+					new MaterialStack(ELEMENT.getInstance().OXYGEN, 4)
+			});
+
+	public static final Material YTTRIALITE = new Material(
+			"Yttrialite", //Material Name
+			MaterialState.ORE, //State
+			new short[]{35, 189, 99, 0}, //Material Colour
+			500,
+			1500,
+			50,
+			75,
+			0, //Radiation
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.getInstance().YTTRIUM, 2),
+					new MaterialStack(ELEMENT.getInstance().THORIUM, 2),
+					new MaterialStack(ELEMENT.getInstance().SILICON, 2),
+					new MaterialStack(ELEMENT.getInstance().OXYGEN, 7),
+			});
+
+	public static final Material YTTROCERITE = new Material(
+			"Yttrocerite", //Material Name
+			MaterialState.ORE, //State
+			new short[]{35, 19, 199, 0}, //Material Colour
+			500,
+			1500,
+			50,
+			75,
+			0, //Radiation
+			new MaterialStack[]{
+					new MaterialStack(ELEMENT.getInstance().CERIUM, 1),
+					new MaterialStack(ELEMENT.getInstance().CALCIUM, 1),
+					new MaterialStack(ELEMENT.getInstance().FLUORINE, 5),
+					new MaterialStack(ELEMENT.getInstance().YTTRIUM, 1),
+			});
+
+
+
+
+
+
 }
diff --git a/src/Java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java b/src/Java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java
index a9d2bcef32..a95e972139 100644
--- a/src/Java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java
+++ b/src/Java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java
@@ -17,6 +17,7 @@ import gtPlusPlus.core.item.ModItems;
 import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.core.lib.LoadedMods;
 import gtPlusPlus.core.material.ALLOY;
+import gtPlusPlus.core.material.nuclear.FLUORIDES;
 import gtPlusPlus.core.material.nuclear.NUCLIDE;
 import gtPlusPlus.core.recipe.common.CI;
 import gtPlusPlus.core.util.fluid.FluidUtils;
@@ -1079,8 +1080,8 @@ public class RECIPES_GREGTECH {
 				ItemUtils.getItemStackOfAmountFromOreDict("pelletZirconium", 1),
 				ItemUtils.getItemStackOfAmountFromOreDict("dustZrCl4", 1));
 		GT_ModHandler.addPulverisationRecipe(
-				ItemUtils.getSimpleStack(Item.getItemFromBlock(ModBlocks.blockOreFluorite)),
-				ItemUtils.getItemStackOfAmountFromOreDict("dustFluorite", 4));
+				FLUORIDES.FLUORITE.getOre(1),
+				FLUORIDES.FLUORITE.getDust(4));
 
 		if (ItemUtils.simpleMetaStack("chisel:limestone", 0, 1) != null){
 			GT_ModHandler.addPulverisationRecipe(
diff --git a/src/Java/gtPlusPlus/core/recipe/RECIPES_General.java b/src/Java/gtPlusPlus/core/recipe/RECIPES_General.java
index 9e9482932d..22a686c10a 100644
--- a/src/Java/gtPlusPlus/core/recipe/RECIPES_General.java
+++ b/src/Java/gtPlusPlus/core/recipe/RECIPES_General.java
@@ -10,6 +10,7 @@ import gtPlusPlus.core.block.ModBlocks;
 import gtPlusPlus.core.item.ModItems;
 import gtPlusPlus.core.lib.CORE;
 import gtPlusPlus.core.lib.LoadedMods;
+import gtPlusPlus.core.material.nuclear.FLUORIDES;
 import gtPlusPlus.core.recipe.common.CI;
 import gtPlusPlus.core.util.item.ItemUtils;
 import gtPlusPlus.core.util.recipe.RecipeUtils;
@@ -40,6 +41,7 @@ public class RECIPES_General {
 			RECIPE_BasicCasingIC2 = ItemUtils.getItemStack("IC2:blockMachine", 1);
 			run();
 			addCompressedObsidian();
+			addFluoriteFix();
 		}
 	}
 
@@ -241,6 +243,10 @@ public class RECIPES_General {
 		}
 		return true;
 	}
+	
+	private static boolean addFluoriteFix(){
+		return RecipeUtils.addShapelessGregtechRecipe(new ItemStack[]{ItemUtils.getSimpleStack(ModBlocks.blockOreFluorite)}, FLUORIDES.FLUORITE.getOre(1));
+	}
 
 }
 
diff --git a/src/Java/gtPlusPlus/core/world/darkworld/biome/BiomeGenerator_Custom.java b/src/Java/gtPlusPlus/core/world/darkworld/biome/BiomeGenerator_Custom.java
index 0dc84b8aa3..74a67dfc5e 100644
--- a/src/Java/gtPlusPlus/core/world/darkworld/biome/BiomeGenerator_Custom.java
+++ b/src/Java/gtPlusPlus/core/world/darkworld/biome/BiomeGenerator_Custom.java
@@ -112,7 +112,7 @@ public class BiomeGenerator_Custom extends BiomeDecorator {
         this.redstoneGen = new WorldGenMinable_Custom(Blocks.redstone_ore, 10);
         this.diamondGen = new WorldGenMinable_Custom(Blocks.diamond_ore, 12);
         this.lapisGen = new WorldGenMinable_Custom(Blocks.lapis_ore, 8);
-        this.fluoriteGen = new WorldGenMinable_Custom(ModBlocks.blockOreFluorite, 20);
+        // this.fluoriteGen = new WorldGenMinable_Custom(ModBlocks.blockOreFluorite, 20);
         
         //Nature
         this.yellowFlowerGen = new WorldGenFlowers(Blocks.yellow_flower);
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Ore.java b/src/Java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Ore.java
index 5be4e13d28..d9e67c16f6 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Ore.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_Ore.java
@@ -40,13 +40,13 @@ public class RecipeGen_Ore implements Runnable{
 			Material bonusB; //Tin
 			
 			if (material.getComposites().get(0) != null){
-				bonusA = material.getComposites().get(1).getStackMaterial();
+				bonusA = material.getComposites().get(0).getStackMaterial();
 			}
 			else {
 				return ;
 			}
-			if (material.getComposites().get(1) != null){
-				bonusB = material.getComposites().get(2).getStackMaterial();
+			if (material.getComposites().size() >= 1 && material.getComposites().get(1) != null){
+				bonusB = material.getComposites().get(1).getStackMaterial();
 			}
 			else if (material.getComposites().get(0) != null){
 				bonusB = material.getComposites().get(0).getStackMaterial();