mirror of
https://github.com/GTNewHorizons/StorageDrawers.git
synced 2026-11-13 17:04:15 +00:00
L3 status upgrade changed to L2, L2 removed. All drawers support all status upgrades. Render work.
This commit is contained in:
Justin Aquadro committed
1 parent
26b143b6a1
commit
b42b105fcf
19 files changed
+1584
-93
No files matched your search
@@ -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
|
||||
|
||||
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 273 B |
Binary file not shown.
|
After Width: | Height: | Size: 316 B |
Binary file not shown.
|
After Width: | Height: | Size: 287 B |
Binary file not shown.
|
After Width: | Height: | Size: 330 B |
Binary file not shown.
|
After Width: | Height: | Size: 298 B |
Binary file not shown.
|
After Width: | Height: | Size: 342 B |
Binary file not shown.
|
Before Width: | Height: | Size: 397 B |
Binary file not shown.
|
Before Width: | Height: | Size: 342 B |
Binary file not shown.
|
Before Width: | Height: | Size: 367 B |
@@ -88,7 +88,7 @@ public class BlockCompDrawers extends BlockDrawers
|
||||
return iconFront[0];
|
||||
|
||||
if (side == tile.getDirection()) {
|
||||
if (tile.getStatusLevel() != 3) {
|
||||
if (tile.getStatusLevel() == 0) {
|
||||
if (tile.isDrawerEnabled(2) && tile.getDrawer(2).getStoredItemStackSize() > 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);
|
||||
}
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
+1
-1
@@ -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 };
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}*/
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user