feat(render): tile ambient occlusion

Render smooth lighting ambient occlusion on all Gregtech tiles:
- Ores
- Machines
- Pipes, Cables, Wires, Frames

Add new Client-side configuration entry in Gregtech.cfg.
If false, the flat lighting rendering of older versions is used.

```yml
render {
    B:TileAmbientOcclusion_true=true
}
```

1 files changed, 45 insertions, 57 deletions

diff --git a/src/main/java/gregtech/common/render/GT_Renderer_Block.java b/src/main/java/gregtech/common/render/GT_Renderer_Block.java
index 4c6a237818..6cb161fcb8 100644
--- a/src/main/java/gregtech/common/render/GT_Renderer_Block.java
+++ b/src/main/java/gregtech/common/render/GT_Renderer_Block.java
@@ -2,6 +2,7 @@ package gregtech.common.render;
 
 import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
 import cpw.mods.fml.client.registry.RenderingRegistry;
+import gregtech.GT_Mod;
 import gregtech.api.GregTech_API;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
@@ -12,6 +13,7 @@ import gregtech.common.blocks.GT_Block_Machines;
 import gregtech.common.blocks.GT_Block_Ores_Abstract;
 import gregtech.common.blocks.GT_TileEntity_Ores;
 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;
@@ -420,101 +422,84 @@ public class GT_Renderer_Block implements ISimpleBlockRenderingHandler {
 
     public static void renderNegativeYFacing(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[] aIcon, boolean aFullBlock) {
         if (aWorld != null) {
-            if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX, aY - 1, aZ, 0))) {
-                return;
-            }
+            if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX, aY - 1, aZ, 0))) return;
             Tessellator.instance.setBrightness(aBlock.getMixedBrightnessForBlock(aWorld, aX, aFullBlock ? aY - 1 : aY, aZ));
         }
-        if (aIcon != null) {
-            for (ITexture iTexture : aIcon) {
-                if (iTexture != null) {
-                    iTexture.renderYNeg(aRenderer, aBlock, aX, aY, aZ);
-                }
+        if (aIcon == null) return;
+        for (ITexture iTexture : aIcon) {
+            if (iTexture != null) {
+                iTexture.renderYNeg(aRenderer, aBlock, aX, aY, aZ);
             }
         }
     }
 
     public static void renderPositiveYFacing(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[] aIcon, boolean aFullBlock) {
         if (aWorld != null) {
-            if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX, aY + 1, aZ, 1))) {
-                return;
-            }
+            if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX, aY + 1, aZ, 1))) return;
             Tessellator.instance.setBrightness(aBlock.getMixedBrightnessForBlock(aWorld, aX, aFullBlock ? aY + 1 : aY, aZ));
         }
-        if (aIcon != null) {
-            for (ITexture iTexture : aIcon) {
-                if (iTexture != null) {
-                    iTexture.renderYPos(aRenderer, aBlock, aX, aY, aZ);
-                }
+        if (aIcon == null) return;
+        for (ITexture iTexture : aIcon) {
+            if (iTexture != null) {
+                iTexture.renderYPos(aRenderer, aBlock, aX, aY, aZ);
             }
         }
     }
 
     public static void renderNegativeZFacing(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[] aIcon, boolean aFullBlock) {
         if (aWorld != null) {
-            if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX, aY, aZ - 1, 2))) {
-                return;
-            }
+            if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX, aY, aZ - 1, 2))) return;
             Tessellator.instance.setBrightness(aBlock.getMixedBrightnessForBlock(aWorld, aX, aY, aFullBlock ? aZ - 1 : aZ));
         }
-        if (aIcon != null) {
-            for (ITexture iTexture : aIcon) {
-                if (iTexture != null) {
-                    iTexture.renderZNeg(aRenderer, aBlock, aX, aY, aZ);
-                }
+        if (aIcon == null) return;
+        for (ITexture iTexture : aIcon) {
+            if (iTexture != null) {
+                iTexture.renderZNeg(aRenderer, aBlock, aX, aY, aZ);
             }
         }
     }
 
     public static void renderPositiveZFacing(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[] aIcon, boolean aFullBlock) {
         if (aWorld != null) {
-            if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX, aY, aZ + 1, 3))) {
-                return;
-            }
+            if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX, aY, aZ + 1, 3))) return;
             Tessellator.instance.setBrightness(aBlock.getMixedBrightnessForBlock(aWorld, aX, aY, aFullBlock ? aZ + 1 : aZ));
         }
-        if (aIcon != null) {
-            for (ITexture iTexture : aIcon) {
-                if (iTexture != null) {
-                    iTexture.renderZPos(aRenderer, aBlock, aX, aY, aZ);
-                }
+        if (aIcon == null) return;
+        for (ITexture iTexture : aIcon) {
+            if (iTexture != null) {
+                iTexture.renderZPos(aRenderer, aBlock, aX, aY, aZ);
             }
         }
     }
 
     public static void renderNegativeXFacing(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[] aIcon, boolean aFullBlock) {
         if (aWorld != null) {
-            if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX - 1, aY, aZ, 4))) {
-                return;
-            }
+            if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX - 1, aY, aZ, 4))) return;
             Tessellator.instance.setBrightness(aBlock.getMixedBrightnessForBlock(aWorld, aFullBlock ? aX - 1 : aX, aY, aZ));
         }
-        if (aIcon != null) {
-            for (ITexture iTexture : aIcon) {
-                if (iTexture != null) {
-                    iTexture.renderXNeg(aRenderer, aBlock, aX, aY, aZ);
-                }
+        if (aIcon == null) return;
+        for (ITexture iTexture : aIcon) {
+            if (iTexture != null) {
+                iTexture.renderXNeg(aRenderer, aBlock, aX, aY, aZ);
             }
         }
     }
 
     public static void renderPositiveXFacing(IBlockAccess aWorld, RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ, ITexture[] aIcon, boolean aFullBlock) {
         if (aWorld != null) {
-            if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX + 1, aY, aZ, 5))) {
-                return;
-            }
+            if ((aFullBlock) && (!aBlock.shouldSideBeRendered(aWorld, aX + 1, aY, aZ, 5))) return;
             Tessellator.instance.setBrightness(aBlock.getMixedBrightnessForBlock(aWorld, aFullBlock ? aX + 1 : aX, aY, aZ));
         }
-        if (aIcon != null) {
-            for (ITexture iTexture : aIcon) {
-                if (iTexture != null) {
-                    iTexture.renderXPos(aRenderer, aBlock, aX, aY, aZ);
-                }
+        if (aIcon == null) return;
+        for (ITexture iTexture : aIcon) {
+            if (iTexture != null) {
+                iTexture.renderXPos(aRenderer, aBlock, aX, aY, aZ);
             }
         }
     }
 
     public void renderInventoryBlock(Block aBlock, int aMeta, int aModelID, RenderBlocks aRenderer) {
+        aRenderer.enableAO = false;
         if ((aBlock instanceof GT_Block_Machines)) {
             if ((aMeta > 0) && (aMeta < GregTech_API.METATILEENTITIES.length) && (GregTech_API.METATILEENTITIES[aMeta] != null) &&
                     (!GregTech_API.METATILEENTITIES[aMeta].renderInInventory(aBlock, aMeta, aRenderer))) {
@@ -566,15 +551,18 @@ public class GT_Renderer_Block implements ISimpleBlockRenderingHandler {
     }
 
     public boolean renderWorldBlock(IBlockAccess aWorld, int aX, int aY, int aZ, Block aBlock, int aModelID, RenderBlocks aRenderer) {
-        TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ);
-        if (aTileEntity == null) {
-            return false;
-        }
-        if (aTileEntity instanceof IGregTechTileEntity && (((IGregTechTileEntity) aTileEntity).getMetaTileEntity() != null) && (((IGregTechTileEntity) aTileEntity).getMetaTileEntity().renderInWorld(aWorld, aX, aY, aZ, aBlock, aRenderer))) {
-            return true;
-        }
-        if ((aTileEntity instanceof IPipeRenderedTileEntity)) {
-            return renderPipeBlock(aWorld, aX, aY, aZ, aBlock, (IPipeRenderedTileEntity) aTileEntity, aRenderer);
+        aRenderer.enableAO = Minecraft.isAmbientOcclusionEnabled() && GT_Mod.gregtechproxy.mRenderTileAmbientOcclusion;
+        TileEntity tileEntity = aWorld.getTileEntity(aX, aY, aZ);
+        if (tileEntity == null) return false;
+        if (tileEntity instanceof IGregTechTileEntity) {
+            IMetaTileEntity metaTileEntity;
+            if ((metaTileEntity = ((IGregTechTileEntity) tileEntity).getMetaTileEntity()) != null &&
+                    metaTileEntity.renderInWorld(aWorld, aX, aY, aZ, aBlock, aRenderer)) {
+                return true;
+            }
+        }
+        if ((tileEntity instanceof IPipeRenderedTileEntity)) {
+            return renderPipeBlock(aWorld, aX, aY, aZ, aBlock, (IPipeRenderedTileEntity) tileEntity, aRenderer);
         }
         return renderStandardBlock(aWorld, aX, aY, aZ, aBlock, aRenderer);
     }