Merge pull request #24 from GTNewHorizons/experimental

update

19 files changed, 1226 insertions, 281 deletions

diff --git a/src/main/java/gregtech/GT_Mod.java b/src/main/java/gregtech/GT_Mod.java
index 858f8c87f8..4115e61251 100644
--- a/src/main/java/gregtech/GT_Mod.java
+++ b/src/main/java/gregtech/GT_Mod.java
@@ -323,6 +323,8 @@ public class GT_Mod implements IGT_Mod {
                     tDye.mRGBa[2] = ((short) Math.min(255, Math.max(0, GregTech_API.sClientDataFile.get(SBdye1, "B", tDye.mRGBa[2]))));
                 }
         );
+        gregtechproxy.mRenderTileAmbientOcclusion = GregTech_API.sClientDataFile.get("render", "TileAmbientOcclusion", true);
+
         gregtechproxy.mMaxEqualEntitiesAtOneSpot = tMainConfig.get(aTextGeneral, "MaxEqualEntitiesAtOneSpot", 3).getInt(3);
         gregtechproxy.mSkeletonsShootGTArrows = tMainConfig.get(aTextGeneral, "SkeletonsShootGTArrows", 16).getInt(16);
         gregtechproxy.mFlintChance = tMainConfig.get(aTextGeneral, "FlintAndSteelChance", 30).getInt(30);
diff --git a/src/main/java/gregtech/api/GregTech_API.java b/src/main/java/gregtech/api/GregTech_API.java
index 0fbb1cd745..e24297c48c 100644
--- a/src/main/java/gregtech/api/GregTech_API.java
+++ b/src/main/java/gregtech/api/GregTech_API.java
@@ -739,4 +739,23 @@ public class GregTech_API {
         sToolList.add(new GT_ItemStack(GT_Utility.copyAmount(1, aTool)));
         return true;
     }
+
+    /**
+     * Sets the {@link IIconRegister} for Block Icons
+     * @param aIconRegister The {@link IIconRegister} Icon Register
+     */
+    @SideOnly(Side.CLIENT)
+    public static void setBlockIconRegister(IIconRegister aIconRegister) {
+        sBlockIcons = aIconRegister;
+    };
+
+    /**
+     * Sets the {@link IIconRegister} for Items Icons
+     * @param aIconRegister The {@link IIconRegister} Icon Register
+     */
+    @SideOnly(Side.CLIENT)
+    public static void setItemIconRegister(IIconRegister aIconRegister) {
+        GregTech_API.sItemIcons = aIconRegister;
+    }
+
 }
diff --git a/src/main/java/gregtech/api/gui/GT_Container_BasicMachine.java b/src/main/java/gregtech/api/gui/GT_Container_BasicMachine.java
index 38f8bd3b35..28fd2983f4 100644
--- a/src/main/java/gregtech/api/gui/GT_Container_BasicMachine.java
+++ b/src/main/java/gregtech/api/gui/GT_Container_BasicMachine.java
@@ -212,14 +212,17 @@ public class GT_Container_BasicMachine extends GT_Container_BasicTank {
                     if (tStackSizedOne == null || tStackHeld.stackSize == 0) return null;
                     FluidStack tInputFluid = machine.getFillableStack();
                     FluidStack tFluidHeld = GT_Utility.getFluidForFilledItem(tStackSizedOne, true);
+                    if (tFluidHeld != null && tFluidHeld.amount <= 0)
+                        tFluidHeld = null;
                     if (tInputFluid == null) {
                         if (tFluidHeld == null)
                             // both null -> no op
                             return null;
                         return fillFluid(machine, aPlayer, tFluidHeld, aMouseclick == 0);
                     } else {
-                        if (tFluidHeld != null) {
-                            // both nonnull. actually both pickup and fill is reasonable, but I'll go with fill here
+                        if (tFluidHeld != null && tInputFluid.amount < machine.getCapacity()) {
+                            // both nonnull and have space left for filling.
+                            // actually both pickup and fill is reasonable, but I'll go with fill here
                             return fillFluid(machine, aPlayer, tFluidHeld, aMouseclick == 0);
                         } else {
                             tResultStack = pickupFluid(tInputFluid, aPlayer, aMouseclick == 0);
diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_OutputBus.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_OutputBus.java
index aaa0dc9df5..9c227b8da7 100644
--- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_OutputBus.java
+++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_OutputBus.java
@@ -24,6 +24,10 @@ public class GT_MetaTileEntity_Hatch_OutputBus extends GT_MetaTileEntity_Hatch {
         super(aID, aName, aNameRegional, aTier, getSlots(aTier), aDescription);
     }
 
+    public GT_MetaTileEntity_Hatch_OutputBus(int aID, String aName, String aNameRegional, int aTier, String[] aDescription, int inventorySize) {
+        super(aID, aName, aNameRegional, aTier, inventorySize, aDescription);
+    }
+
     public GT_MetaTileEntity_Hatch_OutputBus(String aName, int aTier, String aDescription, ITexture[][][] aTextures) {
         super(aName, aTier, aTier < 1 ? 1 : aTier == 1 ? 4 : aTier == 2 ? 9 : 16, aDescription, aTextures);
     }
@@ -32,6 +36,10 @@ public class GT_MetaTileEntity_Hatch_OutputBus extends GT_MetaTileEntity_Hatch {
         super(aName, aTier, aTier < 1 ? 1 : aTier == 1 ? 4 : aTier == 2 ? 9 : 16, aDescription, aTextures);
     }
 
+    public GT_MetaTileEntity_Hatch_OutputBus(String aName, int aTier, String[] aDescription, int inventorySize, ITexture[][][] aTextures) {
+        super(aName, aTier, inventorySize, aDescription, aTextures);
+    }
+
     @Override
     public ITexture[] getTexturesActive(ITexture aBaseTexture) {
         return new ITexture[]{aBaseTexture, new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE_OUT)};
diff --git a/src/main/java/gregtech/api/objects/GT_CopiedBlockTexture.java b/src/main/java/gregtech/api/objects/GT_CopiedBlockTexture.java
index e7138d04ed..b31149e8de 100644
--- a/src/main/java/gregtech/api/objects/GT_CopiedBlockTexture.java
+++ b/src/main/java/gregtech/api/objects/GT_CopiedBlockTexture.java
@@ -2,10 +2,12 @@ package gregtech.api.objects;
 
 import gregtech.api.enums.Dyes;
 import gregtech.api.interfaces.ITexture;
+import gregtech.api.util.LightingHelper;
 import net.minecraft.block.Block;
 import net.minecraft.client.renderer.RenderBlocks;
 import net.minecraft.client.renderer.Tessellator;
 import net.minecraft.util.IIcon;
+import net.minecraftforge.common.util.ForgeDirection;
 
 public class GT_CopiedBlockTexture implements ITexture {
     private final Block mBlock;
@@ -43,46 +45,58 @@ public class GT_CopiedBlockTexture implements ITexture {
 
     @Override
     public void renderXPos(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) {
-        IIcon aIcon = getIcon(5);
-        Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 0.6F), (int) (mRGBa[1] * 0.6F), (int) (mRGBa[2] * 0.6F), mAllowAlpha ? 255 - mRGBa[3] : 255);
+        IIcon aIcon = getIcon(ForgeDirection.EAST.ordinal());
         aRenderer.field_152631_f = true;
+        new LightingHelper(aRenderer)
+                .setupLightingXPos(aBlock, aX, aY, aZ)
+                .setupColor(ForgeDirection.EAST.ordinal(), 0xffffff);
         aRenderer.renderFaceXPos(aBlock, aX, aY, aZ, aIcon);
         aRenderer.field_152631_f = false;
     }
 
     @Override
     public void renderXNeg(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) {
-        IIcon aIcon = getIcon(4);
-        Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 0.6F), (int) (mRGBa[1] * 0.6F), (int) (mRGBa[2] * 0.6F), mAllowAlpha ? 255 - mRGBa[3] : 255);
+        IIcon aIcon = getIcon(ForgeDirection.WEST.ordinal());
+        new LightingHelper(aRenderer)
+                .setupLightingXNeg(aBlock, aX, aY, aZ)
+                .setupColor(ForgeDirection.WEST.ordinal(), 0xffffff);
         aRenderer.renderFaceXNeg(aBlock, aX, aY, aZ, aIcon);
     }
 
     @Override
     public void renderYPos(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) {
-        IIcon aIcon = getIcon(1);
-        Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 1.0F), (int) (mRGBa[1] * 1.0F), (int) (mRGBa[2] * 1.0F), mAllowAlpha ? 255 - mRGBa[3] : 255);
+        IIcon aIcon = getIcon(ForgeDirection.UP.ordinal());
+            new LightingHelper(aRenderer)
+                    .setupLightingYPos(aBlock, aX, aY, aZ)
+                    .setupColor(ForgeDirection.UP.ordinal(), 0xffffff);
         aRenderer.renderFaceYPos(aBlock, aX, aY, aZ, aIcon);
     }
 
     @Override
     public void renderYNeg(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) {
-        IIcon aIcon = getIcon(0);
-        Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 0.5F), (int) (mRGBa[1] * 0.5F), (int) (mRGBa[2] * 0.5F), mAllowAlpha ? 255 - mRGBa[3] : 255);
+        IIcon aIcon = getIcon(ForgeDirection.DOWN.ordinal());
+        new LightingHelper(aRenderer)
+                .setupLightingYNeg(aBlock, aX, aY, aZ)
+                .setupColor(ForgeDirection.DOWN.ordinal(), 0xffffff);
         aRenderer.renderFaceYNeg(aBlock, aX, aY, aZ, aIcon);
     }
 
     @Override
     public void renderZPos(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) {
-        IIcon aIcon = getIcon(3);
-        Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 0.8F), (int) (mRGBa[1] * 0.8F), (int) (mRGBa[2] * 0.8F), mAllowAlpha ? 255 - mRGBa[3] : 255);
+        IIcon aIcon = getIcon(ForgeDirection.SOUTH.ordinal());
+        new LightingHelper(aRenderer)
+                .setupLightingZPos(aBlock, aX, aY, aZ)
+                .setupColor(ForgeDirection.SOUTH.ordinal(), 0xffffff);
         aRenderer.renderFaceZPos(aBlock, aX, aY, aZ, aIcon);
     }
 
     @Override
     public void renderZNeg(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) {
-        IIcon aIcon = getIcon(2);
-        Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 0.8F), (int) (mRGBa[1] * 0.8F), (int) (mRGBa[2] * 0.8F), mAllowAlpha ? 255 - mRGBa[3] : 255);
+        IIcon aIcon = getIcon(ForgeDirection.NORTH.ordinal());
         aRenderer.field_152631_f = true;
+        new LightingHelper(aRenderer)
+                .setupLightingZNeg(aBlock, aX, aY, aZ)
+                .setupColor(ForgeDirection.NORTH.ordinal(), 0xffffff);
         aRenderer.renderFaceZNeg(aBlock, aX, aY, aZ, aIcon);
         aRenderer.field_152631_f = false;
     }
diff --git a/src/main/java/gregtech/api/objects/GT_RenderedTexture.java b/src/main/java/gregtech/api/objects/GT_RenderedTexture.java
index bbfc90fa6f..b1e014af01 100644
--- a/src/main/java/gregtech/api/objects/GT_RenderedTexture.java
+++ b/src/main/java/gregtech/api/objects/GT_RenderedTexture.java
@@ -4,10 +4,12 @@ import gregtech.api.enums.Dyes;
 import gregtech.api.interfaces.IColorModulationContainer;
 import gregtech.api.interfaces.IIconContainer;
 import gregtech.api.interfaces.ITexture;
+import gregtech.api.util.LightingHelper;
 import net.minecraft.block.Block;
 import net.minecraft.client.renderer.RenderBlocks;
 import net.minecraft.client.renderer.Tessellator;
 import net.minecraft.util.IIcon;
+import net.minecraftforge.common.util.ForgeDirection;
 
 public class GT_RenderedTexture implements ITexture, IColorModulationContainer {
     final IIconContainer mIconContainer;
@@ -37,36 +39,38 @@ public class GT_RenderedTexture implements ITexture, IColorModulationContainer {
 
     @Override
     public void renderXPos(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) {
-        final Tessellator tessellator = Tessellator.instance;
-        tessellator.setColorRGBA((int) (mRGBa[0] * 0.6F), (int) (mRGBa[1] * 0.6F), (int) (mRGBa[2] * 0.6F), mAllowAlpha ? 255 - mRGBa[3] : 255);
         aRenderer.field_152631_f = true;
+        LightingHelper lighting = new LightingHelper(aRenderer);
+        lighting.setupLightingXPos(aBlock, aX, aY, aZ)
+                .setupColor(ForgeDirection.EAST.ordinal(), mRGBa);
         aRenderer.renderFaceXPos(aBlock, aX, aY, aZ, mIconContainer.getIcon());
         if (mIconContainer.getOverlayIcon() != null) {
-            tessellator.setColorRGBA(153, 153, 153, 255);
+            lighting.setupColor(ForgeDirection.EAST.ordinal(), 0xffffff);
             aRenderer.renderFaceXPos(aBlock, aX, aY, aZ, mIconContainer.getOverlayIcon());
         }
         aRenderer.field_152631_f = false;
     }
 
-
     @Override
     public void renderXNeg(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) {
-        final Tessellator tessellator = Tessellator.instance;
-        tessellator.setColorRGBA((int) (mRGBa[0] * 0.6F), (int) (mRGBa[1] * 0.6F), (int) (mRGBa[2] * 0.6F), mAllowAlpha ? 255 - mRGBa[3] : 255);
+        LightingHelper lighting = new LightingHelper(aRenderer);
+        lighting.setupLightingXNeg(aBlock, aX, aY, aZ)
+                .setupColor(ForgeDirection.WEST.ordinal(), mRGBa);
         aRenderer.renderFaceXNeg(aBlock, aX, aY, aZ, mIconContainer.getIcon());
         if (mIconContainer.getOverlayIcon() != null) {
-            tessellator.setColorRGBA(153, 153, 153, 255);
+            lighting.setupColor(ForgeDirection.WEST.ordinal(), 0xffffff);
             aRenderer.renderFaceXNeg(aBlock, aX, aY, aZ, mIconContainer.getOverlayIcon());
         }
     }
 
     @Override
     public void renderYPos(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) {
-        final Tessellator tessellator = Tessellator.instance;
-        tessellator.setColorRGBA((int) (mRGBa[0] * 1.0F), (int) (mRGBa[1] * 1.0F), (int) (mRGBa[2] * 1.0F), mAllowAlpha ? 255 - mRGBa[3] : 255);
+        LightingHelper lighting = new LightingHelper(aRenderer);
+        lighting.setupLightingYPos(aBlock, aX, aY, aZ)
+                .setupColor(ForgeDirection.UP.ordinal(), mRGBa);
         aRenderer.renderFaceYPos(aBlock, aX, aY, aZ, mIconContainer.getIcon());
         if (mIconContainer.getOverlayIcon() != null) {
-            tessellator.setColorRGBA(255, 255, 255, 255);
+            lighting.setupColor(ForgeDirection.UP.ordinal(), 0xffffff);
             aRenderer.renderFaceYPos(aBlock, aX, aY, aZ, mIconContainer.getOverlayIcon());
         }
     }
@@ -74,7 +78,6 @@ public class GT_RenderedTexture implements ITexture, IColorModulationContainer {
     @Override
     public void renderYNeg(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) {
         final Tessellator tessellator = Tessellator.instance;
-        tessellator.setColorRGBA((int) (mRGBa[0] * 0.5F), (int) (mRGBa[1] * 0.5F), (int) (mRGBa[2] * 0.5F), mAllowAlpha ? 255 - mRGBa[3] : 255);
         IIcon aIcon = mIconContainer.getIcon();
 
         float minU = aIcon.getInterpolatedU((1.0D - aRenderer.renderMaxX) * 16.0D);
@@ -98,13 +101,30 @@ public class GT_RenderedTexture implements ITexture, IColorModulationContainer {
         double minZ = aZ + aRenderer.renderMinZ;
         double maxZ = aZ + aRenderer.renderMaxZ;
 
-        tessellator.addVertexWithUV(minX, minY, maxZ, maxU, maxV);
-        tessellator.addVertexWithUV(minX, minY, minZ, maxU, minV);
-        tessellator.addVertexWithUV(maxX, minY, minZ, minU, minV);
+        LightingHelper lighting = new LightingHelper(aRenderer);
+        lighting.setupLightingYNeg(aBlock, aX, aY, aZ)
+                .setupColor(ForgeDirection.DOWN.ordinal(), mRGBa);
+
+        if (aRenderer.enableAO) {
+            tessellator.setColorOpaque_F(aRenderer.colorRedTopLeft, aRenderer.colorGreenTopLeft, aRenderer.colorBlueTopLeft);
+            tessellator.setBrightness(aRenderer.brightnessTopLeft);
+            tessellator.addVertexWithUV(minX, minY, maxZ, maxU, maxV);
+            tessellator.setColorOpaque_F(aRenderer.colorRedBottomLeft, aRenderer.colorGreenBottomLeft, aRenderer.colorBlueBottomLeft);
+            tessellator.setBrightness(aRenderer.brightnessBottomLeft);
+            tessellator.addVertexWithUV(minX, minY, minZ, maxU, minV);
+            tessellator.setColorOpaque_F(aRenderer.colorRedBottomRight, aRenderer.colorGreenBottomRight, aRenderer.colorBlueBottomRight);
+            tessellator.setBrightness(aRenderer.brightnessBottomRight);
+            tessellator.addVertexWithUV(maxX, minY, minZ, minU, minV);
+            tessellator.setColorOpaque_F(aRenderer.colorRedTopRight, aRenderer.colorGreenTopRight, aRenderer.colorBlueTopRight);
+            tessellator.setBrightness(aRenderer.brightnessTopRight);
+        } else {
+            tessellator.addVertexWithUV(minX, minY, maxZ, maxU, maxV);
+            tessellator.addVertexWithUV(minX, minY, minZ, maxU, minV);
+            tessellator.addVertexWithUV(maxX, minY, minZ, minU, minV);
+        }
         tessellator.addVertexWithUV(maxX, minY, maxZ, minU, maxV);
-        if (mIconContainer.getOverlayIcon() != null) {
-            tessellator.setColorRGBA(128, 128, 128, 255);
 
+        if (mIconContainer.getOverlayIcon() != null) {
             minU = aIcon.getInterpolatedU((1.0D - aRenderer.renderMaxX) * 16.0D);
             maxU = aIcon.getInterpolatedU((1.0D - aRenderer.renderMinX) * 16.0D);
             minV = aIcon.getInterpolatedV(aRenderer.renderMinZ * 16.0D);
@@ -126,32 +146,50 @@ public class GT_RenderedTexture implements ITexture, IColorModulationContainer {
             minZ = aZ + (float)aRenderer.renderMinZ;
             maxZ = aZ + (float)aRenderer.renderMaxZ;
 
-            tessellator.addVertexWithUV(minX, minY, maxZ, maxU, maxV);
-            tessellator.addVertexWithUV(minX, minY, minZ, maxU, minV);
-            tessellator.addVertexWithUV(maxX, minY, minZ, minU, minV);
+            lighting.setupColor(ForgeDirection.DOWN.ordinal(), 0xffffff);
+
+            if (aRenderer.enableAO) {
+                tessellator.setColorOpaque_F(aRenderer.colorRedTopLeft, aRenderer.colorGreenTopLeft, aRenderer.colorBlueTopLeft);
+                tessellator.setBrightness(aRenderer.brightnessTopLeft);
+                tessellator.addVertexWithUV(minX, minY, maxZ, maxU, maxV);
+                tessellator.setColorOpaque_F(aRenderer.colorRedBottomLeft, aRenderer.colorGreenBottomLeft, aRenderer.colorBlueBottomLeft);
+                tessellator.setBrightness(aRenderer.brightnessBottomLeft);
+                tessellator.addVertexWithUV(minX, minY, minZ, maxU, minV);
+                tessellator.setColorOpaque_F(aRenderer.colorRedBottomRight, aRenderer.colorGreenBottomRight, aRenderer.colorBlueBottomRight);
+                tessellator.setBrightness(aRenderer.brightnessBottomRight);
+                tessellator.addVertexWithUV(maxX, minY, minZ, minU, minV);
+                tessellator.setColorOpaque_F(aRenderer.colorRedTopRight, aRenderer.colorGreenTopRight, aRenderer.colorBlueTopRight);
+                tessellator.setBrightness(aRenderer.brightnessTopRight);
+            } else {
+                tessellator.addVertexWithUV(minX, minY, maxZ, maxU, maxV);
+                tessellator.addVertexWithUV(minX, minY, minZ, maxU, minV);
+                tessellator.addVertexWithUV(maxX, minY, minZ, minU, minV);
+            }
             tessellator.addVertexWithUV(maxX, minY, maxZ, minU, maxV);
         }
     }
 
     @Override
     public void renderZPos(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) {
-        final Tessellator tessellator = Tessellator.instance;
-        tessellator.setColorRGBA((int) (mRGBa[0] * 0.8F), (int) (mRGBa[1] * 0.8F), (int) (mRGBa[2] * 0.8F), mAllowAlpha ? 255 - mRGBa[3] : 255);
+        LightingHelper lighting = new LightingHelper(aRenderer);
+        lighting.setupLightingZPos(aBlock, aX, aY, aZ)
+                .setupColor(ForgeDirection.SOUTH.ordinal(), mRGBa);
         aRenderer.renderFaceZPos(aBlock, aX, aY, aZ, mIconContainer.getIcon());
         if (mIconContainer.getOverlayIcon() != null) {
-            tessellator.setColorRGBA(204, 204, 204, 255);
+            lighting.setupColor(ForgeDirection.SOUTH.ordinal(), 0xffffff);
             aRenderer.renderFaceZPos(aBlock, aX, aY, aZ, mIconContainer.getOverlayIcon());
         }
     }
 
     @Override
     public void renderZNeg(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) {
-        final Tessellator tessellator = Tessellator.instance;
-        tessellator.setColorRGBA((int) (mRGBa[0] * 0.8F), (int) (mRGBa[1] * 0.8F), (int) (mRGBa[2] * 0.8F), mAllowAlpha ? 255 - mRGBa[3] : 255);
         aRenderer.field_152631_f = true;
+        LightingHelper lighting = new LightingHelper(aRenderer);
+        lighting.setupLightingZNeg(aBlock, aX, aY, aZ)
+                .setupColor(ForgeDirection.NORTH.ordinal(), mRGBa);
         aRenderer.renderFaceZNeg(aBlock, aX, aY, aZ, mIconContainer.getIcon());
         if (mIconContainer.getOverlayIcon() != null) {
-            tessellator.setColorRGBA(204, 204, 204, 255);
+            lighting.setupColor(ForgeDirection.NORTH.ordinal(), 0xffffff);
             aRenderer.renderFaceZNeg(aBlock, aX, aY, aZ, mIconContainer.getOverlayIcon());
         }
         aRenderer.field_152631_f = false;
diff --git a/src/main/java/gregtech/api/objects/GT_StdRenderedTexture.java b/src/main/java/gregtech/api/objects/GT_StdRenderedTexture.java
index db475c9561..041fed4164 100644
--- a/src/main/java/gregtech/api/objects/GT_StdRenderedTexture.java
+++ b/src/main/java/gregtech/api/objects/GT_StdRenderedTexture.java
@@ -2,9 +2,10 @@ package gregtech.api.objects;
 
 import gregtech.api.enums.Dyes;
 import gregtech.api.interfaces.IIconContainer;
+import gregtech.api.util.LightingHelper;
 import net.minecraft.block.Block;
 import net.minecraft.client.renderer.RenderBlocks;
-import net.minecraft.client.renderer.Tessellator;
+import net.minecraftforge.common.util.ForgeDirection;
 
 /**
  * This ITexture implementation extends the GT_RenderedTexture class
@@ -30,11 +31,12 @@ public class GT_StdRenderedTexture extends GT_RenderedTexture{
 
     @Override
     public void renderYNeg(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) {
-        final Tessellator tessellator = Tessellator.instance;
-        tessellator.setColorRGBA((int) (mRGBa[0] * 0.5F), (int) (mRGBa[1] * 0.5F), (int) (mRGBa[2] * 0.5F), mAllowAlpha ? 255 - mRGBa[3] : 255);
+        LightingHelper lighting = new LightingHelper(aRenderer);
+        lighting.setupLightingYNeg(aBlock, aX, aY, aZ)
+                .setupColor(ForgeDirection.DOWN.ordinal(), mRGBa);
         aRenderer.renderFaceYNeg(aBlock, aX, aY, aZ, mIconContainer.getIcon());
         if (mIconContainer.getOverlayIcon() != null) {
-            tessellator.setColorRGBA(128, 128, 128, 255);
+            lighting.setupColor(ForgeDirection.DOWN.ordinal(), 0xffffff);
             aRenderer.renderFaceYNeg(aBlock, aX, aY, aZ, mIconContainer.getOverlayIcon());
         }
     }
diff --git a/src/main/java/gregtech/api/util/LightingHelper.java b/src/main/java/gregtech/api/util/LightingHelper.java
new file mode 100644
index 0000000000..df70ffaeef
--- /dev/null
+++ b/src/main/java/gregtech/api/util/LightingHelper.java
@@ -0,0 +1,723 @@
+/*
+ * LightingHelper - Derived and adapted from @Mineshopper / carpentersblocks
+ * Copyright (c) 2013-2021.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package gregtech.api.util;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.EntityRenderer;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+
+@SuppressWarnings("unused")
+@SideOnly(Side.CLIENT)
+public class LightingHelper {
+    public static final int NORMAL_BRIGHTNESS = 0xff00ff;
+    public static final int MAX_BRIGHTNESS = 0xf000f0;
+    protected static final float[] LIGHTNESS = {0.5F, 1.0F, 0.8F, 0.8F, 0.6F, 0.6F};
+    private final RenderBlocks renderBlocks;
+    /**
+     * Brightness for side.
+     */
+    private int brightness;
+    /**
+     * Ambient occlusion values for all four corners of side.
+     */
+    private float aoTopLeft, aoBottomLeft, aoBottomRight, aoTopRight;
+    private boolean hasLightnessOverride;
+    private float lightnessOverride;
+    private boolean hasBrightnessOverride;
+    private int brightnessOverride;
+    private boolean hasColorOverride;
+    private int colorOverride = 0xffffff;
+
+    /**
+     * Class constructor specifying the {@link RenderBlocks}.
+     *
+     * @param renderBlocks the {@link RenderBlocks}
+     */
+    public LightingHelper(RenderBlocks renderBlocks) {
+        this.renderBlocks = renderBlocks;
+    }
+
+    /**
+     * Gets average brightness from two brightness values.
+     *
+     * @param brightnessA the first brightness value
+     * @param brightnessB the second brightness value
+     * @return the mixed brightness
+     */
+    public static int getAverageBrightness(int brightnessA, int brightnessB) {
+        int sectionA1 = brightnessA >> 16 & 0xff;
+        int sectionA2 = brightnessA & 255;
+
+        int sectionB1 = brightnessB >> 16 & 0xff;
+        int sectionB2 = brightnessB & 255;
+
+        int difference1 = (int) ((sectionA1 + sectionB1) / 2.0F);
+        int difference2 = (int) ((sectionA2 + sectionB2) / 2.0F);
+
+        return difference1 << 16 | difference2;
+    }
+
+    /**
+     * Gets rgb color from RGBA array.
+     *
+     * @param color the integer color
+     * @return a float array with rgb values
+     */
+    public static float[] getRGB(short[] color) {
+        float red = color[0] / 255.0F;
+        float green = color[1] / 255.0F;
+        float blue = color[2] / 255.0F;
+
+        return new float[]{red, green, blue};
+    }
+
+    /**
+     * Clears brightness override.
+     */
+    public void clearBrightnessOverride() {
+        hasBrightnessOverride = false;
+    }
+
+    /**
+     * Clears color override.
+     */
+    public void clearColorOverride() {
+        hasColorOverride = false;
+    }
+
+    /**
+     * Clears lightness override.
+     */
+    public void clearLightnessOverride() {
+        hasLightnessOverride = false;
+    }
+
+    /**
+     * @return the Ambient Occlusion for Bottom-Left corner
+     */
+    public float getAoBottomLeft() {
+        return aoBottomLeft;
+    }
+
+    /**
+     * @return the Ambient Occlusion for Bottom-Right corner
+     */
+    public float getAoBottomRight() {
+        return aoBottomRight;
+    }
+
+    /**
+     * @return the Ambient Occlusion for Top-Left corner
+     */
+    public float getAoTopLeft() {
+        return aoTopLeft;
+    }
+
+    /**
+     * @return the Ambient Occlusion for Top-Right corner
+     */
+    public float getAoTopRight() {
+        return aoTopRight;
+    }
+
+    /**
+     * Sets brightness override.
+     *
+     * @param brightness the brightness override
+     * @return the {@link LightingHelper}
+     */
+    public LightingHelper setBrightnessOverride(int brightness) {
+        hasBrightnessOverride = true;
+        brightnessOverride = brightness;
+        return this;
+    }
+
+    public LightingHelper setColorOverride(short[] color) {
+        return setColorOverride(getColor(color));
+    }
+
+    /**
+     * Sets color override.
+     *
+     * @param color the color override
+     * @return the {@link LightingHelper}
+     */
+    public LightingHelper setColorOverride(int color) {
+        hasColorOverride = true;
+        colorOverride = color;
+        return this;
+    }
+
+    /**
+     * Gets int color from RGBA array.
+     *
+     * @param rgba the short RGBA color array
+     * @return int color
+     */
+    public static int getColor(short[] rgba) {
+        return (rgba[2] & 0xff) | (rgba[1] & 0xff) << 8 | (rgba[0] & 0xff) << 16;
+    }
+
+    /**
+     * Sets lightness override.
+     *
+     * @param lightness the lightness override
+     * @return the {@link LightingHelper}
+     */
+    public LightingHelper setLightnessOverride(float lightness) {
+        hasLightnessOverride = true;
+        lightnessOverride = lightness;
+        return this;
+    }
+
+    /**
+     * Sets up the color using lightness, brightness, and the primary color
+     * value (usually the dye color) for the side.
+     *
+     * @param side the side
+     * @param rgba the primary short[] RGBA color array
+     */
+    public void setupColor(int side, short[] rgba) {
+        setupColor(side, getColor(rgba));
+    }
+
+    /**
+     * Sets up the color using lightness, brightness, and the primary color
+     * value (usually the dye color) for the side.
+     *
+     * @param side     the side
+     * @param hexColor the primary color
+     */
+    public void setupColor(int side, int hexColor) {
+        Tessellator tessellator = Tessellator.instance;
+        float lightness = hasLightnessOverride ? lightnessOverride : LIGHTNESS[side];
+        float[] rgb = getRGB(hexColor);
+
+        if (hasColorOverride && !renderBlocks.hasOverrideBlockTexture()) {
+            rgb = getRGB(colorOverride);
+        }
+
+        applyAnaglyph(rgb);
+
+        if (renderBlocks.enableAO) {
+            tessellator.setBrightness(hasBrightnessOverride ? brightnessOverride : brightness);
+
+            if (renderBlocks.hasOverrideBlockTexture()) {
+
+                renderBlocks.colorRedTopLeft = renderBlocks.colorRedBottomLeft = renderBlocks.colorRedBottomRight = renderBlocks.colorRedTopRight = rgb[0];
+                renderBlocks.colorGreenTopLeft = renderBlocks.colorGreenBottomLeft = renderBlocks.colorGreenBottomRight = renderBlocks.colorGreenTopRight = rgb[1];
+                renderBlocks.colorBlueTopLeft = renderBlocks.colorBlueBottomLeft = renderBlocks.colorBlueBottomRight = renderBlocks.colorBlueTopRight = rgb[2];
+
+            } else {
+
+                renderBlocks.colorRedTopLeft = renderBlocks.colorRedBottomLeft = renderBlocks.colorRedBottomRight = renderBlocks.colorRedTopRight = rgb[0] * lightness;
+                renderBlocks.colorGreenTopLeft = renderBlocks.colorGreenBottomLeft = renderBlocks.colorGreenBottomRight = renderBlocks.colorGreenTopRight = rgb[1] * lightness;
+                renderBlocks.colorBlueTopLeft = renderBlocks.colorBlueBottomLeft = renderBlocks.colorBlueBottomRight = renderBlocks.colorBlueTopRight = rgb[2] * lightness;
+
+                renderBlocks.colorRedTopLeft *= aoTopLeft;
+                renderBlocks.colorGreenTopLeft *= aoTopLeft;
+                renderBlocks.colorBlueTopLeft *= aoTopLeft;
+                renderBlocks.colorRedBottomLeft *= aoBottomLeft;
+                renderBlocks.colorGreenBottomLeft *= aoBottomLeft;
+                renderBlocks.colorBlueBottomLeft *= aoBottomLeft;
+                renderBlocks.colorRedBottomRight *= aoBottomRight;
+                renderBlocks.colorGreenBottomRight *= aoBottomRight;
+                renderBlocks.colorBlueBottomRight *= aoBottomRight;
+                renderBlocks.colorRedTopRight *= aoTopRight;
+                renderBlocks.colorGreenTopRight *= aoTopRight;
+                renderBlocks.colorBlueTopRight *= aoTopRight;
+            }
+
+        } else {
+
+            tessellator.setColorOpaque_F(rgb[0] * lightness, rgb[1] * lightness, rgb[2] * lightness);
+
+        }
+    }
+
+    /**
+     * Gets rgb color from integer.
+     *
+     * @param color the integer color
+     * @return a float array with rgb values
+     */
+    public static float[] getRGB(int color) {
+        float red = (color >> 16 & 0xff) / 255.0F;
+        float green = (color >> 8 & 0xff) / 255.0F;
+        float blue = (color & 0xff) / 255.0F;
+
+        return new float[]{red, green, blue};
+    }
+
+    /**
+     * Will apply anaglyph color multipliers to RGB float array.
+     * <p>
+     * If {@link EntityRenderer#anaglyphEnable} is false,
+     * will do nothing.
+     *
+     * @param rgb array containing red, green and blue float values
+     */
+    public vo