Colourful lights

1 files changed, 265 insertions, 36 deletions

diff --git a/ihl/model/RenderBlocksExt.java b/ihl/model/RenderBlocksExt.java
index b4b334a..5355b13 100644
--- a/ihl/model/RenderBlocksExt.java
+++ b/ihl/model/RenderBlocksExt.java
@@ -2,8 +2,11 @@ package ihl.model;
 
 import net.minecraft.block.Block;
 import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.init.Blocks;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.IBlockAccess;
+import net.minecraftforge.common.util.ForgeDirection;
 
 import java.util.HashSet;
 import java.util.Set;
@@ -14,82 +17,308 @@ import ihl.ClientProxy;
 import ihl.IHLMod;
 import ihl.enviroment.LightSource;
 
-@SideOnly(value=Side.CLIENT)
+@SideOnly(value = Side.CLIENT)
 public class RenderBlocksExt extends RenderBlocks {
 
 	public static RenderBlocksExt instance;
-	private final int[] YNEG = new int[] { 0, -1, 0 };
-	private final int[] YPOS = new int[] { 0, 1, 0 };
-	private final int[] XNEG = new int[] { -1, 0, 0 };
-	private final int[] XPOS = new int[] { 1, 0, 0 };
-	private final int[] ZNEG = new int[] { 0, 0, -1 };
-	private final int[] ZPOS = new int[] { 0, 0, 1 };
-	private final int BRIGHT = 0x0000FF;
-	private final int DARK = 0x000000;
+	final static int[][] NULL_NORMAL = new int[][] { new int[] { 0, 0, 0 },
+
+			new int[] { 1, 0, 0 }, // Top left
+			new int[] { 0, 0, 1 }, new int[] { 1, 0, 1 },
+
+			new int[] { -1, 0, 0 }, // Top Right
+			new int[] { 0, 0, 1 }, new int[] { -1, 0, 1 },
+
+			new int[] { 1, 0, 0 }, // Bottom Left
+			new int[] { 0, 0, -1 }, new int[] { 1, 0, -1 },
+
+			new int[] { -1, 0, 0 }, // Bottom Right
+			new int[] { 0, 0, -1 }, new int[] { -1, 0, -1 },
+
+	};
+	private final static int[][] YNEG = new int[][] { new int[] { 0, -1, 0 }, // 0
+
+			new int[] { -1, 0, 0 }, // Top left
+			new int[] { 0, 0, 1 }, new int[] { -1, 0, 1 },
+
+			new int[] { 1, 0, 0 }, // Top Right
+			new int[] { 0, 0, 1 }, new int[] { 1, 0, 1 },
+
+			new int[] { -1, 0, 0 }, // Bottom Left
+			new int[] { 0, 0, -1 }, new int[] { -1, 0, -1 },
+
+			new int[] { 1, 0, 0 }, // Bottom Right
+			new int[] { 0, 0, -1 }, new int[] { 1, 0, -1 }, };
+	private final static int[][] YPOS = new int[][] { new int[] { 0, 1, 0 },
+
+			new int[] { 1, 0, 0 }, // Top left
+			new int[] { 0, 0, 1 }, new int[] { 1, 0, 1 },
+
+			new int[] { -1, 0, 0 }, // Top Right
+			new int[] { 0, 0, 1 }, new int[] { -1, 0, 1 },
+
+			new int[] { 1, 0, 0 }, // Bottom Left
+			new int[] { 0, 0, -1 }, new int[] { 1, 0, -1 },
+
+			new int[] { -1, 0, 0 }, // Bottom Right
+			new int[] { 0, 0, -1 }, new int[] { -1, 0, -1 },
+
+	};
+	private final static int[][] XNEG = new int[][] { new int[] { -1, 0, 0 }, // 4
+
+			new int[] { 0, 1, 0 }, // Top left
+			new int[] { 0, 0, 1 }, new int[] { 0, 1, 1 },
+
+			new int[] { 0, -1, 0 }, // Top Right
+			new int[] { 0, 0, 1 }, new int[] { 0, -1, 1 },
+
+			new int[] { 0, 1, 0 }, // Bottom Left
+			new int[] { 0, 0, -1 }, new int[] { 0, 1, -1 },
+
+			new int[] { 0, -1, 0 }, // Bottom Right
+			new int[] { 0, 0, -1 }, new int[] { 0, -1, -1 }, };
+	private final static int[][] XPOS = new int[][] { new int[] { 1, 0, 0 }, // 5
+
+			new int[] { 0, -1, 0 }, // Top left
+			new int[] { 0, 0, 1 }, new int[] { 0, -1, 1 },
+
+			new int[] { 0, 1, 0 }, // Top Right
+			new int[] { 0, 0, 1 }, new int[] { 0, 1, 1 },
+
+			new int[] { 0, -1, 0 }, // Bottom Left
+			new int[] { 0, 0, -1 }, new int[] { 0, -1, -1 },
+
+			new int[] { 0, 1, 0 }, // Bottom Right
+			new int[] { 0, 0, -1 }, new int[] { 0, 1, -1 }, };
+	private final static int[][] ZNEG = new int[][] { new int[] { 0, 0, -1 }, // 2
+
+			new int[] { -1, 0, 0 }, // Top left
+			new int[] { 0, 1, 0 }, new int[] { -1, 1, 0 },
+
+			new int[] { -1, 0, 0 }, // Top Right
+			new int[] { 0, -1, 0 }, new int[] { -1, -1, 0 },
+
+			new int[] { 1, 0, 0 }, // Bottom Left
+			new int[] { 0, 1, 0 }, new int[] { 1, 1, 0 },
+
+			new int[] { 1, 0, 0 }, // Bottom Right
+			new int[] { 0, -1, 0 }, new int[] { 1, -1, 0 },
+
+	};
+	private final static int[][] ZPOS = new int[][] { new int[] { 0, 0, 1 }, // 3
+
+			new int[] { -1, 0, 0 }, // Top left
+			new int[] { 0, 1, 0 }, new int[] { -1, 1, 0 },
+
+			new int[] { 1, 0, 0 }, // Top Right
+			new int[] { 0, 1, 0 }, new int[] { 1, 1, 0 },
+
+			new int[] { -1, 0, 0 }, // Bottom Left
+			new int[] { 0, -1, 0 }, new int[] { -1, -1, 0 },
+
+			new int[] { 1, 0, 0 }, // Bottom Right
+			new int[] { 0, -1, 0 }, new int[] { 1, -1, 0 }, };
+	private final static int BRIGHT = 0xFF00F7;
+	final static int MASK = 0xFF0003;
 
 	public RenderBlocksExt(IBlockAccess blockAccess) {
 		super(blockAccess);
 		instance = this;
 	}
 
-	private void transformColour(int x, int y, int z, int[] normal) {
-		/*		for (LightSource lightSource : ((ClientProxy)IHLMod.proxy).getLightHandler().lightSources) {
+	private void transformColour(Block block, int x, int y, int z, int[][] normal) {
+		int brightnessBase = block.getMixedBrightnessForBlock(this.blockAccess, x + normal[0][0], y + normal[0][1],
+				z + normal[0][2]);
+		int brightnessBase1 = brightnessBase;
+		int l = block.colorMultiplier(this.blockAccess, x, y, z);
+		float redF = (float) (l >> 16 & 255) / 255f;
+		float greenF = (float) (l >> 8 & 255) / 255f;
+		float blueF = (float) (l & 255) / 255f;
+		int baseColourValue = 255;
+		int[] baseColour = new int[] { baseColourValue, baseColourValue, baseColourValue };
+		int[] topLeft = new int[] { baseColourValue, baseColourValue, baseColourValue };
+		int[] topRight = new int[] { baseColourValue, baseColourValue, baseColourValue };
+		int[] bottomLeft = new int[] { baseColourValue, baseColourValue, baseColourValue };
+		int[] bottomRight = new int[] { baseColourValue, baseColourValue, baseColourValue };
+		int brightnessTopLeft1 = this.brightnessTopLeft;
+		int brightnessTopRight1 = this.brightnessTopRight;
+		int brightnessBottomLeft1 = this.brightnessBottomLeft;
+		int brightnessBottomRight1 = this.brightnessBottomRight;
+		boolean lightAffected = false;
+		for (LightSource lightSource : ((ClientProxy) IHLMod.proxy).getLightHandler().lightSources) {
 			if (lightSource.isBlockIlluminated(x, y, z)) {
-				int[] lightValue = lightSource.getLightValue((int) x, (int) y, (int) z, normal);
-				System.out.println("this.brightnessBottomRight="+this.brightnessBottomRight);
-				this.brightnessTopLeft |= lightValue[0];
-				this.brightnessBottomLeft |= lightValue[0];
-				this.brightnessTopRight |= lightValue[0];
-				this.brightnessBottomRight |= lightValue[0];
-				this.colorRedTopLeft *= (255 - lightValue[0]) * lightValue[1] / 255 / 255f;
-				this.colorRedBottomLeft *= (255 - lightValue[0]) * lightValue[1] / 255 / 255f;
-				this.colorRedTopRight *= (255 - lightValue[0]) * lightValue[1] / 255 / 255f;
-				this.colorRedBottomRight *= (255 - lightValue[0]) * lightValue[1] / 255 / 255f;
-				this.colorBlueTopLeft *= (255 - lightValue[0]) * lightValue[2] / 255 / 255f;
-				this.colorBlueBottomLeft *= (255 - lightValue[0]) * lightValue[2] / 255 / 255f;
-				this.colorBlueTopRight *= (255 - lightValue[0]) * lightValue[2] / 255 / 255f;
-				this.colorBlueBottomRight *= (255 - lightValue[0]) * lightValue[2] / 255 / 255f;
-				this.colorGreenTopLeft *= (255 - lightValue[0]) * lightValue[3] / 255 / 255f;
-				this.colorGreenBottomLeft *= (255 - lightValue[0]) * lightValue[3] / 255 / 255f;
-				this.colorGreenTopRight *= (255 - lightValue[0]) * lightValue[3] / 255 / 255f;
-				this.colorGreenBottomRight *= (255 - lightValue[0]) * lightValue[3] / 255 / 255f;
+				lightAffected = true;
+				int[] lightValue = lightSource.getLightValue(x, y, z, normal[0]);
+				if ((brightnessBase & 240) < lightValue[0]) {
+					int colourFactor = lightValue[0] - (brightnessBase & 240);
+					if ((brightnessBase1 & 240) < lightValue[0]) {
+						brightnessBase1 &= MASK;
+						brightnessBase1 |= lightValue[0];
+					}
+					baseColour[0] += lightValue[1] * colourFactor / 255;
+					baseColour[1] += lightValue[2] * colourFactor / 255;
+					baseColour[2] += lightValue[3] * colourFactor / 255;
+				}
+				if (this.enableAO) {
+					if (lightSource.isBlockIlluminated(x + normal[1][0], y + normal[1][1], z + normal[1][2])
+							&& lightSource.isBlockIlluminated(x + normal[2][0], y + normal[2][1], z + normal[2][2])
+							&& lightSource.isBlockIlluminated(x + normal[3][0], y + normal[3][1], z + normal[3][2])) {
+						lightValue = lightSource.getLightValue(x + normal[3][0], y + normal[3][1], z + normal[3][2],
+								normal[0]);
+						if ((this.brightnessTopLeft & 240) < lightValue[0]) {
+							int colourFactor = lightValue[0] - (this.brightnessTopLeft & 240);
+							if ((brightnessTopLeft1 & 240) < lightValue[0]) {
+								brightnessTopLeft1 &= MASK;
+								brightnessTopLeft1 |= lightValue[0];
+							}
+							topLeft[0] += lightValue[1] * colourFactor / 255;
+							topLeft[1] += lightValue[2] * colourFactor / 255;
+							topLeft[2] += lightValue[3] * colourFactor / 255;
+						}
+					}
+					if (lightSource.isBlockIlluminated(x + normal[4][0], y + normal[4][1], z + normal[4][2])
+							&& lightSource.isBlockIlluminated(x + normal[5][0], y + normal[5][1], z + normal[5][2])
+							&& lightSource.isBlockIlluminated(x + normal[6][0], y + normal[6][1], z + normal[6][2])) {
+						lightValue = lightSource.getLightValue(x + normal[6][0], y + normal[6][1], z + normal[6][2],
+								normal[0]);
+						if ((this.brightnessTopRight & 240) < lightValue[0]) {
+							int colourFactor = lightValue[0] - (this.brightnessTopRight & 240);
+							if ((brightnessTopRight1 & 240) < lightValue[0]) {
+								brightnessTopRight1 &= MASK;
+								brightnessTopRight1 |= lightValue[0];
+							}
+							topRight[0] += lightValue[1] * colourFactor / 255;
+							topRight[1] += lightValue[2] * colourFactor / 255;
+							topRight[2] += lightValue[3] * colourFactor / 255;
+						}
+					}
+					if (lightSource.isBlockIlluminated(x + normal[7][0], y + normal[7][1], z + normal[7][2])
+							&& lightSource.isBlockIlluminated(x + normal[8][0], y + normal[8][1], z + normal[8][2])
+							&& lightSource.isBlockIlluminated(x + normal[9][0], y + normal[9][1], z + normal[9][2])) {
+						lightValue = lightSource.getLightValue(x + normal[9][0], y + normal[9][1], z + normal[9][2],
+								normal[0]);
+						if ((this.brightnessBottomLeft & 240) < lightValue[0]) {
+							int colourFactor = lightValue[0] - (this.brightnessBottomLeft & 240);
+							if ((brightnessBottomLeft1 & 240) < lightValue[0]) {
+								brightnessBottomLeft1 &= MASK;
+								brightnessBottomLeft1 |= lightValue[0];
+							}
+							bottomLeft[0] += lightValue[1] * colourFactor / 255;
+							bottomLeft[1] += lightValue[2] * colourFactor / 255;
+							bottomLeft[2] += lightValue[3] * colourFactor / 255;
+						}
+					}
+					if (lightSource.isBlockIlluminated(x + normal[10][0], y + normal[10][1], z + normal[10][2])
+							&& lightSource.isBlockIlluminated(x + normal[11][0], y + normal[11][1], z + normal[11][2])
+							&& lightSource.isBlockIlluminated(x + normal[12][0], y + normal[12][1],
+									z + normal[12][2])) {
+						lightValue = lightSource.getLightValue(x + normal[12][0], y + normal[12][1], z + normal[12][2],
+								normal[0]);
+						if ((this.brightnessBottomRight & 240) < lightValue[0]) {
+							int colourFactor = lightValue[0] - (this.brightnessBottomRight & 240);
+							if ((brightnessBottomRight1 & 240) < lightValue[0]) {
+								brightnessBottomRight1 &= MASK;
+								brightnessBottomRight1 |= lightValue[0];
+							}
+							bottomRight[0] += lightValue[1] * colourFactor / 255;
+							bottomRight[1] += lightValue[2] * colourFactor / 255;
+							bottomRight[2] += lightValue[3] * colourFactor / 255;
+						}
+					}
+				}
 			}
-		}*/
+		}
+		if (lightAffected) {
+			normalizeColour(baseColour);
+			normalizeColour(topLeft);
+			normalizeColour(topRight);
+			normalizeColour(bottomLeft);
+			normalizeColour(bottomRight);
+			redF = mixLightColour(redF, baseColour[0]);
+			greenF = mixLightColour(greenF, baseColour[1]);
+			blueF = mixLightColour(blueF, baseColour[2]);
+			this.colorRedTopLeft = mixLightColour(colorRedTopLeft, topLeft[0]);
+			this.colorGreenTopLeft = mixLightColour(colorGreenTopLeft, topLeft[1]);
+			this.colorBlueTopLeft = mixLightColour(colorBlueTopLeft, topLeft[2]);
+			this.colorRedTopRight = mixLightColour(colorRedTopRight, topRight[0]);
+			this.colorGreenTopRight = mixLightColour(colorGreenTopRight, topRight[1]);
+			this.colorBlueTopRight = mixLightColour(colorBlueTopRight, topRight[2]);
+			this.colorRedBottomLeft = mixLightColour(colorRedBottomLeft, bottomLeft[0]);
+			this.colorGreenBottomLeft = mixLightColour(colorGreenBottomLeft, bottomLeft[1]);
+			this.colorBlueBottomLeft = mixLightColour(colorBlueBottomLeft, bottomLeft[2]);
+			this.colorRedBottomRight = mixLightColour(colorRedBottomRight, bottomRight[0]);
+			this.colorGreenBottomRight = mixLightColour(colorGreenBottomRight, bottomRight[1]);
+			this.colorBlueBottomRight = mixLightColour(colorBlueBottomRight, bottomRight[2]);
+			this.brightnessTopLeft = brightnessTopLeft1;
+			this.brightnessTopRight = brightnessTopRight1;
+			this.brightnessBottomLeft = brightnessBottomLeft1;
+			this.brightnessBottomRight = brightnessBottomRight1;
+			Tessellator.instance.setBrightness(brightnessBase1);
+			Tessellator.instance.setColorOpaque_F(redF, greenF, blueF);
+		}
+	}
+
+	static void normalizeColour(int[] colour) {
+		int max = colour[0];
+		if (max < colour[1])
+			max = colour[1];
+		if (max < colour[2])
+			max = colour[2];
+		if (max != 0) {
+			colour[0] = colour[0] * 255 / max;
+			colour[1] = colour[1] * 255 / max;
+			colour[2] = colour[2] * 255 / max;
+		} else {
+			colour[0] = 255;
+			colour[1] = 255;
+			colour[2] = 255;
+		}
+	}
+
+	static float mixLightColour(float original, int colour) {
+		return original * colour / 255f;
+	}
+
+	@Override
+	public void drawCrossedSquares(IIcon icon, double x, double y, double z, float f) {
+		this.transformColour(this.blockAccess.getBlock((int) x, (int) y, (int) z), (int) x, (int) y, (int) z,
+				NULL_NORMAL);
+		super.drawCrossedSquares(icon, x, y, z, f);
 	}
 
 	@Override
 	public void renderFaceYNeg(Block block, double x, double y, double z, IIcon icon) {
-		this.transformColour((int) x, (int) y, (int) z, YNEG);
+		this.transformColour(block, (int) x, (int) y, (int) z, YNEG);
 		super.renderFaceYNeg(block, x, y, z, icon);
 	}
 
 	@Override
 	public void renderFaceYPos(Block block, double x, double y, double z, IIcon icon) {
-		this.transformColour((int) x, (int) y, (int) z, YPOS);
+		this.transformColour(block, (int) x, (int) y, (int) z, YPOS);
 		super.renderFaceYPos(block, x, y, z, icon);
 	}
 
 	@Override
 	public void renderFaceZNeg(Block block, double x, double y, double z, IIcon icon) {
-		this.transformColour((int) x, (int) y, (int) z, ZNEG);
+		this.transformColour(block, (int) x, (int) y, (int) z, ZNEG);
 		super.renderFaceZNeg(block, x, y, z, icon);
 	}
 
 	@Override
 	public void renderFaceZPos(Block block, double x, double y, double z, IIcon icon) {
-		this.transformColour((int) x, (int) y, (int) z, ZPOS);
+		this.transformColour(block, (int) x, (int) y, (int) z, ZPOS);
 		super.renderFaceZPos(block, x, y, z, icon);
 	}
 
 	@Override
 	public void renderFaceXNeg(Block block, double x, double y, double z, IIcon icon) {
-		this.transformColour((int) x, (int) y, (int) z, XNEG);
+		this.transformColour(block, (int) x, (int) y, (int) z, XNEG);
 		super.renderFaceXNeg(block, x, y, z, icon);
 	}
 
 	@Override
 	public void renderFaceXPos(Block block, double x, double y, double z, IIcon icon) {
-		this.transformColour((int) x, (int) y, (int) z, XPOS);
+		this.transformColour(block, (int) x, (int) y, (int) z, XPOS);
 		super.renderFaceXPos(block, x, y, z, icon);
 	}
 }