From b42b105fcf71efc43e7a461b3be085929554d469 Mon Sep 17 00:00:00 2001 From: Justin Aquadro Date: Fri, 6 Mar 2015 22:15:14 -0500 Subject: [PATCH] L3 status upgrade changed to L2, L2 removed. All drawers support all status upgrades. Render work. --- .../assets/storagedrawers/lang/en_US.lang | 4 +- .../textures/blocks/block_config.mcmeta | 41 + .../blocks/indicator/indicator_1_off.png | Bin 0 -> 273 bytes .../blocks/indicator/indicator_1_on.png | Bin 0 -> 316 bytes .../blocks/indicator/indicator_2_off.png | Bin 0 -> 287 bytes .../blocks/indicator/indicator_2_on.png | Bin 0 -> 330 bytes .../blocks/indicator/indicator_4_off.png | Bin 0 -> 298 bytes .../blocks/indicator/indicator_4_on.png | Bin 0 -> 342 bytes .../textures/blocks/indicator_amber.png | Bin 397 -> 0 bytes .../textures/blocks/indicator_off.png | Bin 342 -> 0 bytes .../textures/blocks/indicator_on.png | Bin 367 -> 0 bytes .../block/BlockCompDrawers.java | 7 +- .../storagedrawers/block/BlockDrawers.java | 109 +- .../client/renderer/DrawersRenderer.java | 133 ++- .../renderer/TileEntityDrawersRenderer.java | 2 +- .../storagedrawers/core/ModRecipes.java | 6 +- .../item/ItemUpgradeStatus.java | 2 +- .../storagedrawers/util/RenderHelper.java | 419 ++++++++ .../storagedrawers/util/RenderHelperAO.java | 954 ++++++++++++++++++ 19 files changed, 1584 insertions(+), 93 deletions(-) create mode 100644 resources/assets/storagedrawers/textures/blocks/block_config.mcmeta create mode 100644 resources/assets/storagedrawers/textures/blocks/indicator/indicator_1_off.png create mode 100644 resources/assets/storagedrawers/textures/blocks/indicator/indicator_1_on.png create mode 100644 resources/assets/storagedrawers/textures/blocks/indicator/indicator_2_off.png create mode 100644 resources/assets/storagedrawers/textures/blocks/indicator/indicator_2_on.png create mode 100644 resources/assets/storagedrawers/textures/blocks/indicator/indicator_4_off.png create mode 100644 resources/assets/storagedrawers/textures/blocks/indicator/indicator_4_on.png delete mode 100644 resources/assets/storagedrawers/textures/blocks/indicator_amber.png delete mode 100644 resources/assets/storagedrawers/textures/blocks/indicator_off.png delete mode 100644 resources/assets/storagedrawers/textures/blocks/indicator_on.png create mode 100644 src/com/jaquadro/minecraft/storagedrawers/util/RenderHelper.java create mode 100644 src/com/jaquadro/minecraft/storagedrawers/util/RenderHelperAO.java diff --git a/resources/assets/storagedrawers/lang/en_US.lang b/resources/assets/storagedrawers/lang/en_US.lang index 6b49bcb..b6e651a 100644 --- a/resources/assets/storagedrawers/lang/en_US.lang +++ b/resources/assets/storagedrawers/lang/en_US.lang @@ -10,9 +10,7 @@ item.upgrade.emerald.name=Storage Upgrade (VI) item.upgradeStatus.level1.name=Status Upgrade (I) item.upgradeStatus.level1.description=Shows full storage item.upgradeStatus.level2.name=Status Upgrade (II) -item.upgradeStatus.level2.description=Shows near-full storage -item.upgradeStatus.level3.name=Status Upgrade (III) -item.upgradeStatus.level3.description=Shows fill level +item.upgradeStatus.level2.description=Shows fill level item.upgradeLock.name=Lock Upgrade item.upgradeLock.description=Keep associated items when empty diff --git a/resources/assets/storagedrawers/textures/blocks/block_config.mcmeta b/resources/assets/storagedrawers/textures/blocks/block_config.mcmeta new file mode 100644 index 0000000..60705b6 --- /dev/null +++ b/resources/assets/storagedrawers/textures/blocks/block_config.mcmeta @@ -0,0 +1,41 @@ +{ + "fullDrawers1": { + "trimWidth": 0.0625, + "trimDepth": 0.0625, + "indStart": 0.390625, + "indEnd": 0.609375, + "indSteps": 14 + }, + "fullDrawers2": { + "trimWidth": 0.0625, + "trimDepth": 0.0625, + "indStart": 0.390625, + "indEnd": 0.609375, + "indSteps": 14 + }, + "fullDrawers4": { + "trimWidth": 0.0625, + "trimDepth": 0.0625, + "indStart": 0.140625, + "indEnd": 0.359375, + "indSteps": 14 + }, + "halfDrawers2": { + "trimWidth": 0.0625, + "trimDepth": 0.0625, + "indStart": 0.390625, + "indEnd": 0.609375, + "indSteps": 14 + }, + "halfDrawers4": { + "trimWidth": 0.0625, + "trimDepth": 0.0625, + "indStart": 0.140625, + "indEnd": 0.359375, + "indSteps": 14 + }, + "compDrawers": { + "trimWidth": 0.0625, + "trimDepth": 0.0625 + } +} \ No newline at end of file diff --git a/resources/assets/storagedrawers/textures/blocks/indicator/indicator_1_off.png b/resources/assets/storagedrawers/textures/blocks/indicator/indicator_1_off.png new file mode 100644 index 0000000000000000000000000000000000000000..7111a3a1caef8427d74447e245a0b8345234fd48 GIT binary patch literal 273 zcmeAS@N?(olHy`uVBq!ia0vp^4j|0I1|(Ny7TyC=+9j?LCC){ui6xo&c?uz!xv2~x z8KnxQ3ciU&3PuKora;2V(89{pSV7mo)W9IXbAl338+(bTuPgg~W;RwnhO74HjDbR& z1s;*b3=CW!K$y{KjmZq4AWOQVuOkD)#(wTUiL5|=rl*TzNX4zU7Yw;t4Fp&Za3noc zty6sR?|EkhZ#Vy<8=X@%q+QZhiR^yz)|(Tk9sz!Isr_o6^Z8fG{wYGUHumZzT=#u? z?Oy$fhc{P=e25NurGM^R`}YXN=&4NS+8Os8WqYQ>^}9eU;ycI$Pgg&ebxsLQ09*iA A6#xJL literal 0 HcmV?d00001 diff --git a/resources/assets/storagedrawers/textures/blocks/indicator/indicator_1_on.png b/resources/assets/storagedrawers/textures/blocks/indicator/indicator_1_on.png new file mode 100644 index 0000000000000000000000000000000000000000..65ba8f490e4b0d1651cba7da1defc2419a79e701 GIT binary patch literal 316 zcmeAS@N?(olHy`uVBq!ia0vp^4j|0I1|(Ny7TyC=+9j?LCC){ui6xo&c?uz!xv2~x z8KnxQ3ciU&3PuKora;2V(89{pSV7mo)W9IXbAl338+(bTuPgg~W;RwnF4I@)xWXNX4zUmmIkc83-^OaB-== zGWlLj^Z8G%PWK<$*EA?pe15f-L&$Ss&;|t#!7GvxH)1&=r|~iZ^&-Fz(T!i&za~xl z7W#F?bzkAOS9SK!BiC(TUi?wATmOMrvUK~!Exmg0zqeP-zG^geUjCnzt}>6GXx3kS ut@m)X_=NKn)AbaWyq3;?epH;{&vxtelWbOASaS0k$O2DSKbLh*2~7aXg>AwB literal 0 HcmV?d00001 diff --git a/resources/assets/storagedrawers/textures/blocks/indicator/indicator_2_off.png b/resources/assets/storagedrawers/textures/blocks/indicator/indicator_2_off.png new file mode 100644 index 0000000000000000000000000000000000000000..bd4f15181d0ca8a7ea577353b79dc65360b28508 GIT binary patch literal 287 zcmeAS@N?(olHy`uVBq!ia0vp^4j|0I1|(Ny7TyC=+9j?LCC){ui6xo&c?uz!xv2~x z8KnxQ3ciU&3PuKora;2V(89{pSV7mo)W9IXbAl338+(bTuPgg~W;Rw{oinFC3Il~W z3p^r=85p=efH0%e8j~47L6&q!Uq=Rpjs4tz5?O)#a!(h>kcwMxZy9nOHsE0mVD)N? zS>){a-M-&>-Nc0fQJbdvC^{~?@Li2xY})@n%0L|q3=Q>$A@&nyzSsV|cIzeC{Hu&P z$Cl2WRc*JaX1gBaop`~^2Y0`|UiofA^mK-A^2}f@3@?1`7g#m))-?bj!-v^+4q~ET TJ3l_P2FZH5`njxgN@xNA?%Z8* literal 0 HcmV?d00001 diff --git a/resources/assets/storagedrawers/textures/blocks/indicator/indicator_2_on.png b/resources/assets/storagedrawers/textures/blocks/indicator/indicator_2_on.png new file mode 100644 index 0000000000000000000000000000000000000000..a6ebf5933822b2cab299ba0e13feb61d4df194a9 GIT binary patch literal 330 zcmeAS@N?(olHy`uVBq!ia0vp^4j|0I1|(Ny7TyC=+9j?LCC){ui6xo&c?uz!xv2~x z8KnxQ3ciU&3PuKora;2V(89{pSV7mo)W9IXbAl338+(bTuPgg~W;Rw{F1h0+?|?#_ z1s;*b3=G^tAk28_ZrvZCAWOQVuOkD)#(wTUiL5~WB2O2`kcwMxZ#i-uG7w~H8l ze`zs$?=Rob)^+=A&zDa7efMe9pT48a6-OfGU(Se{zbxo|L^rz$xeGF~`X~p7&Pkr0mPv9Sm|g1H%XXU3Z^ns=-NC{d?p6EewC_waL7Kg`AuM$E~fo>W&gzZ4*B5b|1Re%x~Omu=xJd7NA}r_|vWO?LeNP z_9m0sC$DYzb1OH;9b0O2f8M!^a{KS>mwGTw<*H@Rva2f}r|n(4EmF68pZS-U{~oVv zmYIAqSZ4KA^N)P3g ai6z!eX`lL^m!^k-q&;2zT-G@yGywoVme)#s&(y2BroEZRLl40=2Q1c>21s-{WLsRkJ$ZRHP3S z;w?gxP%{b`t&F|a`oIfAn@azxOjMCHTQDKPtVSu-xRs={;ihj z*Ai71c&4hI6Z+{FP^x~znNdpc-0|;klDG<{#YmfdpB+>9&O(C0Q|qCO#Ciqw+fPsM zH(A_nSu(dF>YVKAb&bJ#2ma|!ooTUqa!Sim_5PWq;w#P^*_phM<21s-{WLsRpRP3Z*K<* zaTa()7Bet#3xP1>rMq>1fPyUPj=qiz3>*8o|0J>k`RhDg978H@C0|KM_;H?r)m%bC zLUICw58rePjtwU^8XQ#pS5WZRJ?sa&*J_1K2F9K8_aEd;bFcq*(6W4Ajp8X*ofCQq ziEfjAo^D`zP_*NS;~V>oNg8oKydz{Jn0!2f{s)LCJt^okUhqPVd&7y!9flqr9tL|V zJ~lnP)hDYl$zW$Tw^)KG`^!W|Lk9`z1FG#h=UyB;#L_>hS|-NDGCI>lHo#K$kF&9? fyUwf>wlG_ zaSO!@5^dWRDo)BRW*6)hiTTcT&Fr#Ify&yG_gd>ePyYU&MaXHdreyxxyORYxH_M0% z9{$AA&15`h?nTSbnsPH0Zq8k{!CpeV=&2ENy-55?gZ8IUv!3qQQRwob#=S=SY*Ead zyoU$o9#_t)U%F#OWUt}L)MN2C798h(bpMjh@xNzs4t`qo==Q8MOTD-lzx0sM) 0) return iconFront[2]; else if (tile.isDrawerEnabled(1) && tile.getDrawer(1).getStoredItemStackSize() > 0) @@ -99,7 +99,10 @@ public class BlockCompDrawers extends BlockDrawers else { IDrawer main = tile.getDrawer(0); int plev = 0; - if (main.getMaxCapacity() != 0) { + + if (tile.getStatusLevel() == 1) + plev = (main.getMaxCapacity() > 0 && main.getRemainingCapacity() == 0) ? 6 : 0; + else if (main.getMaxCapacity() > 0) { float pfull = (float) main.getStoredItemCount() / main.getMaxCapacity(); plev = MathHelper.clamp_int((int) (pfull * 6.99), 0, 6); } diff --git a/src/com/jaquadro/minecraft/storagedrawers/block/BlockDrawers.java b/src/com/jaquadro/minecraft/storagedrawers/block/BlockDrawers.java index 352c8fd..a3a9e33 100644 --- a/src/com/jaquadro/minecraft/storagedrawers/block/BlockDrawers.java +++ b/src/com/jaquadro/minecraft/storagedrawers/block/BlockDrawers.java @@ -1,5 +1,8 @@ package com.jaquadro.minecraft.storagedrawers.block; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; import com.jaquadro.minecraft.storagedrawers.StorageDrawers; import com.jaquadro.minecraft.storagedrawers.api.storage.IDrawer; import com.jaquadro.minecraft.storagedrawers.block.tile.TileEntityDrawers; @@ -19,6 +22,8 @@ import net.minecraft.block.material.Material; import net.minecraft.client.Minecraft; import net.minecraft.client.particle.EffectRenderer; import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.client.resources.IResource; +import net.minecraft.client.resources.data.IMetadataSection; import net.minecraft.creativetab.CreativeTabs; import net.minecraft.entity.Entity; import net.minecraft.entity.EntityLivingBase; @@ -28,23 +33,32 @@ import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.tileentity.TileEntity; -import net.minecraft.util.AxisAlignedBB; -import net.minecraft.util.IIcon; -import net.minecraft.util.MathHelper; -import net.minecraft.util.MovingObjectPosition; +import net.minecraft.util.*; import net.minecraft.world.IBlockAccess; import net.minecraft.world.World; import net.minecraftforge.common.util.ForgeDirection; +import org.apache.commons.compress.utils.IOUtils; import org.apache.logging.log4j.Level; +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; import java.util.List; import java.util.Random; public class BlockDrawers extends BlockContainer implements IExtendedBlockClickHandler { + private static final ResourceLocation blockConfig = new ResourceLocation(StorageDrawers.MOD_ID + ":textures/blocks/block_config.mcmeta"); + public final boolean halfDepth; public final int drawerCount; + public float trimWidth = 0.0625f; + public float trimDepth = 0.0625f; + public float indStart = 0; + public float indEnd = 0; + public int indSteps = 0; + @SideOnly(Side.CLIENT) private IIcon[] iconSide; @SideOnly(Side.CLIENT) @@ -70,11 +84,11 @@ public class BlockDrawers extends BlockContainer implements IExtendedBlockClickH private IIcon[] iconOverlayTrim; @SideOnly(Side.CLIENT) - private IIcon iconIndicatorOn; + private IIcon[] iconIndicator1; @SideOnly(Side.CLIENT) - private IIcon iconIndicatorAmber; + private IIcon[] iconIndicator2; @SideOnly(Side.CLIENT) - private IIcon iconIndicatorOff; + private IIcon[] iconIndicator4; //@SideOnly(Side.CLIENT) //private IIcon iconLockFace; @@ -517,30 +531,6 @@ public class BlockDrawers extends BlockContainer implements IExtendedBlockClickH return iconOverlayTrim[level]; } - @SideOnly(Side.CLIENT) - public IIcon getIndicatorIcon (boolean on) { - return on ? iconIndicatorOn : iconIndicatorAmber; - } - - @SideOnly(Side.CLIENT) - public IIcon getIndicatorIcon (int level) { - switch (level) { - case 0: - return iconIndicatorOff; - case 1: - return iconIndicatorAmber; - case 2: - return iconIndicatorOn; - default: - return iconIndicatorOff; - } - } - - /*@SideOnly(Side.CLIENT) - public IIcon getIconLockFace () { - return iconLockFace; - }*/ - @SideOnly(Side.CLIENT) private IIcon getIcon (IBlockAccess blockAccess, int x, int y, int z, int side, int level) { int meta = blockAccess.getBlockMetadata(x, y, z) % BlockWood.field_150096_a.length; @@ -578,6 +568,18 @@ public class BlockDrawers extends BlockContainer implements IExtendedBlockClickH return (level > 0) ? iconOverlay[level] : iconSide[meta]; } + @SideOnly(Side.CLIENT) + public IIcon getIndicatorIcon (int drawerCount, boolean on) { + int onIndex = on ? 1 : 0; + switch (drawerCount) { + case 1: return iconIndicator1[onIndex]; + case 2: return iconIndicator2[onIndex]; + case 4: return iconIndicator4[onIndex]; + } + + return null; + } + @Override @SideOnly(Side.CLIENT) public void registerBlockIcons (IIconRegister register) { @@ -615,10 +617,49 @@ public class BlockDrawers extends BlockContainer implements IExtendedBlockClickH iconOverlayTrim[i] = register.registerIcon(StorageDrawers.MOD_ID + ":overlay_" + overlays[i] + "_trim"); } - iconIndicatorOff = register.registerIcon(StorageDrawers.MOD_ID + ":indicator_off"); - iconIndicatorAmber = register.registerIcon(StorageDrawers.MOD_ID + ":indicator_amber"); - iconIndicatorOn = register.registerIcon(StorageDrawers.MOD_ID + ":indicator_on"); + iconIndicator1 = new IIcon[2]; + iconIndicator2 = new IIcon[2]; + iconIndicator4 = new IIcon[2]; + + iconIndicator1[0] = register.registerIcon(StorageDrawers.MOD_ID + ":indicator/indicator_1_off"); + iconIndicator1[1] = register.registerIcon(StorageDrawers.MOD_ID + ":indicator/indicator_1_on"); + iconIndicator2[0] = register.registerIcon(StorageDrawers.MOD_ID + ":indicator/indicator_2_off"); + iconIndicator2[1] = register.registerIcon(StorageDrawers.MOD_ID + ":indicator/indicator_2_on"); + iconIndicator4[0] = register.registerIcon(StorageDrawers.MOD_ID + ":indicator/indicator_4_off"); + iconIndicator4[1] = register.registerIcon(StorageDrawers.MOD_ID + ":indicator/indicator_4_on"); //iconLockFace = register.registerIcon(StorageDrawers.MOD_ID + ":lock_face"); + + loadBlockConfig(); + } + + private void loadBlockConfig () { + try { + IResource configResource = Minecraft.getMinecraft().getResourceManager().getResource(blockConfig); + BufferedReader reader = null; + try { + reader = new BufferedReader(new InputStreamReader(configResource.getInputStream())); + JsonObject root = (new JsonParser()).parse(reader).getAsJsonObject(); + + JsonObject entry = root.getAsJsonObject(getUnlocalizedName().substring(5)); + if (entry != null) { + if (entry.has("trimWidth")) + trimWidth = entry.get("trimWidth").getAsFloat(); + if (entry.has("trimDepth")) + trimDepth = entry.get("trimDepth").getAsFloat(); + if (entry.has("indStart")) + indStart = entry.get("indStart").getAsFloat(); + if (entry.has("indEnd")) + indEnd = entry.get("indEnd").getAsFloat(); + if (entry.has("indSteps")) + indSteps = entry.get("indSteps").getAsInt(); + } + } + finally { + IOUtils.closeQuietly(reader); + } + } catch (IOException e) { + e.printStackTrace(); + } } } diff --git a/src/com/jaquadro/minecraft/storagedrawers/client/renderer/DrawersRenderer.java b/src/com/jaquadro/minecraft/storagedrawers/client/renderer/DrawersRenderer.java index e828a4e..e1eb0d8 100644 --- a/src/com/jaquadro/minecraft/storagedrawers/client/renderer/DrawersRenderer.java +++ b/src/com/jaquadro/minecraft/storagedrawers/client/renderer/DrawersRenderer.java @@ -5,9 +5,11 @@ import com.jaquadro.minecraft.storagedrawers.api.storage.IDrawer; import com.jaquadro.minecraft.storagedrawers.block.BlockCompDrawers; import com.jaquadro.minecraft.storagedrawers.block.BlockDrawers; import com.jaquadro.minecraft.storagedrawers.block.tile.TileEntityDrawers; +import com.jaquadro.minecraft.storagedrawers.util.RenderHelper; import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler; import net.minecraft.block.Block; import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.util.IIcon; import net.minecraft.world.IBlockAccess; import net.minecraftforge.common.util.ForgeDirection; import org.lwjgl.opengl.GL11; @@ -91,19 +93,8 @@ public class DrawersRenderer implements ISimpleBlockRenderingHandler renderInterior(block, x, y, z, side, renderer); - boxRenderer.setIcon(block.getIndicatorIcon(false)); - if (StorageDrawers.config.cache.enableIndicatorUpgrades) - renderHandleIndicator(block, x, y, z, side, renderer, tile.getStatusLevel()); - - /*if (tile.isLocked()) { - boxRenderer.setExteriorIcon(Blocks.iron_block.getIcon(0, 0)); - boxRenderer.setExteriorIcon(block.getIconLockFace(), side); - - double depth = block.halfDepth ? 8 : 0; - setCoord(boxCoord, 7 * unit, 7 * unit, (depth + .5) * unit, 9 * unit, 9 * unit, (depth + 1) * unit, side); - boxRenderer.renderExterior(renderer, block, x, y, z, boxCoord[0], boxCoord[1], boxCoord[2], boxCoord[3], boxCoord[4], boxCoord[5], 0, 0); - }*/ + renderIndicator(block, x, y, z, side, renderer, tile.getStatusLevel()); return true; } @@ -115,56 +106,99 @@ public class DrawersRenderer implements ISimpleBlockRenderingHandler ModularBoxRenderer.CUT_YPOS | ModularBoxRenderer.CUT_YNEG | ModularBoxRenderer.CUT_XNEG | ModularBoxRenderer.CUT_ZNEG | ModularBoxRenderer.CUT_ZPOS, }; - private static final float[][] indicatorsXY1 = new float[][] { - { 6, 14, 10, 15 } + private static final float[][] drawerXYWH1 = new float[][] { + { 0, 0, 16, 16 }, }; - private static final float[][] indicatorsXY2 = new float[][] { - { 6, 14, 10, 15 }, { 6, 6, 10, 7 } + private static final float[][] drawerXYWH2 = new float[][] { + { 0, 8, 16, 8 }, { 0, 0, 16, 8 }, }; - private static final float[][] indicatorsXY4 = new float[][] { - { 11, 14, 13, 15 }, { 11, 6, 13, 7 }, { 3, 14, 5, 15 }, { 3, 6, 5, 7 } + private static final float[][] drawerXYWH4 = new float[][] { + { 0, 8, 8, 8 }, { 0, 0, 8, 8 }, { 8, 8, 8, 8 }, { 8, 0, 8, 8 }, }; - private void renderHandleIndicator (BlockDrawers block, int x, int y, int z, int side, RenderBlocks renderer, int level) { + private void renderIndicator (BlockDrawers block, int x, int y, int z, int side, RenderBlocks renderer, int level) { if (level <= 0 || side < 2 || side > 5) return; TileEntityDrawers tile = block.getTileEntity(renderer.blockAccess, x, y, z); - double depth = block.halfDepth ? 8 : 0; + double depth = block.halfDepth ? 8 : 16; int count = 0; - float[][] xySet = null; + float[][] xywhSet = null; if (block.drawerCount == 1) { count = 1; - xySet = indicatorsXY1; + xywhSet = drawerXYWH1; } - else if (block.drawerCount == 2 || block instanceof BlockCompDrawers) { - count = (block instanceof BlockCompDrawers) ? 1 : 2; - xySet = indicatorsXY2; + else if (block.drawerCount == 2) { + count = 2; + xywhSet = drawerXYWH2; } else if (block.drawerCount == 4) { count = 4; - xySet = indicatorsXY4; + xywhSet = drawerXYWH4; } + IIcon iconOff = block.getIndicatorIcon(count, false); + IIcon iconOn = block.getIndicatorIcon(count, true); + for (int i = 0; i < count; i++) { - float[] xy = xySet[i]; - setCoord(boxCoord, xy[0] * unit, xy[1] * unit, (depth + .95) * unit, xy[2] * unit, xy[3] * unit, (depth + 1) * unit, side); - IDrawer drawer = tile.getDrawer(i); - int iconIndex = 0; - if (level == 2) - iconIndex = (drawer.getMaxCapacity() > 0 && (float)drawer.getStoredItemCount() / drawer.getMaxCapacity() > .75) ? 1 : iconIndex; - if (level >= 1) - iconIndex = (drawer.getMaxCapacity() > 0 && drawer.getStoredItemCount() == drawer.getMaxCapacity()) ? 2 : iconIndex; + if (drawer == null) + continue; - boxRenderer.setExteriorIcon(block.getIndicatorIcon(iconIndex)); + float[] xywh = xywhSet[i]; + + setCoord(boxCoord, xywh[0] * unit, xywh[1] * unit, (depth - 1) * unit, (xywh[0] + xywh[2]) * unit, (xywh[1] + xywh[3]) * unit, (depth - .95) * unit, side); + + boxRenderer.setExteriorIcon(iconOff); boxRenderer.renderExterior(renderer, block, x, y, z, boxCoord[0], boxCoord[1], boxCoord[2], boxCoord[3], boxCoord[4], boxCoord[5], 0, cut[side - 2]); + + if (level == 1 && drawer.getMaxCapacity() > 0 && drawer.getRemainingCapacity() == 0) { + setCoord(boxCoord, xywh[0] * unit, xywh[1] * unit, (depth - 1) * unit, (xywh[0] + xywh[2]) * unit, (xywh[1] + xywh[3]) * unit, (depth - .94) * unit, side); + + boxRenderer.setExteriorIcon(iconOn); + boxRenderer.renderExterior(renderer, block, x, y, z, boxCoord[0], boxCoord[1], boxCoord[2], boxCoord[3], boxCoord[4], boxCoord[5], 0, cut[side - 2]); + } + else if (level >= 2) { + double indStart = xywh[0] + block.indStart / unit; + double indEnd = xywh[0] + block.indEnd / unit; + double indCur = getIndEnd(block, tile, i, indStart, (block.indEnd - block.indStart) / unit); + + if (indCur > indStart) { + if (indCur >= indEnd) + indCur = xywh[0] + xywh[2]; + + setCoord(boxCoord, xywh[0] * unit, xywh[1] * unit, (depth - 1) * unit, indCur * unit, (xywh[1] + xywh[3]) * unit, (depth - .94) * unit, side); + if (side == 2 || side == 5) + renderer.flipTexture = true; + + boxRenderer.setExteriorIcon(iconOn); + boxRenderer.renderExterior(renderer, block, x, y, z, boxCoord[0], boxCoord[1], boxCoord[2], boxCoord[3], boxCoord[4], boxCoord[5], 0, cut[side - 2]); + + renderer.flipTexture = false; + } + } } } + private double getIndEnd (BlockDrawers block, TileEntityDrawers tile, int slot, double x, double w) { + IDrawer drawer = tile.getDrawer(slot); + if (drawer == null) + return x; + + int cap = drawer.getMaxCapacity(); + int count = drawer.getStoredItemCount(); + if (cap == 0 || count == 0) + return x; + + int step = block.indSteps > 0 ? block.indSteps : 1000; + float fillAmt = (float)(step * count / cap) / step; + + return x + (w * fillAmt); + } + private void setCoord (double[] coords, double xMin, double yMin, double zMin, double xMax, double yMax, double zMax) { coords[0] = xMin; coords[1] = yMin; @@ -184,30 +218,33 @@ public class DrawersRenderer implements ISimpleBlockRenderingHandler switch (side) { case 2: - return; - case 3: tmpX = coords[0]; - tmpZ = coords[2]; coords[0] = 1 - coords[3]; coords[3] = 1 - tmpX; + + tmpZ = coords[2]; coords[2] = 1 - coords[5]; coords[5] = 1 - tmpZ; return; + case 3: + return; case 4: tmpX = coords[0]; - coords[0] = coords[2]; - coords[2] = 1 - coords[3]; - coords[3] = coords[5]; - coords[5] = 1 - tmpX; + tmpZ = coords[3]; + coords[0] = 1 - coords[5]; + coords[3] = 1 - coords[2]; + + coords[2] = tmpX; + coords[5] = tmpZ; return; case 5: tmpX = coords[0]; - tmpZ = coords[2]; - coords[0] = 1 - coords[5]; - coords[2] = tmpX; - tmpX = coords[3]; - coords[3] = 1 - tmpZ; - coords[5] = tmpX; + tmpZ = coords[3]; + coords[0] = coords[2]; + coords[3] = coords[5]; + + coords[2] = 1 - tmpZ; + coords[5] = 1 - tmpX; return; } } diff --git a/src/com/jaquadro/minecraft/storagedrawers/client/renderer/TileEntityDrawersRenderer.java b/src/com/jaquadro/minecraft/storagedrawers/client/renderer/TileEntityDrawersRenderer.java index 869f914..b8e9656 100644 --- a/src/com/jaquadro/minecraft/storagedrawers/client/renderer/TileEntityDrawersRenderer.java +++ b/src/com/jaquadro/minecraft/storagedrawers/client/renderer/TileEntityDrawersRenderer.java @@ -196,7 +196,7 @@ public class TileEntityDrawersRenderer extends TileEntitySpecialRenderer }; private float itemOffset1X[] = new float[] { .5f }; - private float itemOffset1Y[] = new float[] { 6.25f }; + private float itemOffset1Y[] = new float[] { 8.25f }; private float itemOffset2X[] = new float[] { .5f, .5f }; private float itemOffset2Y[] = new float[] { 10.25f, 2.25f }; diff --git a/src/com/jaquadro/minecraft/storagedrawers/core/ModRecipes.java b/src/com/jaquadro/minecraft/storagedrawers/core/ModRecipes.java index d4254d2..e70c3c0 100644 --- a/src/com/jaquadro/minecraft/storagedrawers/core/ModRecipes.java +++ b/src/com/jaquadro/minecraft/storagedrawers/core/ModRecipes.java @@ -71,11 +71,9 @@ public class ModRecipes } if (config.cache.enableIndicatorUpgrades) { - GameRegistry.addRecipe(new ItemStack(ModItems.upgradeStatus, 1, 1), "xyx", "yzy", "xyx", - 'x', Items.redstone, 'y', Items.stick, 'z', ModItems.upgradeTemplate); - GameRegistry.addRecipe(new ItemStack(ModItems.upgradeStatus, 1, 2), "wyw", "yzy", "xyx", + GameRegistry.addRecipe(new ItemStack(ModItems.upgradeStatus, 1, 1), "wyw", "yzy", "xyx", 'w', new ItemStack(Blocks.redstone_torch), 'x', Items.redstone, 'y', Items.stick, 'z', ModItems.upgradeTemplate); - GameRegistry.addRecipe(new ItemStack(ModItems.upgradeStatus, 1, 3), "wyw", "yzy", "xyx", + GameRegistry.addRecipe(new ItemStack(ModItems.upgradeStatus, 1, 2), "wyw", "yzy", "xyx", 'w', Items.comparator, 'x', Items.redstone, 'y', Items.stick, 'z', ModItems.upgradeTemplate); } diff --git a/src/com/jaquadro/minecraft/storagedrawers/item/ItemUpgradeStatus.java b/src/com/jaquadro/minecraft/storagedrawers/item/ItemUpgradeStatus.java index 23c5d45..5ece029 100644 --- a/src/com/jaquadro/minecraft/storagedrawers/item/ItemUpgradeStatus.java +++ b/src/com/jaquadro/minecraft/storagedrawers/item/ItemUpgradeStatus.java @@ -17,7 +17,7 @@ import java.util.List; public class ItemUpgradeStatus extends Item { - public static final String[] iconNames = new String[] { null, "level1", "level2", "level3" }; + public static final String[] iconNames = new String[] { null, "level1", "level2" }; @SideOnly(Side.CLIENT) private IIcon[] icons; diff --git a/src/com/jaquadro/minecraft/storagedrawers/util/RenderHelper.java b/src/com/jaquadro/minecraft/storagedrawers/util/RenderHelper.java new file mode 100644 index 0000000..5841659 --- /dev/null +++ b/src/com/jaquadro/minecraft/storagedrawers/util/RenderHelper.java @@ -0,0 +1,419 @@ +package com.jaquadro.minecraft.storagedrawers.util; + +import net.minecraft.block.Block; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.EntityRenderer; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.init.Blocks; +import net.minecraft.util.IIcon; + +public class RenderHelper +{ + public static final int YNEG = 0; + public static final int YPOS = 1; + public static final int ZNEG = 2; + public static final int ZPOS = 3; + public static final int XNEG = 4; + public static final int XPOS = 5; + + private static final int TL = 0; + private static final int BL = 1; + private static final int BR = 2; + private static final int TR = 3; + + private static final int xyzuvMap[][][] = { + { // Y-NEG + { 0, 2, 5, 0, 3 }, + { 0, 2, 4, 0, 2 }, + { 1, 2, 4, 1, 2 }, + { 1, 2, 5, 1, 3 } + }, { // Y-POS + { 1, 3, 5, 1, 3 }, + { 1, 3, 4, 1, 2 }, + { 0, 3, 4, 0, 2 }, + { 0, 3, 5, 0, 3 } + }, { // Z-NEG + { 0, 3, 4, 1, 2 }, + { 1, 3, 4, 0, 2 }, + { 1, 2, 4, 0, 3 }, + { 0, 2, 4, 1, 3 } + }, { // Z-POS + { 0, 3, 5, 0, 2 }, + { 0, 2, 5, 0, 3 }, + { 1, 2, 5, 1, 3 }, + { 1, 3, 5, 1, 2 } + }, { // X-NEG + { 0, 3, 5, 1, 2 }, + { 0, 3, 4, 0, 2 }, + { 0, 2, 4, 0, 3 }, + { 0, 2, 5, 1, 3 } + }, { // X-POS + { 1, 2, 5, 0, 3 }, + { 1, 2, 4, 1, 3 }, + { 1, 3, 4, 1, 2 }, + { 1, 3, 5, 0, 2 } + }, + }; + + private static final float rgbMap[][] = { + { 0.5f, 0.5f, 0.5f }, + { 1.0f, 1.0f, 1.0f }, + { 0.8f, 0.8f, 0.8f }, + { 0.8f, 0.8f, 0.8f }, + { 0.6f, 0.6f, 0.6f }, + { 0.6f, 0.6f, 0.6f }, + }; + + private static final float normMap[][] = { + { 0, -1, 0 }, + { 0, 1, 0 }, + { 0, 0, -1 }, + { 0, 0, 1 }, + { -1, 0, 0 }, + { 1, 0, 0 }, + }; + + private RenderHelperAO aoHelper = new RenderHelperAO(); + + // u-min, u-max, v-min, v-max + private double[] uv = new double[4]; + + // x-min, x-max, y-min, y-max, z-min, z-max + private double[] xyz = new double[6]; + + private float[] colorScratch = new float[3]; + + private void setUV (IIcon icon, double uMin, double vMin, double uMax, double vMax) { + uv[0] = uMin + icon.getMinU(); + uv[1] = uMax + icon.getMaxU(); + uv[2] = vMin + icon.getMinV(); + uv[3] = vMax + icon.getMaxV(); + } + + private void setXYZ (RenderBlocks renderer, double x, double y, double z) { + xyz[0] = x + renderer.renderMinX; + xyz[1] = x + renderer.renderMaxX; + xyz[2] = y + renderer.renderMinY; + xyz[3] = y + renderer.renderMaxY; + xyz[4] = z + renderer.renderMinZ; + xyz[5] = z + renderer.renderMaxZ; + } + + private void renderXYZUV (RenderBlocks renderer, int[][] index) { + Tessellator tessellator = Tessellator.instance; + + int[] tl = index[TL]; + int[] bl = index[BL]; + int[] br = index[BR]; + int[] tr = index[TR]; + + tessellator.addVertexWithUV(xyz[tl[0]], xyz[tl[1]], xyz[tl[2]], uv[tl[3]], uv[tl[4]]); + tessellator.addVertexWithUV(xyz[bl[0]], xyz[bl[1]], xyz[bl[2]], uv[bl[3]], uv[bl[4]]); + tessellator.addVertexWithUV(xyz[br[0]], xyz[br[1]], xyz[br[2]], uv[br[3]], uv[br[4]]); + tessellator.addVertexWithUV(xyz[tr[0]], xyz[tr[1]], xyz[tr[2]], uv[tr[3]], uv[tr[4]]); + } + + private void renderXYZUVAO (RenderBlocks renderer, int[][] index) { + Tessellator tessellator = Tessellator.instance; + + int[] tl = index[TL]; + int[] bl = index[BL]; + int[] br = index[BR]; + int[] tr = index[TR]; + + tessellator.setColorOpaque_F(renderer.colorRedTopLeft, renderer.colorGreenTopLeft, renderer.colorBlueTopLeft); + tessellator.setBrightness(renderer.brightnessTopLeft); + tessellator.addVertexWithUV(xyz[tl[0]], xyz[tl[1]], xyz[tl[2]], uv[tl[3]], uv[tl[4]]); + + tessellator.setColorOpaque_F(renderer.colorRedBottomLeft, renderer.colorGreenBottomLeft, renderer.colorBlueBottomLeft); + tessellator.setBrightness(renderer.brightnessBottomLeft); + tessellator.addVertexWithUV(xyz[bl[0]], xyz[bl[1]], xyz[bl[2]], uv[bl[3]], uv[bl[4]]); + + tessellator.setColorOpaque_F(renderer.colorRedBottomRight, renderer.colorGreenBottomRight, renderer.colorBlueBottomRight); + tessellator.setBrightness(renderer.brightnessBottomRight); + tessellator.addVertexWithUV(xyz[br[0]], xyz[br[1]], xyz[br[2]], uv[br[3]], uv[br[4]]); + + tessellator.setColorOpaque_F(renderer.colorRedTopRight, renderer.colorGreenTopRight, renderer.colorBlueTopRight); + tessellator.setBrightness(renderer.brightnessTopRight); + tessellator.addVertexWithUV(xyz[tr[0]], xyz[tr[1]], xyz[tr[2]], uv[tr[3]], uv[tr[4]]); + } + + public static void calculateBaseColor (float[] target, int color) { + float r = (float)(color >> 16 & 255) / 255f; + float g = (float)(color >> 8 & 255) / 255f; + float b = (float)(color & 255) / 255f; + + if (EntityRenderer.anaglyphEnable) { + float gray = (r * 30f + g * 59f + b * 11f) / 100f; + float rg = (r * 30f + g * 70f) / 100f; + float rb = (r * 30f + b * 70f) / 100f; + + r = gray; + g = rg; + b = rb; + } + + target[0] = r; + target[1] = g; + target[2] = b; + } + + public static void scaleColor (float[] target, float[] source, float scale) { + target[0] = source[0] * scale; + target[1] = source[1] * scale; + target[2] = source[2] * scale; + } + + public static void setTessellatorColor (Tessellator tessellator, float[] color) { + tessellator.setColorOpaque_F(color[0], color[1], color[2]); + } + + public static void renderEmptyPlane (Block block, int x, int y, int z, RenderBlocks renderer) { + renderer.setRenderBounds(0, 0, 0, 0, 0, 0); + renderer.renderFaceYNeg(block, x, y, z, Blocks.dirt.getIcon(0, 0)); + } + + public void renderBlock (RenderBlocks renderer, Block block, int x, int y, int z) { + calculateBaseColor(colorScratch, block.colorMultiplier(renderer.blockAccess, x, y, z)); + float r = colorScratch[0]; + float g = colorScratch[1]; + float b = colorScratch[2]; + + renderFace(YNEG, renderer, block, x, y, z, block.getIcon(renderer.blockAccess, x, y, z, 0), r, g, b); + renderFace(YPOS, renderer, block, x, y, z, block.getIcon(renderer.blockAccess, x, y, z, 1), r, g, b); + renderFace(ZNEG, renderer, block, x, y, z, block.getIcon(renderer.blockAccess, x, y, z, 2), r, g, b); + renderFace(ZPOS, renderer, block, x, y, z, block.getIcon(renderer.blockAccess, x, y, z, 3), r, g, b); + renderFace(XNEG, renderer, block, x, y, z, block.getIcon(renderer.blockAccess, x, y, z, 4), r, g, b); + renderFace(XPOS, renderer, block, x, y, z, block.getIcon(renderer.blockAccess, x, y, z, 5), r, g, b); + } + + public void renderFace (int face, RenderBlocks renderer, Block block, int x, int y, int z, IIcon icon) { + calculateBaseColor(colorScratch, block.colorMultiplier(renderer.blockAccess, x, y, z)); + renderFace(face, renderer, block, x, y, z, icon, colorScratch[0], colorScratch[1], colorScratch[2]); + } + + public void renderFace (int face, RenderBlocks renderer, Block block, int x, int y, int z, IIcon icon, float r, float g, float b) { + if (Minecraft.isAmbientOcclusionEnabled() && renderer.blockAccess != null && block.getLightValue(renderer.blockAccess, x, y, z) == 0) + renderFaceAOPartial(face, renderer, block, x, y, z, icon, r, g, b); + else + renderFaceColorMult(face, renderer, block, x, y, z, icon, r, g, b); + } + + public void renderFaceColorMult (int face, RenderBlocks renderer, Block block, int x, int y, int z, IIcon icon, float r, float g, float b) { + setupColorMult(face, renderer, block, x, y, z, r, g, b); + + switch (face) { + case YNEG: renderer.renderFaceYNeg(block, x, y, z, icon); break; + case YPOS: renderer.renderFaceYPos(block, x, y, z, icon); break; + case ZNEG: renderer.renderFaceZNeg(block, x, y, z, icon); break; + case ZPOS: renderer.renderFaceZPos(block, x, y, z, icon); break; + case XNEG: renderer.renderFaceXNeg(block, x, y, z, icon); break; + case XPOS: renderer.renderFaceXPos(block, x, y, z, icon); break; + } + + if (renderer.blockAccess == null) + Tessellator.instance.draw(); + } + + public void renderFaceAOPartial (int face, RenderBlocks renderer, Block block, int x, int y, int z, IIcon icon, float r, float g, float b) { + renderer.enableAO = true; + + switch (face) { + case YNEG: + aoHelper.setupYNegAOPartial(renderer, block, x, y, z, r, g, b); + renderer.renderFaceYNeg(block, x, y, z, icon); + break; + case YPOS: + aoHelper.setupYPosAOPartial(renderer, block, x, y, z, r, g, b); + renderer.renderFaceYPos(block, x, y, z, icon); + break; + case ZNEG: + aoHelper.setupZNegAOPartial(renderer, block, x, y, z, r, g, b); + renderer.renderFaceZNeg(block, x, y, z, icon); + break; + case ZPOS: + aoHelper.setupZPosAOPartial(renderer, block, x, y, z, r, g, b); + renderer.renderFaceZPos(block, x, y, z, icon); + break; + case XNEG: + aoHelper.setupXNegAOPartial(renderer, block, x, y, z, r, g, b); + renderer.renderFaceXNeg(block, x, y, z, icon); + break; + case XPOS: + aoHelper.setupXPosAOPartial(renderer, block, x, y, z, r, g, b); + renderer.renderFaceXPos(block, x, y, z, icon); + break; + } + + renderer.enableAO = false; + } + + public void renderPartialFace (int face, RenderBlocks renderer, Block block, int x, int y, int z, IIcon icon, double uMin, double vMin, double uMax, double vMax) { + calculateBaseColor(colorScratch, block.colorMultiplier(renderer.blockAccess, x, y, z)); + renderPartialFace(face, renderer, block, x, y, z, icon, uMin, vMin, uMax, vMax, colorScratch[0], colorScratch[1], colorScratch[2]); + } + + public void renderPartialFace (int face, RenderBlocks renderer, Block block, int x, int y, int z, IIcon icon, double uMin, double vMin, double uMax, double vMax, float r, float g, float b) { + if (Minecraft.isAmbientOcclusionEnabled() && renderer.blockAccess != null && block.getLightValue(renderer.blockAccess, x, y, z) == 0) + renderPartialFaceAOPartial(face, renderer, block, x, y, z, icon, uMin, vMin, uMax, vMax, r, g, b); + else + renderPartialFaceColorMult(face, renderer, block, x, y, z, icon, uMin, vMin, uMax, vMax, r, g, b); + } + + public void renderPartialFaceColorMult (int face, RenderBlocks renderer, Block block, int x, int y, int z, IIcon icon, double uMin, double vMin, double uMax, double vMax, float r, float g, float b) { + setupColorMult(face, renderer, block, x, y, z, r, g, b); + renderPartialFace(face, renderer, x, y, z, icon, uMin, vMin, uMax, vMax); + + if (renderer.blockAccess == null) + Tessellator.instance.draw(); + } + + public void renderPartialFaceAOPartial (int face, RenderBlocks renderer, Block block, int x, int y, int z, IIcon icon, double uMin, double vMin, double uMax, double vMax, float r, float g, float b) { + renderer.enableAO = true; + + switch (face) { + case YNEG: + aoHelper.setupYNegAOPartial(renderer, block, x, y, z, r, g, b); + break; + case YPOS: + aoHelper.setupYPosAOPartial(renderer, block, x, y, z, r, g, b); + break; + case ZNEG: + aoHelper.setupZNegAOPartial(renderer, block, x, y, z, r, g, b); + break; + case ZPOS: + aoHelper.setupZPosAOPartial(renderer, block, x, y, z, r, g, b); + break; + case XNEG: + aoHelper.setupXNegAOPartial(renderer, block, x, y, z, r, g, b); + break; + case XPOS: + aoHelper.setupXPosAOPartial(renderer, block, x, y, z, r, g, b); + break; + } + + renderPartialFace(face, renderer, x, y, z, icon, uMin, vMin, uMax, vMax); + renderer.enableAO = false; + } + + public void renderPartialFace (int face, RenderBlocks renderer, double x, double y, double z, IIcon icon, double uMin, double vMin, double uMax, double vMax) { + if (renderer.hasOverrideBlockTexture()) + icon = renderer.overrideBlockTexture; + + setXYZ(renderer, x, y, z); + setUV(icon, uMin, vMin, uMax, vMax); + + if (renderer.enableAO) + renderXYZUVAO(renderer, xyzuvMap[face]); + else + renderXYZUV(renderer, xyzuvMap[face]); + } + + private void setupColorMult (int face, RenderBlocks renderer, Block block, int x, int y, int z, float r, float g, float b) { + Tessellator tessellator = Tessellator.instance; + float[] rgb = rgbMap[face]; + float[] norm = normMap[face]; + + tessellator.setColorOpaque_F(rgb[0] * r, rgb[1] * g, rgb[2] * b); + if (renderer.blockAccess == null) { + tessellator.startDrawingQuads(); + tessellator.setNormal(norm[0], norm[1], norm[2]); + } + else { + int brightX = x; + int brightY = y; + int brightZ = z; + + switch (face) { + case YNEG: brightY = (renderer.renderMinY > 0) ? y : y - 1; break; + case YPOS: brightY = (renderer.renderMaxY < 1) ? y : y + 1; break; + case ZNEG: brightZ = (renderer.renderMinZ > 0) ? z : z - 1; break; + case ZPOS: brightZ = (renderer.renderMaxZ < 1) ? z : z + 1; break; + case XNEG: brightX = (renderer.renderMinX > 0) ? x : x - 1; break; + case XPOS: brightX = (renderer.renderMaxX < 1) ? x : x + 1; break; + } + + tessellator.setBrightness(block.getMixedBrightnessForBlock(renderer.blockAccess, brightX, brightY, brightZ)); + } + + renderer.enableAO = false; + } + + /* uMin += icon.getMinU(); + uMax += icon.getMaxU(); + vMin += icon.getMinV(); + vMax += icon.getMaxV(); + + double xMin = x + renderer.renderMinX; + double xMax = x + renderer.renderMaxX; + double yMin = y + renderer.renderMinY; + double yMax = y + renderer.renderMaxY; + double zMin = z + renderer.renderMinZ; + + if (renderer.enableAO) { + tessellator.setColorOpaque_F(renderer.colorRedTopLeft, renderer.colorGreenTopLeft, renderer.colorBlueTopLeft); + tessellator.setBrightness(renderer.brightnessTopLeft); + tessellator.addVertexWithUV(xMin, yMax, zMin, uMax, vMin); + + tessellator.setColorOpaque_F(renderer.colorRedBottomLeft, renderer.colorGreenBottomLeft, renderer.colorBlueBottomLeft); + tessellator.setBrightness(renderer.brightnessBottomLeft); + tessellator.addVertexWithUV(xMax, yMax, zMin, uMin, vMin); + + tessellator.setColorOpaque_F(renderer.colorRedBottomRight, renderer.colorGreenBottomRight, renderer.colorBlueBottomRight); + tessellator.setBrightness(renderer.brightnessBottomRight); + tessellator.addVertexWithUV(xMax, yMin, zMin, uMin, vMax); + + tessellator.setColorOpaque_F(renderer.colorRedTopRight, renderer.colorGreenTopRight, renderer.colorBlueTopRight); + tessellator.setBrightness(renderer.brightnessTopRight); + tessellator.addVertexWithUV(xMin, yMin, zMin, uMax, vMax); + } + else { + tessellator.addVertexWithUV(xMin, yMax, zMin, uMax, vMin); + tessellator.addVertexWithUV(xMax, yMax, zMin, uMin, vMin); + tessellator.addVertexWithUV(xMax, yMin, zMin, uMin, vMax); + tessellator.addVertexWithUV(xMin, yMin, zMin, uMax, vMax); + } + }*/ + + /*public void renderPartialFaceZPos (RenderBlocks renderer, double x, double y, double z, IIcon icon, double uMin, double vMin, double uMax, double vMax) { + Tessellator tessellator = Tessellator.instance; + if (renderer.hasOverrideBlockTexture()) + icon = renderer.overrideBlockTexture; + + uMin += icon.getMinU(); + uMax += icon.getMaxU(); + vMin += icon.getMinV(); + vMax += icon.getMaxV(); + + double xMin = x + renderer.renderMinX; + double xMax = x + renderer.renderMaxX; + double yMin = y + renderer.renderMinY; + double yMax = y + renderer.renderMaxY; + double zMax = z + renderer.renderMaxZ; + + if (renderer.enableAO) { + tessellator.setColorOpaque_F(renderer.colorRedTopLeft, renderer.colorGreenTopLeft, renderer.colorBlueTopLeft); + tessellator.setBrightness(renderer.brightnessTopLeft); + tessellator.addVertexWithUV(xMin, yMax, zMax, uMin, vMin); + + tessellator.setColorOpaque_F(renderer.colorRedBottomLeft, renderer.colorGreenBottomLeft, renderer.colorBlueBottomLeft); + tessellator.setBrightness(renderer.brightnessBottomLeft); + tessellator.addVertexWithUV(xMin, yMin, zMax, uMin, vMax); + + tessellator.setColorOpaque_F(renderer.colorRedBottomRight, renderer.colorGreenBottomRight, renderer.colorBlueBottomRight); + tessellator.setBrightness(renderer.brightnessBottomRight); + tessellator.addVertexWithUV(xMax, yMin, zMax, uMax, vMax); + + tessellator.setColorOpaque_F(renderer.colorRedTopRight, renderer.colorGreenTopRight, renderer.colorBlueTopRight); + tessellator.setBrightness(renderer.brightnessTopRight); + tessellator.addVertexWithUV(xMax, yMax, zMax, uMax, vMin); + } + else { + tessellator.addVertexWithUV(xMin, yMax, zMax, uMin, vMin); + tessellator.addVertexWithUV(xMin, yMin, zMax, uMin, vMax); + tessellator.addVertexWithUV(xMax, yMin, zMax, uMax, vMax); + tessellator.addVertexWithUV(xMax, yMax, zMax, uMax, vMin); + } + }*/ +} diff --git a/src/com/jaquadro/minecraft/storagedrawers/util/RenderHelperAO.java b/src/com/jaquadro/minecraft/storagedrawers/util/RenderHelperAO.java new file mode 100644 index 0000000..30562f1 --- /dev/null +++ b/src/com/jaquadro/minecraft/storagedrawers/util/RenderHelperAO.java @@ -0,0 +1,954 @@ +package com.jaquadro.minecraft.storagedrawers.util; + +import net.minecraft.block.Block; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.util.MathHelper; + +public class RenderHelperAO +{ + private int aoBrightnessXYNI; + private int aoBrightnessYZIN; + private int aoBrightnessYZIP; + private int aoBrightnessXYPI; + private int aoBrightnessXYZNIN; + private int aoBrightnessXYZNIP; + private int aoBrightnessXYZPIN; + private int aoBrightnessXYZPIP; + + private int aoBrightnessXYNN; + private int aoBrightnessYZNN; + private int aoBrightnessYZNP; + private int aoBrightnessXYPN; + private int aoBrightnessXYNP; + private int aoBrightnessXYPP; + private int aoBrightnessYZPN; + private int aoBrightnessYZPP; + private int aoBrightnessXZNN; + private int aoBrightnessXZPN; + private int aoBrightnessXZNP; + private int aoBrightnessXZPP; + private int aoBrightnessXYZNNN; + private int aoBrightnessXYZNNP; + private int aoBrightnessXYZPNN; + private int aoBrightnessXYZPNP; + private int aoBrightnessXYZNPN; + private int aoBrightnessXYZPPN; + private int aoBrightnessXYZNPP; + private int aoBrightnessXYZPPP; + + private int aoBrightnessXZNI; + private int aoBrightnessYZNI; + private int aoBrightnessYZPI; + private int aoBrightnessXZPI; + private int aoBrightnessXYIN; + private int aoBrightnessXZIN; + private int aoBrightnessXZIP; + private int aoBrightnessXYIP; + private int aoBrightnessXYZNNI; + private int aoBrightnessXYZNPI; + private int aoBrightnessXYZPNI; + private int aoBrightnessXYZPPI; + private int aoBrightnessXYZINN; + private int aoBrightnessXYZINP; + private int aoBrightnessXYZIPN; + private int aoBrightnessXYZIPP; + + private float aoLightValueScratchXYNI; + private float aoLightValueScratchYZIN; + private float aoLightValueScratchYZIP; + private float aoLightValueScratchXYPI; + private float aoLightValueScratchXYZNIN; + private float aoLightValueScratchXYZNIP; + private float aoLightValueScratchXYZPIN; + private float aoLightValueScratchXYZPIP; + + private float aoLightValueScratchXYNN; + private float aoLightValueScratchYZNN; + private float aoLightValueScratchYZNP; + private float aoLightValueScratchXYPN; + private float aoLightValueScratchXYNP; + private float aoLightValueScratchXYPP; + private float aoLightValueScratchYZPN; + private float aoLightValueScratchYZPP; + private float aoLightValueScratchXZNN; + private float aoLightValueScratchXZPN; + private float aoLightValueScratchXZNP; + private float aoLightValueScratchXZPP; + private float aoLightValueScratchXYZNNN; + private float aoLightValueScratchXYZNNP; + private float aoLightValueScratchXYZPNN; + private float aoLightValueScratchXYZPNP; + private float aoLightValueScratchXYZNPN; + private float aoLightValueScratchXYZPPN; + private float aoLightValueScratchXYZNPP; + private float aoLightValueScratchXYZPPP; + + private float aoLightValueScratchXZNI; + private float aoLightValueScratchYZNI; + private float aoLightValueScratchYZPI; + private float aoLightValueScratchXZPI; + private float aoLightValueScratchXYIN; + private float aoLightValueScratchXZIN; + private float aoLightValueScratchXZIP; + private float aoLightValueScratchXYIP; + private float aoLightValueScratchXYZNNI; + private float aoLightValueScratchXYZNPI; + private float aoLightValueScratchXYZPNI; + private float aoLightValueScratchXYZPPI; + private float aoLightValueScratchXYZINN; + private float aoLightValueScratchXYZINP; + private float aoLightValueScratchXYZIPN; + private float aoLightValueScratchXYZIPP; + + public void setupYNegAOPartial (RenderBlocks renderer, Block block, int x, int y, int z, float r, float g, float b) { + Tessellator tessellator = Tessellator.instance; + tessellator.setBrightness(983055); + + int yGrass = (renderer.renderMinY <= 0) ? y - 1 : y; + + boolean blocksGrassXYPN = !renderer.blockAccess.getBlock(x + 1, yGrass, z).getCanBlockGrass(); + boolean blocksGrassXYNN = !renderer.blockAccess.getBlock(x - 1, yGrass, z).getCanBlockGrass(); + boolean blocksGrassYZNP = !renderer.blockAccess.getBlock(x, yGrass, z + 1).getCanBlockGrass(); + boolean blocksGrassYZNN = !renderer.blockAccess.getBlock(x, yGrass, z - 1).getCanBlockGrass(); + + if (renderer.renderMinY > 0) + setupAOBrightnessYNeg(renderer, block, x, y, z, blocksGrassXYPN, blocksGrassXYNN, blocksGrassYZNP, blocksGrassYZNN); + + setupAOBrightnessYPos(renderer, block, x, y - 1, z, blocksGrassXYPN, blocksGrassXYNN, blocksGrassYZNP, blocksGrassYZNN); + + float yClamp = MathHelper.clamp_float((float) renderer.renderMinY, 0, 1); + mixAOBrightnessLightValueY(yClamp, 1 - yClamp); + + int blockBrightness = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z); + if (renderer.renderMinY <= 0.0D || !renderer.blockAccess.getBlock(x, y - 1, z).isOpaqueCube()) + blockBrightness = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y - 1, z); + + float aoOpposingBlock = renderer.blockAccess.getBlock(x, y - 1, z).getAmbientOcclusionLightValue(); + float aoXYZNNP = (aoLightValueScratchXYNI + aoLightValueScratchXYZNIP + aoOpposingBlock + aoLightValueScratchYZIP) / 4.0F; + float aoXYZPNP = (aoOpposingBlock + aoLightValueScratchYZIP + aoLightValueScratchXYPI + aoLightValueScratchXYZPIP) / 4.0F; + float aoXYZPNN = (aoLightValueScratchYZIN + aoOpposingBlock + aoLightValueScratchXYZPIN + aoLightValueScratchXYPI) / 4.0F; + float aoXYZNNN = (aoLightValueScratchXYZNIN + aoLightValueScratchXYNI + aoLightValueScratchYZIN + aoOpposingBlock) / 4.0F; + + float aoTR = (float)((double)aoXYZNNP * renderer.renderMinX * (1.0D - renderer.renderMaxZ) + (double)aoXYZPNP * renderer.renderMinX * renderer.renderMaxZ + (double)aoXYZPNN * (1.0D - renderer.renderMinX) * renderer.renderMaxZ + (double)aoXYZNNN * (1.0D - renderer.renderMinX) * (1.0D - renderer.renderMaxZ)); + float aoTL = (float)((double)aoXYZNNP * renderer.renderMinX * (1.0D - renderer.renderMinZ) + (double)aoXYZPNP * renderer.renderMinX * renderer.renderMinZ + (double)aoXYZPNN * (1.0D - renderer.renderMinX) * renderer.renderMinZ + (double)aoXYZNNN * (1.0D - renderer.renderMinX) * (1.0D - renderer.renderMinZ)); + float aoBL = (float)((double)aoXYZNNP * renderer.renderMaxX * (1.0D - renderer.renderMinZ) + (double)aoXYZPNP * renderer.renderMaxX * renderer.renderMinZ + (double)aoXYZPNN * (1.0D - renderer.renderMaxX) * renderer.renderMinZ + (double)aoXYZNNN * (1.0D - renderer.renderMaxX) * (1.0D - renderer.renderMinZ)); + float aoBR = (float)((double)aoXYZNNP * renderer.renderMaxX * (1.0D - renderer.renderMaxZ) + (double)aoXYZPNP * renderer.renderMaxX * renderer.renderMaxZ + (double)aoXYZPNN * (1.0D - renderer.renderMaxX) * renderer.renderMaxZ + (double)aoXYZNNN * (1.0D - renderer.renderMaxX) * (1.0D - renderer.renderMaxZ)); + + int brXYZNNP = renderer.getAoBrightness(aoBrightnessXYNI, aoBrightnessXYZNIP, aoBrightnessYZIP, blockBrightness); + int brXYZPNP = renderer.getAoBrightness(aoBrightnessYZIP, aoBrightnessXYPI, aoBrightnessXYZPIP, blockBrightness); + int brXYZPNN = renderer.getAoBrightness(aoBrightnessYZIN, aoBrightnessXYZPIN, aoBrightnessXYPI, blockBrightness); + int brXYZNNN = renderer.getAoBrightness(aoBrightnessXYZNIN, aoBrightnessXYNI, aoBrightnessYZIN, blockBrightness); + + renderer.brightnessTopRight = renderer.mixAoBrightness(brXYZNNP, brXYZNNN, brXYZPNN, brXYZPNP, renderer.renderMaxX * (1.0D - renderer.renderMaxZ), (1.0D - renderer.renderMaxX) * (1.0D - renderer.renderMaxZ), (1.0D - renderer.renderMaxX) * renderer.renderMaxZ, renderer.renderMaxX * renderer.renderMaxZ); + renderer.brightnessTopLeft = renderer.mixAoBrightness(brXYZNNP, brXYZNNN, brXYZPNN, brXYZPNP, renderer.renderMaxX * (1.0D - renderer.renderMinZ), (1.0D - renderer.renderMaxX) * (1.0D - renderer.renderMinZ), (1.0D - renderer.renderMaxX) * renderer.renderMinZ, renderer.renderMaxX * renderer.renderMinZ); + renderer.brightnessBottomLeft = renderer.mixAoBrightness(brXYZNNP, brXYZNNN, brXYZPNN, brXYZPNP, renderer.renderMinX * (1.0D - renderer.renderMinZ), (1.0D - renderer.renderMinX) * (1.0D - renderer.renderMinZ), (1.0D - renderer.renderMinX) * renderer.renderMinZ, renderer.renderMinX * renderer.renderMinZ); + renderer.brightnessBottomRight = renderer.mixAoBrightness(brXYZNNP, brXYZNNN, brXYZPNN, brXYZPNP, renderer.renderMinX * (1.0D - renderer.renderMaxZ), (1.0D - renderer.renderMinX) * (1.0D - renderer.renderMaxZ), (1.0D - renderer.renderMinX) * renderer.renderMaxZ, renderer.renderMinX * renderer.renderMaxZ); + + renderer.colorRedTopLeft = renderer.colorRedBottomLeft = renderer.colorRedBottomRight = renderer.colorRedTopRight = r * 0.5F; + renderer.colorGreenTopLeft = renderer.colorGreenBottomLeft = renderer.colorGreenBottomRight = renderer.colorGreenTopRight = g * 0.5F; + renderer.colorBlueTopLeft = renderer.colorBlueBottomLeft = renderer.colorBlueBottomRight = renderer.colorBlueTopRight = b * 0.5F; + + renderer.colorRedTopLeft *= aoTL; + renderer.colorGreenTopLeft *= aoTL; + renderer.colorBlueTopLeft *= aoTL; + renderer.colorRedBottomLeft *= aoBL; + renderer.colorGreenBottomLeft *= aoBL; + renderer.colorBlueBottomLeft *= aoBL; + renderer.colorRedBottomRight *= aoBR; + renderer.colorGreenBottomRight *= aoBR; + renderer.colorBlueBottomRight *= aoBR; + renderer.colorRedTopRight *= aoTR; + renderer.colorGreenTopRight *= aoTR; + renderer.colorBlueTopRight *= aoTR; + } + + public void setupYPosAOPartial (RenderBlocks renderer, Block block, int x, int y, int z, float r, float g, float b) { + Tessellator tessellator = Tessellator.instance; + tessellator.setBrightness(983055); + + if (renderer.renderMaxY >= 1.0D) + ++y; + + aoBrightnessXYNP = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y, z); + aoBrightnessXYPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y, z); + aoBrightnessYZPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z - 1); + aoBrightnessYZPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z + 1); + aoBrightnessXYZNPN = aoBrightnessXYNP; + aoBrightnessXYZPPN = aoBrightnessXYPP; + aoBrightnessXYZNPP = aoBrightnessXYNP; + aoBrightnessXYZPPP = aoBrightnessXYPP; + + aoLightValueScratchXYNP = renderer.blockAccess.getBlock(x - 1, y, z).getAmbientOcclusionLightValue(); + aoLightValueScratchXYPP = renderer.blockAccess.getBlock(x + 1, y, z).getAmbientOcclusionLightValue(); + aoLightValueScratchYZPN = renderer.blockAccess.getBlock(x, y, z - 1).getAmbientOcclusionLightValue(); + aoLightValueScratchYZPP = renderer.blockAccess.getBlock(x, y, z + 1).getAmbientOcclusionLightValue(); + aoLightValueScratchXYZNPN = aoLightValueScratchXYNP; + aoLightValueScratchXYZPPN = aoLightValueScratchXYPP; + aoLightValueScratchXYZNPP = aoLightValueScratchXYNP; + aoLightValueScratchXYZPPP = aoLightValueScratchXYPP; + + boolean blocksGrassXYPP = renderer.blockAccess.getBlock(x + 1, y + 1, z).getCanBlockGrass(); + boolean blocksGrassXYNP = renderer.blockAccess.getBlock(x - 1, y + 1, z).getCanBlockGrass(); + boolean blocksGrassYZPP = renderer.blockAccess.getBlock(x, y + 1, z + 1).getCanBlockGrass(); + boolean blocksGrassYZPN = renderer.blockAccess.getBlock(x, y + 1, z - 1).getCanBlockGrass(); + + if (blocksGrassYZPN || blocksGrassXYNP) { + aoLightValueScratchXYZNPN = renderer.blockAccess.getBlock(x - 1, y, z - 1).getAmbientOcclusionLightValue(); + aoBrightnessXYZNPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y, z - 1); + } + + if (blocksGrassYZPN || blocksGrassXYPP) { + aoLightValueScratchXYZPPN = renderer.blockAccess.getBlock(x + 1, y, z - 1).getAmbientOcclusionLightValue(); + aoBrightnessXYZPPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y, z - 1); + } + + if (blocksGrassYZPP || blocksGrassXYNP) { + aoLightValueScratchXYZNPP = renderer.blockAccess.getBlock(x - 1, y, z + 1).getAmbientOcclusionLightValue(); + aoBrightnessXYZNPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y, z + 1); + } + + if (blocksGrassYZPP || blocksGrassXYPP) { + aoLightValueScratchXYZPPP = renderer.blockAccess.getBlock(x + 1, y, z + 1).getAmbientOcclusionLightValue(); + aoBrightnessXYZPPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y, z + 1); + } + + if (renderer.renderMaxY >= 1.0D) + --y; + + int blockBrightness = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z); + if (renderer.renderMaxY >= 1.0D || !renderer.blockAccess.getBlock(x, y + 1, z).isOpaqueCube()) + blockBrightness = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y + 1, z); + + float aoOpposingBlock = renderer.blockAccess.getBlock(x, y + 1, z).getAmbientOcclusionLightValue(); + float aoXYZNPN = (aoLightValueScratchXYZNPP + aoLightValueScratchXYNP + aoLightValueScratchYZPP + aoOpposingBlock) / 4.0F; // TR + float aoXYZNPP = (aoLightValueScratchYZPP + aoOpposingBlock + aoLightValueScratchXYZPPP + aoLightValueScratchXYPP) / 4.0F; // TL + float aoXYZPPP = (aoOpposingBlock + aoLightValueScratchYZPN + aoLightValueScratchXYPP + aoLightValueScratchXYZPPN) / 4.0F; // BL + float aoXYZPPN = (aoLightValueScratchXYNP + aoLightValueScratchXYZNPN + aoOpposingBlock + aoLightValueScratchYZPN) / 4.0F; // BR + + float aoTL = (float)((double)aoXYZPPP * renderer.renderMaxX * (1.0D - renderer.renderMaxZ) + (double)aoXYZNPP * renderer.renderMaxX * renderer.renderMaxZ + (double)aoXYZNPN * (1.0D - renderer.renderMaxX) * renderer.renderMaxZ + (double)aoXYZPPN * (1.0D - renderer.renderMaxX) * (1.0D - renderer.renderMaxZ)); + float aoBL = (float)((double)aoXYZPPP * renderer.renderMaxX * (1.0D - renderer.renderMinZ) + (double)aoXYZNPP * renderer.renderMaxX * renderer.renderMinZ + (double)aoXYZNPN * (1.0D - renderer.renderMaxX) * renderer.renderMinZ + (double)aoXYZPPN * (1.0D - renderer.renderMaxX) * (1.0D - renderer.renderMinZ)); + float aoBR = (float)((double)aoXYZPPP * renderer.renderMinX * (1.0D - renderer.renderMinZ) + (double)aoXYZNPP * renderer.renderMinX * renderer.renderMinZ + (double)aoXYZNPN * (1.0D - renderer.renderMinX) * renderer.renderMinZ + (double)aoXYZPPN * (1.0D - renderer.renderMinX) * (1.0D - renderer.renderMinZ)); + float aoTR = (float)((double)aoXYZPPP * renderer.renderMinX * (1.0D - renderer.renderMaxZ) + (double)aoXYZNPP * renderer.renderMinX * renderer.renderMaxZ + (double)aoXYZNPN * (1.0D - renderer.renderMinX) * renderer.renderMaxZ + (double)aoXYZPPN * (1.0D - renderer.renderMinX) * (1.0D - renderer.renderMaxZ)); + + int brXYZPPN = renderer.getAoBrightness(aoBrightnessXYNP, aoBrightnessXYZNPP, aoBrightnessYZPP, blockBrightness); + int brXYZNPN = renderer.getAoBrightness(aoBrightnessYZPP, aoBrightnessXYPP, aoBrightnessXYZPPP, blockBrightness); + int brXYZNPP = renderer.getAoBrightness(aoBrightnessYZPN, aoBrightnessXYZPPN, aoBrightnessXYPP, blockBrightness); + int brXYZPPP = renderer.getAoBrightness(aoBrightnessXYZNPN, aoBrightnessXYNP, aoBrightnessYZPN, blockBrightness); + + renderer.brightnessTopLeft = mixAOBrightness(brXYZPPP, brXYZPPN, brXYZNPN, brXYZNPP, renderer.renderMaxZ, renderer.renderMaxX); + renderer.brightnessBottomLeft = mixAOBrightness(brXYZPPP, brXYZPPN, brXYZNPN, brXYZNPP, renderer.renderMinZ, renderer.renderMaxX); + renderer.brightnessBottomRight = mixAOBrightness(brXYZPPP, brXYZPPN, brXYZNPN, brXYZNPP, renderer.renderMinZ, renderer.renderMinX); + renderer.brightnessTopRight = mixAOBrightness(brXYZPPP, brXYZPPN, brXYZNPN, brXYZNPP, renderer.renderMaxZ, renderer.renderMinX); + + renderer.colorRedTopLeft = renderer.colorRedBottomLeft = renderer.colorRedBottomRight = renderer.colorRedTopRight = r; + renderer.colorGreenTopLeft = renderer.colorGreenBottomLeft = renderer.colorGreenBottomRight = renderer.colorGreenTopRight = g; + renderer.colorBlueTopLeft = renderer.colorBlueBottomLeft = renderer.colorBlueBottomRight = renderer.colorBlueTopRight = b; + + renderer.colorRedTopLeft *= aoTL; + renderer.colorGreenTopLeft *= aoTL; + renderer.colorBlueTopLeft *= aoTL; + renderer.colorRedBottomLeft *= aoBL; + renderer.colorGreenBottomLeft *= aoBL; + renderer.colorBlueBottomLeft *= aoBL; + renderer.colorRedBottomRight *= aoBR; + renderer.colorGreenBottomRight *= aoBR; + renderer.colorBlueBottomRight *= aoBR; + renderer.colorRedTopRight *= aoTR; + renderer.colorGreenTopRight *= aoTR; + renderer.colorBlueTopRight *= aoTR; + } + + public void setupZNegAOPartial (RenderBlocks renderer, Block block, int x, int y, int z, float r, float g, float b) { + Tessellator tessellator = Tessellator.instance; + tessellator.setBrightness(983055); + + int zGrass = (renderer.renderMinZ <= 0) ? z - 1 : z; + + boolean blocksGrassXZPN = !renderer.blockAccess.getBlock(x + 1, y, zGrass).getCanBlockGrass(); + boolean blocksGrassXZNN = !renderer.blockAccess.getBlock(x - 1, y, zGrass).getCanBlockGrass(); + boolean blocksGrassYZPN = !renderer.blockAccess.getBlock(x, y + 1, zGrass).getCanBlockGrass(); + boolean blocksGrassYZNN = !renderer.blockAccess.getBlock(x, y - 1, zGrass).getCanBlockGrass(); + + if (renderer.renderMinZ > 0) + setupAOBrightnessZNeg(renderer, block, x, y, z, blocksGrassXZPN, blocksGrassXZNN, blocksGrassYZPN, blocksGrassYZNN); + + setupAOBrightnessZPos(renderer, block, x, y, z - 1, blocksGrassXZPN, blocksGrassXZNN, blocksGrassYZPN, blocksGrassYZNN); + + float zClamp = MathHelper.clamp_float((float)renderer.renderMinZ, 0, 1); + mixAOBrightnessLightValueZ(zClamp, 1 - zClamp); + + int blockBrightness = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z); + if (renderer.renderMinZ <= 0.0D || !renderer.blockAccess.getBlock(x, y, z - 1).isOpaqueCube()) + blockBrightness = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z - 1); + + float aoOpposingBlock = renderer.blockAccess.getBlock(x, y, z - 1).getAmbientOcclusionLightValue(); + float aoXYZNPN = (aoLightValueScratchXZNI + aoLightValueScratchXYZNPI + aoOpposingBlock + aoLightValueScratchYZPI) / 4.0F; + float aoXYZPPN = (aoOpposingBlock + aoLightValueScratchYZPI + aoLightValueScratchXZPI + aoLightValueScratchXYZPPI) / 4.0F; + float aoXYZPNN = (aoLightValueScratchYZNI + aoOpposingBlock + aoLightValueScratchXYZPNI + aoLightValueScratchXZPI) / 4.0F; + float aoXYZNNN = (aoLightValueScratchXYZNNI + aoLightValueScratchXZNI + aoLightValueScratchYZNI + aoOpposingBlock) / 4.0F; + + float aoTL = (float)((double)aoXYZNPN * renderer.renderMaxY * (1.0D - renderer.renderMinX) + (double)aoXYZPPN * renderer.renderMaxY * renderer.renderMinX + (double)aoXYZPNN * (1.0D - renderer.renderMaxY) * renderer.renderMinX + (double)aoXYZNNN * (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMinX)); + float aoBL = (float)((double)aoXYZNPN * renderer.renderMaxY * (1.0D - renderer.renderMaxX) + (double)aoXYZPPN * renderer.renderMaxY * renderer.renderMaxX + (double)aoXYZPNN * (1.0D - renderer.renderMaxY) * renderer.renderMaxX + (double)aoXYZNNN * (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMaxX)); + float aoBR = (float)((double)aoXYZNPN * renderer.renderMinY * (1.0D - renderer.renderMaxX) + (double)aoXYZPPN * renderer.renderMinY * renderer.renderMaxX + (double)aoXYZPNN * (1.0D - renderer.renderMinY) * renderer.renderMaxX + (double)aoXYZNNN * (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMaxX)); + float aoTR = (float)((double)aoXYZNPN * renderer.renderMinY * (1.0D - renderer.renderMinX) + (double)aoXYZPPN * renderer.renderMinY * renderer.renderMinX + (double)aoXYZPNN * (1.0D - renderer.renderMinY) * renderer.renderMinX + (double)aoXYZNNN * (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMinX)); + + int brXYZNPN = renderer.getAoBrightness(aoBrightnessXZNI, aoBrightnessXYZNPI, aoBrightnessYZPI, blockBrightness); + int brXYZPPN = renderer.getAoBrightness(aoBrightnessYZPI, aoBrightnessXZPI, aoBrightnessXYZPPI, blockBrightness); + int brXYZPNN = renderer.getAoBrightness(aoBrightnessYZNI, aoBrightnessXYZPNI, aoBrightnessXZPI, blockBrightness); + int brXYZNNN = renderer.getAoBrightness(aoBrightnessXYZNNI, aoBrightnessXZNI, aoBrightnessYZNI, blockBrightness); + + renderer.brightnessTopLeft = renderer.mixAoBrightness(brXYZNPN, brXYZPPN, brXYZPNN, brXYZNNN, renderer.renderMaxY * (1.0D - renderer.renderMinX), renderer.renderMaxY * renderer.renderMinX, (1.0D - renderer.renderMaxY) * renderer.renderMinX, (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMinX)); + renderer.brightnessBottomLeft = renderer.mixAoBrightness(brXYZNPN, brXYZPPN, brXYZPNN, brXYZNNN, renderer.renderMaxY * (1.0D - renderer.renderMaxX), renderer.renderMaxY * renderer.renderMaxX, (1.0D - renderer.renderMaxY) * renderer.renderMaxX, (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMaxX)); + renderer.brightnessBottomRight = renderer.mixAoBrightness(brXYZNPN, brXYZPPN, brXYZPNN, brXYZNNN, renderer.renderMinY * (1.0D - renderer.renderMaxX), renderer.renderMinY * renderer.renderMaxX, (1.0D - renderer.renderMinY) * renderer.renderMaxX, (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMaxX)); + renderer.brightnessTopRight = renderer.mixAoBrightness(brXYZNPN, brXYZPPN, brXYZPNN, brXYZNNN, renderer.renderMinY * (1.0D - renderer.renderMinX), renderer.renderMinY * renderer.renderMinX, (1.0D - renderer.renderMinY) * renderer.renderMinX, (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMinX)); + + renderer.colorRedTopLeft = renderer.colorRedBottomLeft = renderer.colorRedBottomRight = renderer.colorRedTopRight = r * 0.8F; + renderer.colorGreenTopLeft = renderer.colorGreenBottomLeft = renderer.colorGreenBottomRight = renderer.colorGreenTopRight = g * 0.8F; + renderer.colorBlueTopLeft = renderer.colorBlueBottomLeft = renderer.colorBlueBottomRight = renderer.colorBlueTopRight = b * 0.8F; + + renderer.colorRedTopLeft *= aoTL; + renderer.colorGreenTopLeft *= aoTL; + renderer.colorBlueTopLeft *= aoTL; + renderer.colorRedBottomLeft *= aoBL; + renderer.colorGreenBottomLeft *= aoBL; + renderer.colorBlueBottomLeft *= aoBL; + renderer.colorRedBottomRight *= aoBR; + renderer.colorGreenBottomRight *= aoBR; + renderer.colorBlueBottomRight *= aoBR; + renderer.colorRedTopRight *= aoTR; + renderer.colorGreenTopRight *= aoTR; + renderer.colorBlueTopRight *= aoTR; + } + + public void setupZPosAOPartial (RenderBlocks renderer, Block block, int x, int y, int z, float r, float g, float b) { + Tessellator tessellator = Tessellator.instance; + tessellator.setBrightness(983055); + + int zGrass = (renderer.renderMaxZ >= 1) ? z + 1 : z; + + boolean blocksGrassXZPP = !renderer.blockAccess.getBlock(x + 1, y, zGrass).getCanBlockGrass(); + boolean blocksGrassXZNP = !renderer.blockAccess.getBlock(x - 1, y, zGrass).getCanBlockGrass(); + boolean blocksGrassYZPP = !renderer.blockAccess.getBlock(x, y + 1, zGrass).getCanBlockGrass(); + boolean blocksGrassYZNP = !renderer.blockAccess.getBlock(x, y - 1, zGrass).getCanBlockGrass(); + + if (renderer.renderMaxZ < 1) + setupAOBrightnessZPos(renderer, block, x, y, z, blocksGrassXZPP, blocksGrassXZNP, blocksGrassYZPP, blocksGrassYZNP); + + setupAOBrightnessZNeg(renderer, block, x, y, z + 1, blocksGrassXZPP, blocksGrassXZNP, blocksGrassYZPP, blocksGrassYZNP); + + float zClamp = MathHelper.clamp_float((float)renderer.renderMaxZ, 0, 1); + mixAOBrightnessLightValueZ(zClamp, 1 - zClamp); + + int blockBrightness = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z); + if (renderer.renderMaxZ >= 1.0D || !renderer.blockAccess.getBlock(x, y, z + 1).isOpaqueCube()) + blockBrightness = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z + 1); + + float aoOpposingBlock = renderer.blockAccess.getBlock(x, y, z + 1).getAmbientOcclusionLightValue(); + float aoXYZNPP = (aoLightValueScratchXZNI + aoLightValueScratchXYZNPI + aoOpposingBlock + aoLightValueScratchYZPI) / 4.0F; + float aoXYZPPP = (aoOpposingBlock + aoLightValueScratchYZPI + aoLightValueScratchXZPI + aoLightValueScratchXYZPPI) / 4.0F; + float aoXYZPNP = (aoLightValueScratchYZNI + aoOpposingBlock + aoLightValueScratchXYZPNI + aoLightValueScratchXZPI) / 4.0F; + float aoXYZNNP = (aoLightValueScratchXYZNNI + aoLightValueScratchXZNI + aoLightValueScratchYZNI + aoOpposingBlock) / 4.0F; + + float aoTL = (float)((double)aoXYZNPP * renderer.renderMaxY * (1.0D - renderer.renderMinX) + (double)aoXYZPPP * renderer.renderMaxY * renderer.renderMinX + (double)aoXYZPNP * (1.0D - renderer.renderMaxY) * renderer.renderMinX + (double)aoXYZNNP * (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMinX)); + float aoBL = (float)((double)aoXYZNPP * renderer.renderMinY * (1.0D - renderer.renderMinX) + (double)aoXYZPPP * renderer.renderMinY * renderer.renderMinX + (double)aoXYZPNP * (1.0D - renderer.renderMinY) * renderer.renderMinX + (double)aoXYZNNP * (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMinX)); + float aoBR = (float)((double)aoXYZNPP * renderer.renderMinY * (1.0D - renderer.renderMaxX) + (double)aoXYZPPP * renderer.renderMinY * renderer.renderMaxX + (double)aoXYZPNP * (1.0D - renderer.renderMinY) * renderer.renderMaxX + (double)aoXYZNNP * (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMaxX)); + float aoTR = (float)((double)aoXYZNPP * renderer.renderMaxY * (1.0D - renderer.renderMaxX) + (double)aoXYZPPP * renderer.renderMaxY * renderer.renderMaxX + (double)aoXYZPNP * (1.0D - renderer.renderMaxY) * renderer.renderMaxX + (double)aoXYZNNP * (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMaxX)); + + int brXYZNPP = renderer.getAoBrightness(aoBrightnessXZNI, aoBrightnessXYZNPI, aoBrightnessYZPI, blockBrightness); + int brXYZPPP = renderer.getAoBrightness(aoBrightnessYZPI, aoBrightnessXZPI, aoBrightnessXYZPPI, blockBrightness); + int brXYZPNP = renderer.getAoBrightness(aoBrightnessYZNI, aoBrightnessXYZPNI, aoBrightnessXZPI, blockBrightness); + int brXYZNNP = renderer.getAoBrightness(aoBrightnessXYZNNI, aoBrightnessXZNI, aoBrightnessYZNI, blockBrightness); + + renderer.brightnessTopLeft = renderer.mixAoBrightness(brXYZNPP, brXYZNNP, brXYZPNP, brXYZPPP, renderer.renderMaxY * (1.0D - renderer.renderMinX), (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMinX), (1.0D - renderer.renderMaxY) * renderer.renderMinX, renderer.renderMaxY * renderer.renderMinX); + renderer.brightnessBottomLeft = renderer.mixAoBrightness(brXYZNPP, brXYZNNP, brXYZPNP, brXYZPPP, renderer.renderMinY * (1.0D - renderer.renderMinX), (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMinX), (1.0D - renderer.renderMinY) * renderer.renderMinX, renderer.renderMinY * renderer.renderMinX); + renderer.brightnessBottomRight = renderer.mixAoBrightness(brXYZNPP, brXYZNNP, brXYZPNP, brXYZPPP, renderer.renderMinY * (1.0D - renderer.renderMaxX), (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMaxX), (1.0D - renderer.renderMinY) * renderer.renderMaxX, renderer.renderMinY * renderer.renderMaxX); + renderer.brightnessTopRight = renderer.mixAoBrightness(brXYZNPP, brXYZNNP, brXYZPNP, brXYZPPP, renderer.renderMaxY * (1.0D - renderer.renderMaxX), (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMaxX), (1.0D - renderer.renderMaxY) * renderer.renderMaxX, renderer.renderMaxY * renderer.renderMaxX); + + renderer.colorRedTopLeft = renderer.colorRedBottomLeft = renderer.colorRedBottomRight = renderer.colorRedTopRight = r * 0.8F; + renderer.colorGreenTopLeft = renderer.colorGreenBottomLeft = renderer.colorGreenBottomRight = renderer.colorGreenTopRight = g * 0.8F; + renderer.colorBlueTopLeft = renderer.colorBlueBottomLeft = renderer.colorBlueBottomRight = renderer.colorBlueTopRight = b * 0.8F; + + renderer.colorRedTopLeft *= aoTL; + renderer.colorGreenTopLeft *= aoTL; + renderer.colorBlueTopLeft *= aoTL; + renderer.colorRedBottomLeft *= aoBL; + renderer.colorGreenBottomLeft *= aoBL; + renderer.colorBlueBottomLeft *= aoBL; + renderer.colorRedBottomRight *= aoBR; + renderer.colorGreenBottomRight *= aoBR; + renderer.colorBlueBottomRight *= aoBR; + renderer.colorRedTopRight *= aoTR; + renderer.colorGreenTopRight *= aoTR; + renderer.colorBlueTopRight *= aoTR; + } + + public void setupXNegAOPartial (RenderBlocks renderer, Block block, int x, int y, int z, float r, float g, float b) { + Tessellator tessellator = Tessellator.instance; + tessellator.setBrightness(983055); + + int xGrass = (renderer.renderMinX <= 0) ? x - 1 : x; + + boolean blocksGrassXYNP = !renderer.blockAccess.getBlock(xGrass, y + 1, z).getCanBlockGrass(); + boolean blocksGrassXYNN = !renderer.blockAccess.getBlock(xGrass, y - 1, z).getCanBlockGrass(); + boolean blocksGrassXZNN = !renderer.blockAccess.getBlock(xGrass, y, z - 1).getCanBlockGrass(); + boolean blocksGrassXZNP = !renderer.blockAccess.getBlock(xGrass, y, z + 1).getCanBlockGrass(); + + if (renderer.renderMinX > 0) + setupAOBrightnessXNeg(renderer, block, x, y, z, blocksGrassXYNP, blocksGrassXYNN, blocksGrassXZNN, blocksGrassXZNP); + + setupAOBrightnessXPos(renderer, block, x - 1, y, z, blocksGrassXYNP, blocksGrassXYNN, blocksGrassXZNN, blocksGrassXZNP); + + float xClamp = MathHelper.clamp_float((float)renderer.renderMinX, 0, 1); + mixAOBrightnessLightValueX(xClamp, 1 - xClamp); + + int blockBrightness = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z); + if (renderer.renderMinX <= 0.0D || !renderer.blockAccess.getBlock(x - 1, y, z).isOpaqueCube()) + blockBrightness = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y, z); + + float aoOpposingBlock = renderer.blockAccess.getBlock(x - 1, y, z).getAmbientOcclusionLightValue(); + float aoXYZNNP = (aoLightValueScratchXYIN + aoLightValueScratchXYZINP + aoOpposingBlock + aoLightValueScratchXZIP) / 4.0F; + float aoXYZNPP = (aoOpposingBlock + aoLightValueScratchXZIP + aoLightValueScratchXYIP + aoLightValueScratchXYZIPP) / 4.0F; + float aoXYZNPN = (aoLightValueScratchXZIN + aoOpposingBlock + aoLightValueScratchXYZIPN + aoLightValueScratchXYIP) / 4.0F; + float aoXYZNNN = (aoLightValueScratchXYZINN + aoLightValueScratchXYIN + aoLightValueScratchXZIN + aoOpposingBlock) / 4.0F; + + float aoTL = (float)((double)aoXYZNPP * renderer.renderMaxY * renderer.renderMaxZ + (double)aoXYZNPN * renderer.renderMaxY * (1.0D - renderer.renderMaxZ) + (double)aoXYZNNN * (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMaxZ) + (double)aoXYZNNP * (1.0D - renderer.renderMaxY) * renderer.renderMaxZ); + float aoBL = (float)((double)aoXYZNPP * renderer.renderMaxY * renderer.renderMinZ + (double)aoXYZNPN * renderer.renderMaxY * (1.0D - renderer.renderMinZ) + (double)aoXYZNNN * (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMinZ) + (double)aoXYZNNP * (1.0D - renderer.renderMaxY) * renderer.renderMinZ); + float aoBR = (float)((double)aoXYZNPP * renderer.renderMinY * renderer.renderMinZ + (double)aoXYZNPN * renderer.renderMinY * (1.0D - renderer.renderMinZ) + (double)aoXYZNNN * (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMinZ) + (double)aoXYZNNP * (1.0D - renderer.renderMinY) * renderer.renderMinZ); + float aoTR = (float)((double)aoXYZNPP * renderer.renderMinY * renderer.renderMaxZ + (double)aoXYZNPN * renderer.renderMinY * (1.0D - renderer.renderMaxZ) + (double)aoXYZNNN * (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMaxZ) + (double)aoXYZNNP * (1.0D - renderer.renderMinY) * renderer.renderMaxZ); + + int brXYZNNP = renderer.getAoBrightness(aoBrightnessXYIN, aoBrightnessXYZINP, aoBrightnessXZIP, blockBrightness); + int brXYZNPP = renderer.getAoBrightness(aoBrightnessXZIP, aoBrightnessXYIP, aoBrightnessXYZIPP, blockBrightness); + int brXYZNPN = renderer.getAoBrightness(aoBrightnessXZIN, aoBrightnessXYZIPN, aoBrightnessXYIP, blockBrightness); + int brXYZNNN = renderer.getAoBrightness(aoBrightnessXYZINN, aoBrightnessXYIN, aoBrightnessXZIN, blockBrightness); + + renderer.brightnessTopLeft = renderer.mixAoBrightness(brXYZNPP, brXYZNPN, brXYZNNN, brXYZNNP, renderer.renderMaxY * renderer.renderMaxZ, renderer.renderMaxY * (1.0D - renderer.renderMaxZ), (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMaxZ), (1.0D - renderer.renderMaxY) * renderer.renderMaxZ); + renderer.brightnessBottomLeft = renderer.mixAoBrightness(brXYZNPP, brXYZNPN, brXYZNNN, brXYZNNP, renderer.renderMaxY * renderer.renderMinZ, renderer.renderMaxY * (1.0D - renderer.renderMinZ), (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMinZ), (1.0D - renderer.renderMaxY) * renderer.renderMinZ); + renderer.brightnessBottomRight = renderer.mixAoBrightness(brXYZNPP, brXYZNPN, brXYZNNN, brXYZNNP, renderer.renderMinY * renderer.renderMinZ, renderer.renderMinY * (1.0D - renderer.renderMinZ), (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMinZ), (1.0D - renderer.renderMinY) * renderer.renderMinZ); + renderer.brightnessTopRight = renderer.mixAoBrightness(brXYZNPP, brXYZNPN, brXYZNNN, brXYZNNP, renderer.renderMinY * renderer.renderMaxZ, renderer.renderMinY * (1.0D - renderer.renderMaxZ), (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMaxZ), (1.0D - renderer.renderMinY) * renderer.renderMaxZ); + + renderer.colorRedTopLeft = renderer.colorRedBottomLeft = renderer.colorRedBottomRight = renderer.colorRedTopRight = r * 0.6F; + renderer.colorGreenTopLeft = renderer.colorGreenBottomLeft = renderer.colorGreenBottomRight = renderer.colorGreenTopRight = g * 0.6F; + renderer.colorBlueTopLeft = renderer.colorBlueBottomLeft = renderer.colorBlueBottomRight = renderer.colorBlueTopRight = b * 0.6F; + + renderer.colorRedTopLeft *= aoTL; + renderer.colorGreenTopLeft *= aoTL; + renderer.colorBlueTopLeft *= aoTL; + renderer.colorRedBottomLeft *= aoBL; + renderer.colorGreenBottomLeft *= aoBL; + renderer.colorBlueBottomLeft *= aoBL; + renderer.colorRedBottomRight *= aoBR; + renderer.colorGreenBottomRight *= aoBR; + renderer.colorBlueBottomRight *= aoBR; + renderer.colorRedTopRight *= aoTR; + renderer.colorGreenTopRight *= aoTR; + renderer.colorBlueTopRight *= aoTR; + } + + public void setupXPosAOPartial (RenderBlocks renderer, Block block, int x, int y, int z, float r, float g, float b) { + Tessellator tessellator = Tessellator.instance; + tessellator.setBrightness(983055); + + int xGrass = (renderer.renderMaxX >= 1) ? x + 1 : x; + + boolean blocksGrassXYNP = !renderer.blockAccess.getBlock(xGrass, y + 1, z).getCanBlockGrass(); + boolean blocksGrassXYNN = !renderer.blockAccess.getBlock(xGrass, y - 1, z).getCanBlockGrass(); + boolean blocksGrassXZNN = !renderer.blockAccess.getBlock(xGrass, y, z - 1).getCanBlockGrass(); + boolean blocksGrassXZNP = !renderer.blockAccess.getBlock(xGrass, y, z + 1).getCanBlockGrass(); + + if (renderer.renderMaxX < 1) + setupAOBrightnessXPos(renderer, block, x, y, z, blocksGrassXYNP, blocksGrassXYNN, blocksGrassXZNN, blocksGrassXZNP); + + setupAOBrightnessXNeg(renderer, block, x + 1, y, z, blocksGrassXYNP, blocksGrassXYNN, blocksGrassXZNN, blocksGrassXZNP); + + float xClamp = MathHelper.clamp_float((float)renderer.renderMaxX, 0, 1); + mixAOBrightnessLightValueX(xClamp, 1 - xClamp); + + int blockBrightness = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z); + if (renderer.renderMaxX >= 1.0D || !renderer.blockAccess.getBlock(x + 1, y, z).isOpaqueCube()) + blockBrightness = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y, z); + + float aoOpposingBlock = renderer.blockAccess.getBlock(x + 1, y, z).getAmbientOcclusionLightValue(); + float aoXYZPNP = (aoLightValueScratchXYIN + aoLightValueScratchXYZINP + aoOpposingBlock + aoLightValueScratchXZIP) / 4.0F; + float aoXYZPNN = (aoLightValueScratchXYZINN + aoLightValueScratchXYIN + aoLightValueScratchXZIN + aoOpposingBlock) / 4.0F; + float aoXYZPPN = (aoLightValueScratchXZIN + aoOpposingBlock + aoLightValueScratchXYZIPN + aoLightValueScratchXYIP) / 4.0F; + float aoXYZPPP = (aoOpposingBlock + aoLightValueScratchXZIP + aoLightValueScratchXYIP + aoLightValueScratchXYZIPP) / 4.0F; + + float aoTL = (float)((double)aoXYZPNP * (1.0D - renderer.renderMinY) * renderer.renderMaxZ + (double)aoXYZPNN * (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMaxZ) + (double)aoXYZPPN * renderer.renderMinY * (1.0D - renderer.renderMaxZ) + (double)aoXYZPPP * renderer.renderMinY * renderer.renderMaxZ); + float aoBL = (float)((double)aoXYZPNP * (1.0D - renderer.renderMinY) * renderer.renderMinZ + (double)aoXYZPNN * (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMinZ) + (double)aoXYZPPN * renderer.renderMinY * (1.0D - renderer.renderMinZ) + (double)aoXYZPPP * renderer.renderMinY * renderer.renderMinZ); + float aoBR = (float)((double)aoXYZPNP * (1.0D - renderer.renderMaxY) * renderer.renderMinZ + (double)aoXYZPNN * (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMinZ) + (double)aoXYZPPN * renderer.renderMaxY * (1.0D - renderer.renderMinZ) + (double)aoXYZPPP * renderer.renderMaxY * renderer.renderMinZ); + float aoTR = (float)((double)aoXYZPNP * (1.0D - renderer.renderMaxY) * renderer.renderMaxZ + (double)aoXYZPNN * (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMaxZ) + (double)aoXYZPPN * renderer.renderMaxY * (1.0D - renderer.renderMaxZ) + (double)aoXYZPPP * renderer.renderMaxY * renderer.renderMaxZ); + + int brXYZPNP = renderer.getAoBrightness(aoBrightnessXYIN, aoBrightnessXYZINP, aoBrightnessXZIP, blockBrightness); + int brXYZPNN = renderer.getAoBrightness(aoBrightnessXZIP, aoBrightnessXYIP, aoBrightnessXYZIPP, blockBrightness); + int brXYZPPN = renderer.getAoBrightness(aoBrightnessXZIN, aoBrightnessXYZIPN, aoBrightnessXYIP, blockBrightness); + int brXYZPPP = renderer.getAoBrightness(aoBrightnessXYZINN, aoBrightnessXYIN, aoBrightnessXZIN, blockBrightness); + + renderer.brightnessTopLeft = renderer.mixAoBrightness(brXYZPNP, brXYZPPP, brXYZPPN, brXYZPNN, (1.0D - renderer.renderMinY) * renderer.renderMaxZ, (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMaxZ), renderer.renderMinY * (1.0D - renderer.renderMaxZ), renderer.renderMinY * renderer.renderMaxZ); + renderer.brightnessBottomLeft = renderer.mixAoBrightness(brXYZPNP, brXYZPPP, brXYZPPN, brXYZPNN, (1.0D - renderer.renderMinY) * renderer.renderMinZ, (1.0D - renderer.renderMinY) * (1.0D - renderer.renderMinZ), renderer.renderMinY * (1.0D - renderer.renderMinZ), renderer.renderMinY * renderer.renderMinZ); + renderer.brightnessBottomRight = renderer.mixAoBrightness(brXYZPNP, brXYZPPP, brXYZPPN, brXYZPNN, (1.0D - renderer.renderMaxY) * renderer.renderMinZ, (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMinZ), renderer.renderMaxY * (1.0D - renderer.renderMinZ), renderer.renderMaxY * renderer.renderMinZ); + renderer.brightnessTopRight = renderer.mixAoBrightness(brXYZPNP, brXYZPPP, brXYZPPN, brXYZPNN, (1.0D - renderer.renderMaxY) * renderer.renderMaxZ, (1.0D - renderer.renderMaxY) * (1.0D - renderer.renderMaxZ), renderer.renderMaxY * (1.0D - renderer.renderMaxZ), renderer.renderMaxY * renderer.renderMaxZ); + + renderer.colorRedTopLeft = renderer.colorRedBottomLeft = renderer.colorRedBottomRight = renderer.colorRedTopRight = r * 0.6F; + renderer.colorGreenTopLeft = renderer.colorGreenBottomLeft = renderer.colorGreenBottomRight = renderer.colorGreenTopRight = g * 0.6F; + renderer.colorBlueTopLeft = renderer.colorBlueBottomLeft = renderer.colorBlueBottomRight = renderer.colorBlueTopRight = b * 0.6F; + + renderer.colorRedTopLeft *= aoTL; + renderer.colorGreenTopLeft *= aoTL; + renderer.colorBlueTopLeft *= aoTL; + renderer.colorRedBottomLeft *= aoBL; + renderer.colorGreenBottomLeft *= aoBL; + renderer.colorBlueBottomLeft *= aoBL; + renderer.colorRedBottomRight *= aoBR; + renderer.colorGreenBottomRight *= aoBR; + renderer.colorBlueBottomRight *= aoBR; + renderer.colorRedTopRight *= aoTR; + renderer.colorGreenTopRight *= aoTR; + renderer.colorBlueTopRight *= aoTR; + } + + private void setupAOBrightnessYNeg (RenderBlocks renderer, Block block, int x, int y, int z, boolean bgXP, boolean bgXN, boolean bgZP, boolean bgZN) { + aoLightValueScratchXYNN = renderer.blockAccess.getBlock(x - 1, y, z).getAmbientOcclusionLightValue(); + aoLightValueScratchYZNN = renderer.blockAccess.getBlock(x, y, z - 1).getAmbientOcclusionLightValue(); + aoLightValueScratchYZNP = renderer.blockAccess.getBlock(x, y, z + 1).getAmbientOcclusionLightValue(); + aoLightValueScratchXYPN = renderer.blockAccess.getBlock(x + 1, y, z).getAmbientOcclusionLightValue(); + aoLightValueScratchXYZNNN = aoLightValueScratchXYNN; + aoLightValueScratchXYZNNP = aoLightValueScratchXYNN; + aoLightValueScratchXYZPNN = aoLightValueScratchXYPN; + aoLightValueScratchXYZPNP = aoLightValueScratchXYPN; + + aoBrightnessXYNN = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y, z); + aoBrightnessYZNN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z - 1); + aoBrightnessYZNP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z + 1); + aoBrightnessXYPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y, z); + aoBrightnessXYZNNN = aoBrightnessXYNN; + aoBrightnessXYZNNP = aoBrightnessXYNN; + aoBrightnessXYZPNN = aoBrightnessXYPN; + aoBrightnessXYZPNP = aoBrightnessXYPN; + + if (bgXN || bgZN) { + aoLightValueScratchXYZNNN = renderer.blockAccess.getBlock(x - 1, y, z - 1).getAmbientOcclusionLightValue(); + aoBrightnessXYZNNN = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y, z - 1); + } + + if (bgXN || bgZP) { + aoLightValueScratchXYZNNP = renderer.blockAccess.getBlock(x - 1, y, z + 1).getAmbientOcclusionLightValue(); + aoBrightnessXYZNNP = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y, z + 1); + } + + if (bgXP || bgZN) { + aoLightValueScratchXYZPNN = renderer.blockAccess.getBlock(x + 1, y, z - 1).getAmbientOcclusionLightValue(); + aoBrightnessXYZPNN = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y, z - 1); + } + + if (bgXP || bgZP) { + aoLightValueScratchXYZPNP = renderer.blockAccess.getBlock(x + 1, y, z + 1).getAmbientOcclusionLightValue(); + aoBrightnessXYZPNP = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y, z + 1); + } + } + + private void setupAOBrightnessYPos (RenderBlocks renderer, Block block, int x, int y, int z, boolean bgXP, boolean bgXN, boolean bgZP, boolean bgZN) { + aoLightValueScratchXYNP = renderer.blockAccess.getBlock(x - 1, y, z).getAmbientOcclusionLightValue(); + aoLightValueScratchYZPN = renderer.blockAccess.getBlock(x, y, z - 1).getAmbientOcclusionLightValue(); + aoLightValueScratchYZPP = renderer.blockAccess.getBlock(x, y, z + 1).getAmbientOcclusionLightValue(); + aoLightValueScratchXYPP = renderer.blockAccess.getBlock(x + 1, y, z).getAmbientOcclusionLightValue(); + aoLightValueScratchXYZNPN = aoLightValueScratchXYNP; + aoLightValueScratchXYZNPP = aoLightValueScratchXYNP; + aoLightValueScratchXYZPPN = aoLightValueScratchXYPP; + aoLightValueScratchXYZPPP = aoLightValueScratchXYPP; + + aoBrightnessXYNP = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y, z); + aoBrightnessYZPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z - 1); + aoBrightnessYZPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z + 1); + aoBrightnessXYPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y, z); + aoBrightnessXYZNPN = aoBrightnessXYNP; + aoBrightnessXYZNPP = aoBrightnessXYNP; + aoBrightnessXYZPPN = aoBrightnessXYPP; + aoBrightnessXYZPPP = aoBrightnessXYPP; + + if (bgXN || bgZN) { + aoLightValueScratchXYZNPN = renderer.blockAccess.getBlock(x - 1, y, z - 1).getAmbientOcclusionLightValue(); + aoBrightnessXYZNPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y, z - 1); + } + + if (bgXN || bgZP) { + aoLightValueScratchXYZNPP = renderer.blockAccess.getBlock(x - 1, y, z + 1).getAmbientOcclusionLightValue(); + aoBrightnessXYZNPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y, z + 1); + } + + if (bgXP || bgZN) { + aoLightValueScratchXYZPPN = renderer.blockAccess.getBlock(x + 1, y, z - 1).getAmbientOcclusionLightValue(); + aoBrightnessXYZPPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y, z - 1); + } + + if (bgXP || bgZP) { + aoLightValueScratchXYZPPP = renderer.blockAccess.getBlock(x + 1, y, z + 1).getAmbientOcclusionLightValue(); + aoBrightnessXYZPPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y, z + 1); + } + } + + private void setupAOBrightnessZNeg (RenderBlocks renderer, Block block, int x, int y, int z, boolean bgXP, boolean bgXN, boolean bgYP, boolean bgYN) { + aoLightValueScratchXZNN = renderer.blockAccess.getBlock(x - 1, y, z).getAmbientOcclusionLightValue(); + aoLightValueScratchYZNN = renderer.blockAccess.getBlock(x, y - 1, z).getAmbientOcclusionLightValue(); + aoLightValueScratchYZPN = renderer.blockAccess.getBlock(x, y + 1, z).getAmbientOcclusionLightValue(); + aoLightValueScratchXZPN = renderer.blockAccess.getBlock(x + 1, y, z).getAmbientOcclusionLightValue(); + aoLightValueScratchXYZNNN = aoLightValueScratchXZNN; + aoLightValueScratchXYZNPN = aoLightValueScratchXZNN; + aoLightValueScratchXYZPNN = aoLightValueScratchXZPN; + aoLightValueScratchXYZPPN = aoLightValueScratchXZPN; + + aoBrightnessXZNN = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y, z); + aoBrightnessYZNN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y - 1, z); + aoBrightnessYZPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y + 1, z); + aoBrightnessXZPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y, z); + aoBrightnessXYZNNN = aoBrightnessXZNN; + aoBrightnessXYZNPN = aoBrightnessXZNN; + aoBrightnessXYZPNN = aoBrightnessXZPN; + aoBrightnessXYZPPN = aoBrightnessXZPN; + + if (bgXN || bgYN) { + aoLightValueScratchXYZNNN = renderer.blockAccess.getBlock(x - 1, y - 1, z).getAmbientOcclusionLightValue(); + aoBrightnessXYZNNN = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y - 1, z); + } + + if (bgXN || bgYP) { + aoLightValueScratchXYZNPN = renderer.blockAccess.getBlock(x - 1, y + 1, z).getAmbientOcclusionLightValue(); + aoBrightnessXYZNPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y + 1, z); + } + + if (bgXP || bgYN) { + aoLightValueScratchXYZPNN = renderer.blockAccess.getBlock(x + 1, y - 1, z).getAmbientOcclusionLightValue(); + aoBrightnessXYZPNN = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y - 1, z); + } + + if (bgXP || bgYP) { + aoLightValueScratchXYZPPN = renderer.blockAccess.getBlock(x + 1, y + 1, z).getAmbientOcclusionLightValue(); + aoBrightnessXYZPPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y + 1, z); + } + } + + private void setupAOBrightnessZPos (RenderBlocks renderer, Block block, int x, int y, int z, boolean bgXP, boolean bgXN, boolean bgYP, boolean bgYN) { + aoLightValueScratchXZNP = renderer.blockAccess.getBlock(x - 1, y, z).getAmbientOcclusionLightValue(); + aoLightValueScratchXZPP = renderer.blockAccess.getBlock(x + 1, y, z).getAmbientOcclusionLightValue(); + aoLightValueScratchYZNP = renderer.blockAccess.getBlock(x, y - 1, z).getAmbientOcclusionLightValue(); + aoLightValueScratchYZPP = renderer.blockAccess.getBlock(x, y + 1, z).getAmbientOcclusionLightValue(); + aoLightValueScratchXYZNNP = aoLightValueScratchXZNP; + aoLightValueScratchXYZNPP = aoLightValueScratchXZNP; + aoLightValueScratchXYZPNP = aoLightValueScratchXZPP; + aoLightValueScratchXYZPPP = aoLightValueScratchXZPP; + + aoBrightnessXZNP = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y, z); + aoBrightnessXZPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y, z); + aoBrightnessYZNP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y - 1, z); + aoBrightnessYZPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y + 1, z); + aoBrightnessXYZNNP = aoBrightnessXZNP; + aoBrightnessXYZNPP = aoBrightnessXZNP; + aoBrightnessXYZPNP = aoBrightnessXZPP; + aoBrightnessXYZPPP = aoBrightnessXZPP; + + if (bgXN || bgYN) { + aoLightValueScratchXYZNNP = renderer.blockAccess.getBlock(x - 1, y - 1, z).getAmbientOcclusionLightValue(); + aoBrightnessXYZNNP = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y - 1, z); + } + + if (bgXN || bgYP) { + aoLightValueScratchXYZNPP = renderer.blockAccess.getBlock(x - 1, y + 1, z).getAmbientOcclusionLightValue(); + aoBrightnessXYZNPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y + 1, z); + } + + if (bgXP || bgYN) { + aoLightValueScratchXYZPNP = renderer.blockAccess.getBlock(x + 1, y - 1, z).getAmbientOcclusionLightValue(); + aoBrightnessXYZPNP = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y - 1, z); + } + + if (bgXP || bgYP) { + aoLightValueScratchXYZPPP = renderer.blockAccess.getBlock(x + 1, y + 1, z).getAmbientOcclusionLightValue(); + aoBrightnessXYZPPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y + 1, z); + } + } + + private void setupAOBrightnessXNeg (RenderBlocks renderer, Block block, int x, int y, int z, boolean bgYP, boolean bgYN, boolean bgZN, boolean bgZP) { + aoLightValueScratchXYNN = renderer.blockAccess.getBlock(x, y - 1, z).getAmbientOcclusionLightValue(); + aoLightValueScratchXZNN = renderer.blockAccess.getBlock(x, y, z - 1).getAmbientOcclusionLightValue(); + aoLightValueScratchXZNP = renderer.blockAccess.getBlock(x, y, z + 1).getAmbientOcclusionLightValue(); + aoLightValueScratchXYNP = renderer.blockAccess.getBlock(x, y + 1, z).getAmbientOcclusionLightValue(); + aoLightValueScratchXYZNNN = aoLightValueScratchXZNN; + aoLightValueScratchXYZNNP = aoLightValueScratchXZNP; + aoLightValueScratchXYZNPN = aoLightValueScratchXZNN; + aoLightValueScratchXYZNPP = aoLightValueScratchXZNP; + + aoBrightnessXYNN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y - 1, z); + aoBrightnessXZNN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z - 1); + aoBrightnessXZNP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z + 1); + aoBrightnessXYNP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y + 1, z); + aoBrightnessXYZNNN = aoBrightnessXZNN; + aoBrightnessXYZNNP = aoBrightnessXZNP; + aoBrightnessXYZNPN = aoBrightnessXZNN; + aoBrightnessXYZNPP = aoBrightnessXZNP; + + if (bgZN || bgYN) { + aoLightValueScratchXYZNNN = renderer.blockAccess.getBlock(x, y - 1, z - 1).getAmbientOcclusionLightValue(); + aoBrightnessXYZNNN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y - 1, z - 1); + } + + if (bgZP || bgYN) { + aoLightValueScratchXYZNNP = renderer.blockAccess.getBlock(x, y - 1, z + 1).getAmbientOcclusionLightValue(); + aoBrightnessXYZNNP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y - 1, z + 1); + } + + if (bgZN || bgYP) { + aoLightValueScratchXYZNPN = renderer.blockAccess.getBlock(x, y + 1, z - 1).getAmbientOcclusionLightValue(); + aoBrightnessXYZNPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y + 1, z - 1); + } + + if (bgZP || bgYP) { + aoLightValueScratchXYZNPP = renderer.blockAccess.getBlock(x, y + 1, z + 1).getAmbientOcclusionLightValue(); + aoBrightnessXYZNPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y + 1, z + 1); + } + } + + private void setupAOBrightnessXPos (RenderBlocks renderer, Block block, int x, int y, int z, boolean bgYP, boolean bgYN, boolean bgZN, boolean bgZP) { + aoLightValueScratchXYPN = renderer.blockAccess.getBlock(x, y - 1, z).getAmbientOcclusionLightValue(); + aoLightValueScratchXZPN = renderer.blockAccess.getBlock(x, y, z - 1).getAmbientOcclusionLightValue(); + aoLightValueScratchXZPP = renderer.blockAccess.getBlock(x, y, z + 1).getAmbientOcclusionLightValue(); + aoLightValueScratchXYPP = renderer.blockAccess.getBlock(x, y + 1, z).getAmbientOcclusionLightValue(); + aoLightValueScratchXYZPNN = aoLightValueScratchXZPN; + aoLightValueScratchXYZPNP = aoLightValueScratchXZPP; + aoLightValueScratchXYZPPN = aoLightValueScratchXZPN; + aoLightValueScratchXYZPPP = aoLightValueScratchXZPP; + + aoBrightnessXYPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y - 1, z); + aoBrightnessXZPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z - 1); + aoBrightnessXZPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z + 1); + aoBrightnessXYPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y + 1, z); + aoBrightnessXYZPNN = aoBrightnessXZPN; + aoBrightnessXYZPNP = aoBrightnessXZPP; + aoBrightnessXYZPPN = aoBrightnessXZPN; + aoBrightnessXYZPPP = aoBrightnessXZPP; + + if (bgYN || bgZN) { + aoLightValueScratchXYZPNN = renderer.blockAccess.getBlock(x, y - 1, z - 1).getAmbientOcclusionLightValue(); + aoBrightnessXYZPNN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y - 1, z - 1); + } + + if (bgYN || bgZP) { + aoLightValueScratchXYZPNP = renderer.blockAccess.getBlock(x, y - 1, z + 1).getAmbientOcclusionLightValue(); + aoBrightnessXYZPNP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y - 1, z + 1); + } + + if (bgYP || bgZN) { + aoLightValueScratchXYZPPN = renderer.blockAccess.getBlock(x, y + 1, z - 1).getAmbientOcclusionLightValue(); + aoBrightnessXYZPPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y + 1, z - 1); + } + + if (bgYP || bgZP) { + aoLightValueScratchXYZPPP = renderer.blockAccess.getBlock(x, y + 1, z + 1).getAmbientOcclusionLightValue(); + aoBrightnessXYZPPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y + 1, z + 1); + } + } + + private void mixAOBrightnessLightValueY (float fMin, float fMax) { + if (fMin == 1 && fMax == 0) { + aoLightValueScratchXYNI = aoLightValueScratchXYNN; + aoLightValueScratchYZIN = aoLightValueScratchYZNN; + aoLightValueScratchYZIP = aoLightValueScratchYZNP; + aoLightValueScratchXYPI = aoLightValueScratchXYPN; + aoLightValueScratchXYZNIN = aoLightValueScratchXYZNNN; + aoLightValueScratchXYZNIP = aoLightValueScratchXYZNNP; + aoLightValueScratchXYZPIN = aoLightValueScratchXYZPNN; + aoLightValueScratchXYZPIP = aoLightValueScratchXYZPNP; + + aoBrightnessXYNI = aoBrightnessXYNN; + aoBrightnessYZIN = aoBrightnessYZNN; + aoBrightnessYZIP = aoBrightnessYZNP; + aoBrightnessXYPI = aoBrightnessXYPN; + aoBrightnessXYZNIN = aoBrightnessXYZNNN; + aoBrightnessXYZNIP = aoBrightnessXYZNNP; + aoBrightnessXYZPIN = aoBrightnessXYZPNN; + aoBrightnessXYZPIP = aoBrightnessXYZPNP; + } + else if (fMin == 0 && fMax == 1) { + aoLightValueScratchXYNI = aoLightValueScratchXYNP; + aoLightValueScratchYZIN = aoLightValueScratchYZPN; + aoLightValueScratchYZIP = aoLightValueScratchYZPP; + aoLightValueScratchXYPI = aoLightValueScratchXYPP; + aoLightValueScratchXYZNIN = aoLightValueScratchXYZNPN; + aoLightValueScratchXYZNIP = aoLightValueScratchXYZNPP; + aoLightValueScratchXYZPIN = aoLightValueScratchXYZPPN; + aoLightValueScratchXYZPIP = aoLightValueScratchXYZPPP; + + aoBrightnessXYNI = aoBrightnessXYNP; + aoBrightnessYZIN = aoBrightnessYZPN; + aoBrightnessYZIP = aoBrightnessYZPP; + aoBrightnessXYPI = aoBrightnessXYPP; + aoBrightnessXYZNIN = aoBrightnessXYZNPN; + aoBrightnessXYZNIP = aoBrightnessXYZNPP; + aoBrightnessXYZPIN = aoBrightnessXYZPPN; + aoBrightnessXYZPIP = aoBrightnessXYZPPP; + } + else { + aoLightValueScratchXYNI = aoLightValueScratchXYNN * fMin + aoLightValueScratchXYNP * fMax; + aoLightValueScratchYZIN = aoLightValueScratchYZNN * fMin + aoLightValueScratchYZPN * fMax; + aoLightValueScratchYZIP = aoLightValueScratchYZNP * fMin + aoLightValueScratchYZPP * fMax; + aoLightValueScratchXYPI = aoLightValueScratchXYPN * fMin + aoLightValueScratchXYPP * fMax; + aoLightValueScratchXYZNIN = aoLightValueScratchXYZNNN * fMin + aoLightValueScratchXYZNPN * fMax; + aoLightValueScratchXYZNIP = aoLightValueScratchXYZNNP * fMin + aoLightValueScratchXYZNPP * fMax; + aoLightValueScratchXYZPIN = aoLightValueScratchXYZPNN * fMin + aoLightValueScratchXYZPPN * fMax; + aoLightValueScratchXYZPIP = aoLightValueScratchXYZPNP * fMin + aoLightValueScratchXYZPPP * fMax; + + aoBrightnessXYNI = mixAOBrightness(aoBrightnessXYNN, aoBrightnessXYNP, fMin, fMax); + aoBrightnessYZIN = mixAOBrightness(aoBrightnessYZNN, aoBrightnessYZPN, fMin, fMax); + aoBrightnessYZIP = mixAOBrightness(aoBrightnessYZNP, aoBrightnessYZPP, fMin, fMax); + aoBrightnessXYPI = mixAOBrightness(aoBrightnessXYPN, aoBrightnessXYPP, fMin, fMax); + aoBrightnessXYZNIN = mixAOBrightness(aoBrightnessXYZNNN, aoBrightnessXYZNPN, fMin, fMax); + aoBrightnessXYZNIP = mixAOBrightness(aoBrightnessXYZNNP, aoBrightnessXYZNPP, fMin, fMax); + aoBrightnessXYZPIN = mixAOBrightness(aoBrightnessXYZPNN, aoBrightnessXYZPPN, fMin, fMax); + aoBrightnessXYZPIP = mixAOBrightness(aoBrightnessXYZPNP, aoBrightnessXYZPPP, fMin, fMax); + } + } + + private void mixAOBrightnessLightValueZ (float fMin, float fMax) { + if (fMin == 1 && fMax == 0) { + aoLightValueScratchXZNI = aoLightValueScratchXZNN; + aoLightValueScratchYZNI = aoLightValueScratchYZNN; + aoLightValueScratchYZPI = aoLightValueScratchYZPN; + aoLightValueScratchXZPI = aoLightValueScratchXZPN; + aoLightValueScratchXYZNNI = aoLightValueScratchXYZNNN; + aoLightValueScratchXYZNPI = aoLightValueScratchXYZNPN; + aoLightValueScratchXYZPNI = aoLightValueScratchXYZPNN; + aoLightValueScratchXYZPPI = aoLightValueScratchXYZPPN; + + aoBrightnessXZNI = aoBrightnessXZNN; + aoBrightnessYZNI = aoBrightnessYZNN; + aoBrightnessYZPI = aoBrightnessYZPN; + aoBrightnessXZPI = aoBrightnessXZPN; + aoBrightnessXYZNNI = aoBrightnessXYZNNN; + aoBrightnessXYZNPI = aoBrightnessXYZNPN; + aoBrightnessXYZPNI = aoBrightnessXYZPNN; + aoBrightnessXYZPPI = aoBrightnessXYZPPN; + } + else if (fMin == 0 && fMax == 1) { + aoLightValueScratchXZNI = aoLightValueScratchXZNP; + aoLightValueScratchYZNI = aoLightValueScratchYZNP; + aoLightValueScratchYZPI = aoLightValueScratchYZPP; + aoLightValueScratchXZPI = aoLightValueScratchXZPP; + aoLightValueScratchXYZNNI = aoLightValueScratchXYZNNP; + aoLightValueScratchXYZNPI = aoLightValueScratchXYZNPP; + aoLightValueScratchXYZPNI = aoLightValueScratchXYZPNP; + aoLightValueScratchXYZPPI = aoLightValueScratchXYZPPP; + + aoBrightnessXZNI = aoBrightnessXZNP; + aoBrightnessYZNI = aoBrightnessYZNP; + aoBrightnessYZPI = aoBrightnessYZPP; + aoBrightnessXZPI = aoBrightnessXZPP; + aoBrightnessXYZNNI = aoBrightnessXYZNNP; + aoBrightnessXYZNPI = aoBrightnessXYZNPP; + aoBrightnessXYZPNI = aoBrightnessXYZPNP; + aoBrightnessXYZPPI = aoBrightnessXYZPPP; + } + else { + aoLightValueScratchXZNI = aoLightValueScratchXZNN * fMin + aoLightValueScratchXZNP * fMax; + aoLightValueScratchYZNI = aoLightValueScratchYZNN * fMin + aoLightValueScratchYZNP * fMax; + aoLightValueScratchYZPI = aoLightValueScratchYZPN * fMin + aoLightValueScratchYZPP * fMax; + aoLightValueScratchXZPI = aoLightValueScratchXZPN * fMin + aoLightValueScratchXZPP * fMax; + aoLightValueScratchXYZNNI = aoLightValueScratchXYZNNN * fMin + aoLightValueScratchXYZNNP * fMax; + aoLightValueScratchXYZNPI = aoLightValueScratchXYZNPN * fMin + aoLightValueScratchXYZNPP * fMax; + aoLightValueScratchXYZPNI = aoLightValueScratchXYZPNN * fMin + aoLightValueScratchXYZPNP * fMax; + aoLightValueScratchXYZPPI = aoLightValueScratchXYZPPN * fMin + aoLightValueScratchXYZPPP * fMax; + + aoBrightnessXZNI = mixAOBrightness(aoBrightnessXZNN, aoBrightnessXZNP, fMin, fMax); + aoBrightnessYZNI = mixAOBrightness(aoBrightnessYZNN, aoBrightnessYZNP, fMin, fMax); + aoBrightnessYZPI = mixAOBrightness(aoBrightnessYZPN, aoBrightnessYZPP, fMin, fMax); + aoBrightnessXZPI = mixAOBrightness(aoBrightnessXZPN, aoBrightnessXZPP, fMin, fMax); + aoBrightnessXYZNNI = mixAOBrightness(aoBrightnessXYZNNN, aoBrightnessXYZNNP, fMin, fMax); + aoBrightnessXYZNPI = mixAOBrightness(aoBrightnessXYZNPN, aoBrightnessXYZNPP, fMin, fMax); + aoBrightnessXYZPNI = mixAOBrightness(aoBrightnessXYZPNN, aoBrightnessXYZPNP, fMin, fMax); + aoBrightnessXYZPPI = mixAOBrightness(aoBrightnessXYZPPN, aoBrightnessXYZPPP, fMin, fMax); + } + } + + private void mixAOBrightnessLightValueX (float fMin, float fMax) { + if (fMin == 1 && fMax == 0) { + aoLightValueScratchXYIN = aoLightValueScratchXYNN; + aoLightValueScratchXZIN = aoLightValueScratchXZNN; + aoLightValueScratchXZIP = aoLightValueScratchXZNP; + aoLightValueScratchXYIP = aoLightValueScratchXYNP; + aoLightValueScratchXYZINN = aoLightValueScratchXYZNNN; + aoLightValueScratchXYZINP = aoLightValueScratchXYZNNP; + aoLightValueScratchXYZIPN = aoLightValueScratchXYZNPN; + aoLightValueScratchXYZIPP = aoLightValueScratchXYZNPP; + + aoBrightnessXYIN = aoBrightnessXYNN; + aoBrightnessXZIN = aoBrightnessXZNN; + aoBrightnessXZIP = aoBrightnessXZNP; + aoBrightnessXYIP = aoBrightnessXYNP; + aoBrightnessXYZINN = aoBrightnessXYZNNN; + aoBrightnessXYZINP = aoBrightnessXYZNNP; + aoBrightnessXYZIPN = aoBrightnessXYZNPN; + aoBrightnessXYZIPP = aoBrightnessXYZNPP; + } + else if (fMin == 0 && fMax == 1) { + aoLightValueScratchXYIN = aoLightValueScratchXYPN; + aoLightValueScratchXZIN = aoLightValueScratchXZPN; + aoLightValueScratchXZIP = aoLightValueScratchXZPP; + aoLightValueScratchXYIP = aoLightValueScratchXYPP; + aoLightValueScratchXYZINN = aoLightValueScratchXYZPNN; + aoLightValueScratchXYZINP = aoLightValueScratchXYZPNP; + aoLightValueScratchXYZIPN = aoLightValueScratchXYZPPN; + aoLightValueScratchXYZIPP = aoLightValueScratchXYZPPP; + + aoBrightnessXYIN = aoBrightnessXYPN; + aoBrightnessXZIN = aoBrightnessXZPN; + aoBrightnessXZIP = aoBrightnessXZPP; + aoBrightnessXYIP = aoBrightnessXYPP; + aoBrightnessXYZINN = aoBrightnessXYZPNN; + aoBrightnessXYZINP = aoBrightnessXYZPNP; + aoBrightnessXYZIPN = aoBrightnessXYZPPN; + aoBrightnessXYZIPP = aoBrightnessXYZPPP; + } + else { + aoLightValueScratchXYIN = aoLightValueScratchXYNN * fMin + aoLightValueScratchXYPN * fMax; + aoLightValueScratchXZIN = aoLightValueScratchXZNN * fMin + aoLightValueScratchXZPN * fMax; + aoLightValueScratchXZIP = aoLightValueScratchXZNP * fMin + aoLightValueScratchXZPP * fMax; + aoLightValueScratchXYIP = aoLightValueScratchXYNP * fMin + aoLightValueScratchXYPP * fMax; + aoLightValueScratchXYZINN = aoLightValueScratchXYZNNN * fMin + aoLightValueScratchXYZPNN * fMax; + aoLightValueScratchXYZINP = aoLightValueScratchXYZNNP * fMin + aoLightValueScratchXYZPNP * fMax; + aoLightValueScratchXYZIPN = aoLightValueScratchXYZNPN * fMin + aoLightValueScratchXYZPPN * fMax; + aoLightValueScratchXYZIPP = aoLightValueScratchXYZNPP * fMin + aoLightValueScratchXYZPPP * fMax; + + aoBrightnessXYIN = mixAOBrightness(aoBrightnessXYNN, aoBrightnessXYPN, fMin, fMax); + aoBrightnessXZIN = mixAOBrightness(aoBrightnessXZNN, aoBrightnessXZPN, fMin, fMax); + aoBrightnessXZIP = mixAOBrightness(aoBrightnessXZNP, aoBrightnessXZPP, fMin, fMax); + aoBrightnessXYIP = mixAOBrightness(aoBrightnessXYNP, aoBrightnessXYPP, fMin, fMax); + aoBrightnessXYZINN = mixAOBrightness(aoBrightnessXYZNNN, aoBrightnessXYZPNN, fMin, fMax); + aoBrightnessXYZINP = mixAOBrightness(aoBrightnessXYZNNP, aoBrightnessXYZPNP, fMin, fMax); + aoBrightnessXYZIPN = mixAOBrightness(aoBrightnessXYZNPN, aoBrightnessXYZPPN, fMin, fMax); + aoBrightnessXYZIPP = mixAOBrightness(aoBrightnessXYZNPP, aoBrightnessXYZPPP, fMin, fMax); + } + } + + public static int mixAOBrightness (int brightTL, int brightBL, int brightBR, int brightTR, double lerpTB, double lerpLR) + { + double brightSkyL = (brightTL >> 16 & 255) * (1 - lerpTB) + (brightBL >> 16 & 255) * lerpTB; + double brightSkyR = (brightTR >> 16 & 255) * (1 - lerpTB) + (brightBR >> 16 & 255) * lerpTB; + int brightSky = (int)(brightSkyL * (1 - lerpLR) + brightSkyR * lerpLR) & 255; + + double brightBlkL = (brightTL & 255) * (1 - lerpTB) + (brightBL & 255) * lerpTB; + double brightBlkR = (brightTR & 255) * (1 - lerpTB) + (brightBR & 255) * lerpTB; + int brightBlk = (int)(brightBlkL * (1 - lerpLR) + brightBlkR * lerpLR) & 255; + + return brightSky << 16 | brightBlk; + } + + public static int mixAOBrightness (int brightMin, int brightMax, float fMin, float fMax) { + if (brightMin == 0) + return 0; + if (brightMax == 0) + return 0; + + float brightSky = (brightMin >> 16 & 255) * fMin + (brightMax >> 16 & 255) * fMax; + float brightBlk = (brightMin & 255) * fMin + (brightMax & 255) * fMax; + + return ((int)brightSky & 255) << 16 | ((int)brightBlk & 255); + } +}