diff --git a/README.md b/README.md index 17eb5ac66..bc9443892 100644 --- a/README.md +++ b/README.md @@ -16,6 +16,8 @@ - **Tim Rurkowski** - Music author +- **Soaryn** - Help with the Altar Frame renderer + ## World Conversion## As of Biomes O Plenty 0.5.2, changes have been made so that the number of block ids used by the mod are drastically reduced. However, as a side-effect of these changes, existing worlds will no longer work. diff --git a/src/minecraft/biomesoplenty/ClientProxy.java b/src/minecraft/biomesoplenty/ClientProxy.java index 634080614..32996fd03 100644 --- a/src/minecraft/biomesoplenty/ClientProxy.java +++ b/src/minecraft/biomesoplenty/ClientProxy.java @@ -14,6 +14,7 @@ import net.minecraftforge.fluids.RenderBlockFluid; import org.lwjgl.opengl.GL11; import biomesoplenty.api.Items; +import biomesoplenty.blocks.renderers.AltarRenderer; import biomesoplenty.blocks.renderers.FoliageRenderer; import biomesoplenty.blocks.renderers.PlantsRenderer; import biomesoplenty.blocks.renderers.SmallBlockRenderer; @@ -42,6 +43,7 @@ public class ClientProxy extends CommonProxy { RenderingRegistry.registerBlockHandler(new FoliageRenderer()); RenderingRegistry.registerBlockHandler(new PlantsRenderer()); RenderingRegistry.registerBlockHandler(new SmallBlockRenderer()); + RenderingRegistry.registerBlockHandler(new AltarRenderer()); //TODO: Remove upon Fluid API being integrated into Forge FluidRegistry.renderIdFluid = RenderingRegistry.getNextAvailableRenderId(); @@ -71,37 +73,4 @@ public class ClientProxy extends CommonProxy { { return RenderingRegistry.addNewArmourRendererPrefix(armor); } - - @Override - public void renderStandardInvBlock(RenderBlocks renderblocks, Block block, int meta) - { - Tessellator tessellator = Tessellator.instance; - GL11.glTranslatef(-0.5F, -0.5F, -0.5F); - tessellator.startDrawingQuads(); - tessellator.setNormal(0.0F, -1F, 0.0F); - renderblocks.renderFaceYNeg(block, 0.0D, 0.0D, 0.0D, block.getIcon(0, meta)); - tessellator.draw(); - tessellator.startDrawingQuads(); - tessellator.setNormal(0.0F, 1.0F, 0.0F); - renderblocks.renderFaceYPos(block, 0.0D, 0.0D, 0.0D, block.getIcon(1, meta)); - tessellator.draw(); - tessellator.startDrawingQuads(); - tessellator.setNormal(0.0F, 0.0F, -1F); - renderblocks.renderFaceZNeg(block, 0.0D, 0.0D, 0.0D, block.getIcon(2, meta)); - tessellator.draw(); - tessellator.startDrawingQuads(); - tessellator.setNormal(0.0F, 0.0F, 1.0F); - renderblocks.renderFaceZPos(block, 0.0D, 0.0D, 0.0D, block.getIcon(3, meta)); - tessellator.draw(); - tessellator.startDrawingQuads(); - tessellator.setNormal(-1F, 0.0F, 0.0F); - renderblocks.renderFaceXNeg(block, 0.0D, 0.0D, 0.0D, block.getIcon(4, meta)); - tessellator.draw(); - tessellator.startDrawingQuads(); - tessellator.setNormal(1.0F, 0.0F, 0.0F); - renderblocks.renderFaceXPos(block, 0.0D, 0.0D, 0.0D, block.getIcon(5, meta)); - tessellator.draw(); - GL11.glTranslatef(0.5F, 0.5F, 0.5F); - } - } \ No newline at end of file diff --git a/src/minecraft/biomesoplenty/CommonProxy.java b/src/minecraft/biomesoplenty/CommonProxy.java index 4ebe96e38..cb039eab7 100644 --- a/src/minecraft/biomesoplenty/CommonProxy.java +++ b/src/minecraft/biomesoplenty/CommonProxy.java @@ -22,8 +22,4 @@ public class CommonProxy { public void spawnParticle(String string, double x, double y, double z) { } - - public void renderStandardInvBlock(RenderBlocks renderblocks, Block block, int meta) - { - } } \ No newline at end of file diff --git a/src/minecraft/biomesoplenty/api/Blocks.java b/src/minecraft/biomesoplenty/api/Blocks.java index 6d3d8669e..be0223bbc 100644 --- a/src/minecraft/biomesoplenty/api/Blocks.java +++ b/src/minecraft/biomesoplenty/api/Blocks.java @@ -94,6 +94,8 @@ public class Blocks // public static Optional grass = Optional.absent(); public static Optional promisedPortal = Optional.absent(); + public static Optional glass = Optional.absent(); + public static Optional altar = Optional.absent(); /** * Populated by Biomes O Plenty with default Biomes O Plenty leaves. Add additional leaves here (E.g. "Blocks.shearBlockIds.put(acaciaLeaves.blockID, 15.0F);") diff --git a/src/minecraft/biomesoplenty/api/Items.java b/src/minecraft/biomesoplenty/api/Items.java index d509dc82b..c2ee676f3 100644 --- a/src/minecraft/biomesoplenty/api/Items.java +++ b/src/minecraft/biomesoplenty/api/Items.java @@ -39,6 +39,7 @@ public class Items public static Optional poison = Optional.absent(); public static Optional dartBlower = Optional.absent(); public static Optional dart = Optional.absent(); + public static Optional soulManipulator = Optional.absent(); public static Optional flowerBand = Optional.absent(); } diff --git a/src/minecraft/biomesoplenty/blocks/BlockAltar.java b/src/minecraft/biomesoplenty/blocks/BlockAltar.java new file mode 100644 index 000000000..b61bfa0b2 --- /dev/null +++ b/src/minecraft/biomesoplenty/blocks/BlockAltar.java @@ -0,0 +1,178 @@ +package biomesoplenty.blocks; + +import java.util.List; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +import net.minecraft.block.Block; +import net.minecraft.block.ITileEntityProvider; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.client.renderer.texture.IconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.Icon; +import net.minecraft.world.World; +import net.minecraftforge.client.MinecraftForgeClient; +import biomesoplenty.BiomesOPlenty; +import biomesoplenty.api.Blocks; +import biomesoplenty.api.Items; +import biomesoplenty.blocks.renderers.AltarRenderer; +import biomesoplenty.blocks.renderers.SmallBlockRenderer; +import biomesoplenty.tileentity.TileEntityAltar; + +public class BlockAltar extends Block +{ + private static final String[] altarTypes = new String[] {"altarframe"}; + + public static Icon altarFrame; + public static Icon altarFrameTop; + + public static Icon frameApatite; + public static Icon framePeridot; + public static Icon frameRuby; + public static Icon frameSapphire; + public static Icon frameTanzanite; + public static Icon frameTopaz; + + public BlockAltar(int blockID) + { + super(blockID, Material.glass); + this.setCreativeTab(BiomesOPlenty.tabBiomesOPlenty); + + this.blockHardness = 0.37F; + } + + @Override + public void registerIcons(IconRegister iconRegister) + { + altarFrame = iconRegister.registerIcon("BiomesOPlenty:altarframe"); + altarFrameTop = iconRegister.registerIcon("BiomesOPlenty:altarframetop"); + + frameApatite = iconRegister.registerIcon("BiomesOPlenty:frameapatite"); + framePeridot = iconRegister.registerIcon("BiomesOPlenty:frameperidot"); + frameRuby = iconRegister.registerIcon("BiomesOPlenty:frameruby"); + frameSapphire = iconRegister.registerIcon("BiomesOPlenty:framesapphire"); + frameTanzanite = iconRegister.registerIcon("BiomesOPlenty:frametanzanite"); + frameTopaz = iconRegister.registerIcon("BiomesOPlenty:frametopaz"); + } + + @Override + public Icon getIcon(int side, int meta) + { + + if (side == 1 || side == 0) + { + return altarFrameTop; + } + else + { + return altarFrame; + } + } + + @Override + public boolean hasTileEntity(int metadata) + { + return true; + } + + @Override + public TileEntity createTileEntity(World world, int metadata) + { + return new TileEntityAltar(); + } + + @Override + public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int par6, float par7, float par8, float par9) + { + boolean returnStatement = false; + + ItemStack equippedItem = player.getCurrentEquippedItem(); + TileEntityAltar tileentityaltar = (TileEntityAltar) world.getBlockTileEntity(x, y, z); + + if (equippedItem != null) + { + if (equippedItem.itemID == Items.miscItems.get().itemID && (equippedItem.getItemDamage() > 9 && equippedItem.getItemDamage() < 16)) + { + if (tileentityaltar != null) + { + returnStatement = true; + + if (world.isRemote) + { + if (!tileentityaltar.getPresent(equippedItem.getItemName())) + { + tileentityaltar.setPresent(equippedItem.getItemName(), true); + + world.markBlockForUpdate(x, y, z); + } + } + } + + + } + } + + if (!world.isRemote) + { + if (returnStatement == true) + { + if (!tileentityaltar.getPresent(equippedItem.getItemName())) + { + tileentityaltar.setPresent(equippedItem.getItemName(), true); + --equippedItem.stackSize; + + world.markBlockForUpdate(x, y, z); + } + } + } + + if (returnStatement == true) + { + return true; + } + else + { + return false; + } + } + + + @Override + @SuppressWarnings({ "rawtypes", "unchecked" }) + public void getSubBlocks(int blockID, CreativeTabs creativeTabs, List list) { + for (int i = 0; i < altarTypes.length; ++i) { + list.add(new ItemStack(blockID, 1, i)); + } + } + + @Override + public boolean isOpaqueCube() + { + return false; + } + + @Override + public boolean renderAsNormalBlock() + { + return false; + } + + @Override + public int getRenderType() + { + return AltarRenderer.altarModel; + } + + @Override + public int damageDropped(int meta) + { + return meta; + } +} diff --git a/src/minecraft/biomesoplenty/blocks/BlockBOPGlass.java b/src/minecraft/biomesoplenty/blocks/BlockBOPGlass.java new file mode 100644 index 000000000..68bc8c4b4 --- /dev/null +++ b/src/minecraft/biomesoplenty/blocks/BlockBOPGlass.java @@ -0,0 +1,59 @@ +package biomesoplenty.blocks; + +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.item.ItemStack; +import net.minecraft.util.Icon; +import biomesoplenty.BiomesOPlenty; + +public class BlockBOPGlass extends Block +{ + private static final String[] glassTypes = new String[] {"celestiallens", "sacrificialFocus"}; + private Icon[] textures; + + public BlockBOPGlass(int blockID) + { + super(blockID, Material.glass); + this.setCreativeTab(BiomesOPlenty.tabBiomesOPlenty); + + this.blockHardness = 0.37F; + } + + @Override + public void registerIcons(IconRegister iconRegister) + { + textures = new Icon[glassTypes.length]; + + for (int i = 0; i < glassTypes.length; ++i) { + textures[i] = iconRegister.registerIcon("BiomesOPlenty:"+glassTypes[i]); + } + } + + @Override + public Icon getIcon(int side, int meta) + { + if (meta < 0 || meta >= textures.length) { + meta = 0; + } + + return textures[meta]; + } + + @Override + @SuppressWarnings({ "rawtypes", "unchecked" }) + public void getSubBlocks(int blockID, CreativeTabs creativeTabs, List list) { + for (int i = 0; i < glassTypes.length; ++i) { + list.add(new ItemStack(blockID, 1, i)); + } + } + + @Override + public int damageDropped(int meta) + { + return meta; + } +} diff --git a/src/minecraft/biomesoplenty/blocks/renderers/AltarRenderer.java b/src/minecraft/biomesoplenty/blocks/renderers/AltarRenderer.java new file mode 100644 index 000000000..56dd5064f --- /dev/null +++ b/src/minecraft/biomesoplenty/blocks/renderers/AltarRenderer.java @@ -0,0 +1,112 @@ +package biomesoplenty.blocks.renderers; + +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.util.Icon; +import net.minecraft.world.IBlockAccess; +import net.minecraftforge.client.MinecraftForgeClient; +import net.minecraftforge.common.ForgeDirection; +import biomesoplenty.BiomesOPlenty; +import biomesoplenty.api.Blocks; +import biomesoplenty.blocks.BlockAltar; +import biomesoplenty.tileentity.TileEntityAltar; +import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler; +import cpw.mods.fml.client.registry.RenderingRegistry; + +public class AltarRenderer implements ISimpleBlockRenderingHandler +{ + public static int altarModel = RenderingRegistry.getNextAvailableRenderId(); + + @Override + public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) + { + TileEntityAltar tileentityaltar = (TileEntityAltar) world.getBlockTileEntity(x, y, z); + + if (modelId == altarModel) + { + if (tileentityaltar != null) + { + renderer.renderAllFaces = false; + + renderer.renderStandardBlock(block, x, y, z); + + renderer.setRenderBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F); + this.renderAltarSlotFaces(renderer, block, BlockAltar.altarFrame, world, x, y, z); + + if (tileentityaltar.getPresent("apatite")) + { + renderer.setRenderBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F); + this.renderAltarSlotFaces(renderer, block, BlockAltar.frameApatite, world, x, y, z); + } + + if (tileentityaltar.getPresent("peridot")) + { + renderer.setRenderBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F); + this.renderAltarSlotFaces(renderer, block, BlockAltar.framePeridot, world, x, y, z); + } + + if (tileentityaltar.getPresent("ruby")) + { + renderer.setRenderBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F); + this.renderAltarSlotFaces(renderer, block, BlockAltar.frameRuby, world, x, y, z); + } + + if (tileentityaltar.getPresent("sapphire")) + { + renderer.setRenderBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F); + this.renderAltarSlotFaces(renderer, block, BlockAltar.frameSapphire, world, x, y, z); + } + + if (tileentityaltar.getPresent("tanzanite")) + { + renderer.setRenderBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F); + this.renderAltarSlotFaces(renderer, block, BlockAltar.frameTanzanite, world, x, y, z); + } + + if (tileentityaltar.getPresent("topaz")) + { + renderer.setRenderBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F); + this.renderAltarSlotFaces(renderer, block, BlockAltar.frameTopaz, world, x, y, z); + } + + renderer.renderAllFaces = false; + + renderer.clearOverrideBlockTexture(); + } + } + + return true; + } + + public static void renderAltarSlotFaces(RenderBlocks renderer, Block block, Icon icon, IBlockAccess world, int x, int y, int z) + { + RenderUtils.renderFace(renderer, block, icon, world, x, y, z, ForgeDirection.NORTH); + RenderUtils.renderFace(renderer, block, icon, world, x, y, z, ForgeDirection.EAST); + RenderUtils.renderFace(renderer, block, icon, world, x, y, z, ForgeDirection.SOUTH); + RenderUtils.renderFace(renderer, block, icon, world, x, y, z, ForgeDirection.WEST); + } + + @Override + public void renderInventoryBlock(Block block, int metadata, int modelID, RenderBlocks renderer) + { + Tessellator tessellator = Tessellator.instance; + + renderer.setRenderBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F); + RenderUtils.renderStandardInvBlock(renderer, block, metadata); + } + + @Override + public boolean shouldRender3DInInventory() + { + return true; + } + + @Override + public int getRenderId() + { + return altarModel; + } +} diff --git a/src/minecraft/biomesoplenty/blocks/renderers/RenderUtils.java b/src/minecraft/biomesoplenty/blocks/renderers/RenderUtils.java new file mode 100644 index 000000000..bf2402546 --- /dev/null +++ b/src/minecraft/biomesoplenty/blocks/renderers/RenderUtils.java @@ -0,0 +1,774 @@ +package biomesoplenty.blocks.renderers; + +import org.lwjgl.opengl.GL11; + +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.util.Icon; +import net.minecraft.world.IBlockAccess; +import net.minecraftforge.common.ForgeDirection; + +public class RenderUtils +{ + public static void renderStandardInvBlock(RenderBlocks renderblocks, Block block, int meta) + { + Tessellator tessellator = Tessellator.instance; + GL11.glTranslatef(-0.5F, -0.5F, -0.5F); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, -1F, 0.0F); + renderblocks.renderFaceYNeg(block, 0.0D, 0.0D, 0.0D, block.getIcon(0, meta)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, 1.0F, 0.0F); + renderblocks.renderFaceYPos(block, 0.0D, 0.0D, 0.0D, block.getIcon(1, meta)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, 0.0F, -1F); + renderblocks.renderFaceZNeg(block, 0.0D, 0.0D, 0.0D, block.getIcon(2, meta)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, 0.0F, 1.0F); + renderblocks.renderFaceZPos(block, 0.0D, 0.0D, 0.0D, block.getIcon(3, meta)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(-1F, 0.0F, 0.0F); + renderblocks.renderFaceXNeg(block, 0.0D, 0.0D, 0.0D, block.getIcon(4, meta)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(1.0F, 0.0F, 0.0F); + renderblocks.renderFaceXPos(block, 0.0D, 0.0D, 0.0D, block.getIcon(5, meta)); + tessellator.draw(); + GL11.glTranslatef(0.5F, 0.5F, 0.5F); + } + + public static boolean renderFace(RenderBlocks renderer, Block block, Icon icon, IBlockAccess world, int x, int y, int z, ForgeDirection face) + { + return renderFace(renderer, block, icon, world, x, y, z, -1, face); + } + + public static boolean renderFace(RenderBlocks renderer, Block block, Icon icon, IBlockAccess world, int x, int y, int z, int brightness, ForgeDirection face) + { + if(icon == null) return false; + int color = block.colorMultiplier(renderer.blockAccess, x, y, z); + float red = (color >> 16 & 255) / 255.0F; + float green = (color >> 8 & 255) / 255.0F; + float blue = (color & 255) / 255.0F; + if(EntityRenderer.anaglyphEnable) { + float redA = (red * 30.0F + green * 59.0F + blue * 11.0F) / 100.0F; + float greenA = (red * 30.0F + green * 70.0F) / 100.0F; + float blueA = (red * 30.0F + blue * 70.0F) / 100.0F; + red = redA; + green = greenA; + blue = blueA; + } + if(Minecraft.isAmbientOcclusionEnabled()) { return renderFaceWithAmbientOcclusion(renderer, block, icon, world, x, y, z, red, green, blue, brightness, face); } + return renderFaceWithColorMultiplier(renderer, block, world, icon, x, y, z, red, green, blue, brightness, face); + } + + private static boolean renderFaceWithAmbientOcclusion(RenderBlocks renderer, Block block, Icon icon, IBlockAccess world, int x, int y, int z, float r, float g, float b, int brightness, ForgeDirection face) { + renderer.enableAO = true; + boolean renderedFace = false; + boolean brightFlag = brightness > -1; + float colorModTopLeft = 0.0F; + float colorModBottomLeft = 0.0F; + float colorModBottomRight = 0.0F; + float colorModTopRight = 0.0F; + boolean locationColorFlag = true; + int mixedBrightnessForBlock = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z); + Tessellator tessellator = Tessellator.instance; + tessellator.setBrightness(983055); + + if(renderer.getBlockIcon(block).getIconName().equals("grass_top")) { + locationColorFlag = false; + } else if(renderer.hasOverrideBlockTexture()) { + locationColorFlag = false; + } + + boolean grassXYNN; + boolean grassXYPN; + boolean grassYZNN; + boolean grassYZNP; + float lightValue; + int mixedBrightnessForSide; + + if(face == ForgeDirection.DOWN && (renderer.renderAllFaces || block.shouldSideBeRendered(renderer.blockAccess, x, y - 1, z, 0))) { + if(renderer.renderMinY <= 0.0D) { + --y; + } + + renderer.aoBrightnessXYNN = brightFlag ? brightness : block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y, z); + renderer.aoBrightnessYZNN = brightFlag ? brightness : block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z - 1); + renderer.aoBrightnessYZNP = brightFlag ? brightness : block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z + 1); + renderer.aoBrightnessXYPN = brightFlag ? brightness : block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y, z); + renderer.aoLightValueScratchXYNN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x - 1, y, z); + renderer.aoLightValueScratchYZNN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y, z - 1); + renderer.aoLightValueScratchYZNP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y, z + 1); + renderer.aoLightValueScratchXYPN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x + 1, y, z); + grassXYPN = Block.canBlockGrass[renderer.blockAccess.getBlockId(x + 1, y - 1, z)]; + grassXYNN = Block.canBlockGrass[renderer.blockAccess.getBlockId(x - 1, y - 1, z)]; + grassYZNP = Block.canBlockGrass[renderer.blockAccess.getBlockId(x, y - 1, z + 1)]; + grassYZNN = Block.canBlockGrass[renderer.blockAccess.getBlockId(x, y - 1, z - 1)]; + + if(!grassYZNN && !grassXYNN) { + renderer.aoLightValueScratchXYZNNN = renderer.aoLightValueScratchXYNN; + renderer.aoBrightnessXYZNNN = brightFlag ? brightness : renderer.aoBrightnessXYNN; + } else { + renderer.aoLightValueScratchXYZNNN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x - 1, y, z - 1); + renderer.aoBrightnessXYZNNN = brightFlag ? brightness : block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y, z - 1); + } + + if(!grassYZNP && !grassXYNN) { + renderer.aoLightValueScratchXYZNNP = renderer.aoLightValueScratchXYNN; + renderer.aoBrightnessXYZNNP = brightFlag ? brightness : renderer.aoBrightnessXYNN; + } else { + renderer.aoLightValueScratchXYZNNP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x - 1, y, z + 1); + renderer.aoBrightnessXYZNNP = brightFlag ? brightness : block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y, z + 1); + } + + if(!grassYZNN && !grassXYPN) { + renderer.aoLightValueScratchXYZPNN = renderer.aoLightValueScratchXYPN; + renderer.aoBrightnessXYZPNN = brightFlag ? brightness : renderer.aoBrightnessXYPN; + } else { + renderer.aoLightValueScratchXYZPNN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x + 1, y, z - 1); + renderer.aoBrightnessXYZPNN = brightFlag ? brightness : block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y, z - 1); + } + + if(!grassYZNP && !grassXYPN) { + renderer.aoLightValueScratchXYZPNP = renderer.aoLightValueScratchXYPN; + renderer.aoBrightnessXYZPNP = brightFlag ? brightness : renderer.aoBrightnessXYPN; + } else { + renderer.aoLightValueScratchXYZPNP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x + 1, y, z + 1); + renderer.aoBrightnessXYZPNP = brightFlag ? brightness : block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y, z + 1); + } + + if(renderer.renderMinY <= 0.0D) { + ++y; + } + + mixedBrightnessForSide = mixedBrightnessForBlock; + + if(renderer.renderMinY <= 0.0D || !renderer.blockAccess.isBlockOpaqueCube(x, y - 1, z)) { + mixedBrightnessForSide = brightFlag ? brightness : block.getMixedBrightnessForBlock(renderer.blockAccess, x, y - 1, z); + } + + lightValue = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y - 1, z); + colorModTopLeft = (renderer.aoLightValueScratchXYZNNP + renderer.aoLightValueScratchXYNN + renderer.aoLightValueScratchYZNP + lightValue) / 4.0F; + colorModTopRight = (renderer.aoLightValueScratchYZNP + lightValue + renderer.aoLightValueScratchXYZPNP + renderer.aoLightValueScratchXYPN) / 4.0F; + colorModBottomRight = (lightValue + renderer.aoLightValueScratchYZNN + renderer.aoLightValueScratchXYPN + renderer.aoLightValueScratchXYZPNN) / 4.0F; + colorModBottomLeft = (renderer.aoLightValueScratchXYNN + renderer.aoLightValueScratchXYZNNN + lightValue + renderer.aoLightValueScratchYZNN) / 4.0F; + renderer.brightnessTopLeft = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessXYZNNP, renderer.aoBrightnessXYNN, renderer.aoBrightnessYZNP, mixedBrightnessForSide); + renderer.brightnessTopRight = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessYZNP, renderer.aoBrightnessXYZPNP, renderer.aoBrightnessXYPN, mixedBrightnessForSide); + renderer.brightnessBottomRight = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessYZNN, renderer.aoBrightnessXYPN, renderer.aoBrightnessXYZPNN, mixedBrightnessForSide); + renderer.brightnessBottomLeft = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessXYNN, renderer.aoBrightnessXYZNNN, renderer.aoBrightnessYZNN, mixedBrightnessForSide); + + if(locationColorFlag) { + 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; + } else { + renderer.colorRedTopLeft = renderer.colorRedBottomLeft = renderer.colorRedBottomRight = renderer.colorRedTopRight = 0.5F; + renderer.colorGreenTopLeft = renderer.colorGreenBottomLeft = renderer.colorGreenBottomRight = renderer.colorGreenTopRight = 0.5F; + renderer.colorBlueTopLeft = renderer.colorBlueBottomLeft = renderer.colorBlueBottomRight = renderer.colorBlueTopRight = 0.5F; + } + + renderer.colorRedTopLeft *= colorModTopLeft; + renderer.colorGreenTopLeft *= colorModTopLeft; + renderer.colorBlueTopLeft *= colorModTopLeft; + renderer.colorRedBottomLeft *= colorModBottomLeft; + renderer.colorGreenBottomLeft *= colorModBottomLeft; + renderer.colorBlueBottomLeft *= colorModBottomLeft; + renderer.colorRedBottomRight *= colorModBottomRight; + renderer.colorGreenBottomRight *= colorModBottomRight; + renderer.colorBlueBottomRight *= colorModBottomRight; + renderer.colorRedTopRight *= colorModTopRight; + renderer.colorGreenTopRight *= colorModTopRight; + renderer.colorBlueTopRight *= colorModTopRight; + renderer.renderFaceYNeg(block, x, y, z, icon); + renderedFace = true; + } + + if(face == ForgeDirection.UP && (renderer.renderAllFaces || block.shouldSideBeRendered(renderer.blockAccess, x, y + 1, z, 1))) { + if(renderer.renderMaxY >= 1.0D) { + ++y; + } + + renderer.aoBrightnessXYNP = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y, z); + renderer.aoBrightnessXYPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y, z); + renderer.aoBrightnessYZPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z - 1); + renderer.aoBrightnessYZPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z + 1); + renderer.aoLightValueScratchXYNP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x - 1, y, z); + renderer.aoLightValueScratchXYPP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x + 1, y, z); + renderer.aoLightValueScratchYZPN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y, z - 1); + renderer.aoLightValueScratchYZPP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y, z + 1); + grassXYPN = Block.canBlockGrass[renderer.blockAccess.getBlockId(x + 1, y + 1, z)]; + grassXYNN = Block.canBlockGrass[renderer.blockAccess.getBlockId(x - 1, y + 1, z)]; + grassYZNP = Block.canBlockGrass[renderer.blockAccess.getBlockId(x, y + 1, z + 1)]; + grassYZNN = Block.canBlockGrass[renderer.blockAccess.getBlockId(x, y + 1, z - 1)]; + + if(!grassYZNN && !grassXYNN) { + renderer.aoLightValueScratchXYZNPN = renderer.aoLightValueScratchXYNP; + renderer.aoBrightnessXYZNPN = renderer.aoBrightnessXYNP; + } else { + renderer.aoLightValueScratchXYZNPN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x - 1, y, z - 1); + renderer.aoBrightnessXYZNPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y, z - 1); + } + + if(!grassYZNN && !grassXYPN) { + renderer.aoLightValueScratchXYZPPN = renderer.aoLightValueScratchXYPP; + renderer.aoBrightnessXYZPPN = renderer.aoBrightnessXYPP; + } else { + renderer.aoLightValueScratchXYZPPN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x + 1, y, z - 1); + renderer.aoBrightnessXYZPPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y, z - 1); + } + + if(!grassYZNP && !grassXYNN) { + renderer.aoLightValueScratchXYZNPP = renderer.aoLightValueScratchXYNP; + renderer.aoBrightnessXYZNPP = renderer.aoBrightnessXYNP; + } else { + renderer.aoLightValueScratchXYZNPP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x - 1, y, z + 1); + renderer.aoBrightnessXYZNPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y, z + 1); + } + + if(!grassYZNP && !grassXYPN) { + renderer.aoLightValueScratchXYZPPP = renderer.aoLightValueScratchXYPP; + renderer.aoBrightnessXYZPPP = renderer.aoBrightnessXYPP; + } else { + renderer.aoLightValueScratchXYZPPP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x + 1, y, z + 1); + renderer.aoBrightnessXYZPPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y, z + 1); + } + + if(renderer.renderMaxY >= 1.0D) { + --y; + } + + mixedBrightnessForSide = mixedBrightnessForBlock; + + if(renderer.renderMaxY >= 1.0D || !renderer.blockAccess.isBlockOpaqueCube(x, y + 1, z)) { + mixedBrightnessForSide = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y + 1, z); + } + + lightValue = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y + 1, z); + colorModTopRight = (renderer.aoLightValueScratchXYZNPP + renderer.aoLightValueScratchXYNP + renderer.aoLightValueScratchYZPP + lightValue) / 4.0F; + colorModTopLeft = (renderer.aoLightValueScratchYZPP + lightValue + renderer.aoLightValueScratchXYZPPP + renderer.aoLightValueScratchXYPP) / 4.0F; + colorModBottomLeft = (lightValue + renderer.aoLightValueScratchYZPN + renderer.aoLightValueScratchXYPP + renderer.aoLightValueScratchXYZPPN) / 4.0F; + colorModBottomRight = (renderer.aoLightValueScratchXYNP + renderer.aoLightValueScratchXYZNPN + lightValue + renderer.aoLightValueScratchYZPN) / 4.0F; + renderer.brightnessTopRight = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessXYZNPP, renderer.aoBrightnessXYNP, renderer.aoBrightnessYZPP, mixedBrightnessForSide); + renderer.brightnessTopLeft = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessYZPP, renderer.aoBrightnessXYZPPP, renderer.aoBrightnessXYPP, mixedBrightnessForSide); + renderer.brightnessBottomLeft = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessYZPN, renderer.aoBrightnessXYPP, renderer.aoBrightnessXYZPPN, mixedBrightnessForSide); + renderer.brightnessBottomRight = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessXYNP, renderer.aoBrightnessXYZNPN, renderer.aoBrightnessYZPN, mixedBrightnessForSide); + 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 *= colorModTopLeft; + renderer.colorGreenTopLeft *= colorModTopLeft; + renderer.colorBlueTopLeft *= colorModTopLeft; + renderer.colorRedBottomLeft *= colorModBottomLeft; + renderer.colorGreenBottomLeft *= colorModBottomLeft; + renderer.colorBlueBottomLeft *= colorModBottomLeft; + renderer.colorRedBottomRight *= colorModBottomRight; + renderer.colorGreenBottomRight *= colorModBottomRight; + renderer.colorBlueBottomRight *= colorModBottomRight; + renderer.colorRedTopRight *= colorModTopRight; + renderer.colorGreenTopRight *= colorModTopRight; + renderer.colorBlueTopRight *= colorModTopRight; + renderer.renderFaceYPos(block, x, y, z, icon); + renderedFace = true; + } + + if(face == ForgeDirection.NORTH && (renderer.renderAllFaces || block.shouldSideBeRendered(renderer.blockAccess, x, y, z - 1, 2))) { + if(renderer.renderMinZ <= 0.0D) { + --z; + } + + renderer.aoLightValueScratchXZNN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x - 1, y, z); + renderer.aoLightValueScratchYZNN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y - 1, z); + renderer.aoLightValueScratchYZPN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y + 1, z); + renderer.aoLightValueScratchXZPN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x + 1, y, z); + renderer.aoBrightnessXZNN = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y, z); + renderer.aoBrightnessYZNN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y - 1, z); + renderer.aoBrightnessYZPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y + 1, z); + renderer.aoBrightnessXZPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y, z); + grassXYPN = Block.canBlockGrass[renderer.blockAccess.getBlockId(x + 1, y, z - 1)]; + grassXYNN = Block.canBlockGrass[renderer.blockAccess.getBlockId(x - 1, y, z - 1)]; + grassYZNP = Block.canBlockGrass[renderer.blockAccess.getBlockId(x, y + 1, z - 1)]; + grassYZNN = Block.canBlockGrass[renderer.blockAccess.getBlockId(x, y - 1, z - 1)]; + + if(!grassXYNN && !grassYZNN) { + renderer.aoLightValueScratchXYZNNN = renderer.aoLightValueScratchXZNN; + renderer.aoBrightnessXYZNNN = renderer.aoBrightnessXZNN; + } else { + renderer.aoLightValueScratchXYZNNN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x - 1, y - 1, z); + renderer.aoBrightnessXYZNNN = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y - 1, z); + } + + if(!grassXYNN && !grassYZNP) { + renderer.aoLightValueScratchXYZNPN = renderer.aoLightValueScratchXZNN; + renderer.aoBrightnessXYZNPN = renderer.aoBrightnessXZNN; + } else { + renderer.aoLightValueScratchXYZNPN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x - 1, y + 1, z); + renderer.aoBrightnessXYZNPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y + 1, z); + } + + if(!grassXYPN && !grassYZNN) { + renderer.aoLightValueScratchXYZPNN = renderer.aoLightValueScratchXZPN; + renderer.aoBrightnessXYZPNN = renderer.aoBrightnessXZPN; + } else { + renderer.aoLightValueScratchXYZPNN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x + 1, y - 1, z); + renderer.aoBrightnessXYZPNN = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y - 1, z); + } + + if(!grassXYPN && !grassYZNP) { + renderer.aoLightValueScratchXYZPPN = renderer.aoLightValueScratchXZPN; + renderer.aoBrightnessXYZPPN = renderer.aoBrightnessXZPN; + } else { + renderer.aoLightValueScratchXYZPPN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x + 1, y + 1, z); + renderer.aoBrightnessXYZPPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y + 1, z); + } + + if(renderer.renderMinZ <= 0.0D) { + ++z; + } + + mixedBrightnessForSide = mixedBrightnessForBlock; + + if(renderer.renderMinZ <= 0.0D || !renderer.blockAccess.isBlockOpaqueCube(x, y, z - 1)) { + mixedBrightnessForSide = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z - 1); + } + + lightValue = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y, z - 1); + colorModTopLeft = (renderer.aoLightValueScratchXZNN + renderer.aoLightValueScratchXYZNPN + lightValue + renderer.aoLightValueScratchYZPN) / 4.0F; + colorModBottomLeft = (lightValue + renderer.aoLightValueScratchYZPN + renderer.aoLightValueScratchXZPN + renderer.aoLightValueScratchXYZPPN) / 4.0F; + colorModBottomRight = (renderer.aoLightValueScratchYZNN + lightValue + renderer.aoLightValueScratchXYZPNN + renderer.aoLightValueScratchXZPN) / 4.0F; + colorModTopRight = (renderer.aoLightValueScratchXYZNNN + renderer.aoLightValueScratchXZNN + renderer.aoLightValueScratchYZNN + lightValue) / 4.0F; + renderer.brightnessTopLeft = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessXZNN, renderer.aoBrightnessXYZNPN, renderer.aoBrightnessYZPN, mixedBrightnessForSide); + renderer.brightnessBottomLeft = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessYZPN, renderer.aoBrightnessXZPN, renderer.aoBrightnessXYZPPN, mixedBrightnessForSide); + renderer.brightnessBottomRight = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessYZNN, renderer.aoBrightnessXYZPNN, renderer.aoBrightnessXZPN, mixedBrightnessForSide); + renderer.brightnessTopRight = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessXYZNNN, renderer.aoBrightnessXZNN, renderer.aoBrightnessYZNN, mixedBrightnessForSide); + + if(locationColorFlag) { + 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; + } else { + renderer.colorRedTopLeft = renderer.colorRedBottomLeft = renderer.colorRedBottomRight = renderer.colorRedTopRight = 0.8F; + renderer.colorGreenTopLeft = renderer.colorGreenBottomLeft = renderer.colorGreenBottomRight = renderer.colorGreenTopRight = 0.8F; + renderer.colorBlueTopLeft = renderer.colorBlueBottomLeft = renderer.colorBlueBottomRight = renderer.colorBlueTopRight = 0.8F; + } + + renderer.colorRedTopLeft *= colorModTopLeft; + renderer.colorGreenTopLeft *= colorModTopLeft; + renderer.colorBlueTopLeft *= colorModTopLeft; + renderer.colorRedBottomLeft *= colorModBottomLeft; + renderer.colorGreenBottomLeft *= colorModBottomLeft; + renderer.colorBlueBottomLeft *= colorModBottomLeft; + renderer.colorRedBottomRight *= colorModBottomRight; + renderer.colorGreenBottomRight *= colorModBottomRight; + renderer.colorBlueBottomRight *= colorModBottomRight; + renderer.colorRedTopRight *= colorModTopRight; + renderer.colorGreenTopRight *= colorModTopRight; + renderer.colorBlueTopRight *= colorModTopRight; + renderer.renderFaceZNeg(block, x, y, z, icon); + + renderedFace = true; + } + + if(face == ForgeDirection.SOUTH && (renderer.renderAllFaces || block.shouldSideBeRendered(renderer.blockAccess, x, y, z + 1, 3))) { + if(renderer.renderMaxZ >= 1.0D) { + ++z; + } + + renderer.aoLightValueScratchXZNP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x - 1, y, z); + renderer.aoLightValueScratchXZPP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x + 1, y, z); + renderer.aoLightValueScratchYZNP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y - 1, z); + renderer.aoLightValueScratchYZPP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y + 1, z); + renderer.aoBrightnessXZNP = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y, z); + renderer.aoBrightnessXZPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y, z); + renderer.aoBrightnessYZNP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y - 1, z); + renderer.aoBrightnessYZPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y + 1, z); + grassXYPN = Block.canBlockGrass[renderer.blockAccess.getBlockId(x + 1, y, z + 1)]; + grassXYNN = Block.canBlockGrass[renderer.blockAccess.getBlockId(x - 1, y, z + 1)]; + grassYZNP = Block.canBlockGrass[renderer.blockAccess.getBlockId(x, y + 1, z + 1)]; + grassYZNN = Block.canBlockGrass[renderer.blockAccess.getBlockId(x, y - 1, z + 1)]; + + if(!grassXYNN && !grassYZNN) { + renderer.aoLightValueScratchXYZNNP = renderer.aoLightValueScratchXZNP; + renderer.aoBrightnessXYZNNP = renderer.aoBrightnessXZNP; + } else { + renderer.aoLightValueScratchXYZNNP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x - 1, y - 1, z); + renderer.aoBrightnessXYZNNP = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y - 1, z); + } + + if(!grassXYNN && !grassYZNP) { + renderer.aoLightValueScratchXYZNPP = renderer.aoLightValueScratchXZNP; + renderer.aoBrightnessXYZNPP = renderer.aoBrightnessXZNP; + } else { + renderer.aoLightValueScratchXYZNPP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x - 1, y + 1, z); + renderer.aoBrightnessXYZNPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y + 1, z); + } + + if(!grassXYPN && !grassYZNN) { + renderer.aoLightValueScratchXYZPNP = renderer.aoLightValueScratchXZPP; + renderer.aoBrightnessXYZPNP = renderer.aoBrightnessXZPP; + } else { + renderer.aoLightValueScratchXYZPNP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x + 1, y - 1, z); + renderer.aoBrightnessXYZPNP = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y - 1, z); + } + + if(!grassXYPN && !grassYZNP) { + renderer.aoLightValueScratchXYZPPP = renderer.aoLightValueScratchXZPP; + renderer.aoBrightnessXYZPPP = renderer.aoBrightnessXZPP; + } else { + renderer.aoLightValueScratchXYZPPP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x + 1, y + 1, z); + renderer.aoBrightnessXYZPPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y + 1, z); + } + + if(renderer.renderMaxZ >= 1.0D) { + --z; + } + + mixedBrightnessForSide = mixedBrightnessForBlock; + + if(renderer.renderMaxZ >= 1.0D || !renderer.blockAccess.isBlockOpaqueCube(x, y, z + 1)) { + mixedBrightnessForSide = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z + 1); + } + + lightValue = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y, z + 1); + colorModTopLeft = (renderer.aoLightValueScratchXZNP + renderer.aoLightValueScratchXYZNPP + lightValue + renderer.aoLightValueScratchYZPP) / 4.0F; + colorModTopRight = (lightValue + renderer.aoLightValueScratchYZPP + renderer.aoLightValueScratchXZPP + renderer.aoLightValueScratchXYZPPP) / 4.0F; + colorModBottomRight = (renderer.aoLightValueScratchYZNP + lightValue + renderer.aoLightValueScratchXYZPNP + renderer.aoLightValueScratchXZPP) / 4.0F; + colorModBottomLeft = (renderer.aoLightValueScratchXYZNNP + renderer.aoLightValueScratchXZNP + renderer.aoLightValueScratchYZNP + lightValue) / 4.0F; + renderer.brightnessTopLeft = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessXZNP, renderer.aoBrightnessXYZNPP, renderer.aoBrightnessYZPP, mixedBrightnessForSide); + renderer.brightnessTopRight = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessYZPP, renderer.aoBrightnessXZPP, renderer.aoBrightnessXYZPPP, mixedBrightnessForSide); + renderer.brightnessBottomRight = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessYZNP, renderer.aoBrightnessXYZPNP, renderer.aoBrightnessXZPP, mixedBrightnessForSide); + renderer.brightnessBottomLeft = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessXYZNNP, renderer.aoBrightnessXZNP, renderer.aoBrightnessYZNP, mixedBrightnessForSide); + + if(locationColorFlag) { + 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; + } else { + renderer.colorRedTopLeft = renderer.colorRedBottomLeft = renderer.colorRedBottomRight = renderer.colorRedTopRight = 0.8F; + renderer.colorGreenTopLeft = renderer.colorGreenBottomLeft = renderer.colorGreenBottomRight = renderer.colorGreenTopRight = 0.8F; + renderer.colorBlueTopLeft = renderer.colorBlueBottomLeft = renderer.colorBlueBottomRight = renderer.colorBlueTopRight = 0.8F; + } + + renderer.colorRedTopLeft *= colorModTopLeft; + renderer.colorGreenTopLeft *= colorModTopLeft; + renderer.colorBlueTopLeft *= colorModTopLeft; + renderer.colorRedBottomLeft *= colorModBottomLeft; + renderer.colorGreenBottomLeft *= colorModBottomLeft; + renderer.colorBlueBottomLeft *= colorModBottomLeft; + renderer.colorRedBottomRight *= colorModBottomRight; + renderer.colorGreenBottomRight *= colorModBottomRight; + renderer.colorBlueBottomRight *= colorModBottomRight; + renderer.colorRedTopRight *= colorModTopRight; + renderer.colorGreenTopRight *= colorModTopRight; + renderer.colorBlueTopRight *= colorModTopRight; + renderer.renderFaceZPos(block, x, y, z, icon); + + renderedFace = true; + } + + if(face == ForgeDirection.WEST && (renderer.renderAllFaces || block.shouldSideBeRendered(renderer.blockAccess, x - 1, y, z, 4))) { + if(renderer.renderMinX <= 0.0D) { + --x; + } + + renderer.aoLightValueScratchXYNN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y - 1, z); + renderer.aoLightValueScratchXZNN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y, z - 1); + renderer.aoLightValueScratchXZNP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y, z + 1); + renderer.aoLightValueScratchXYNP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y + 1, z); + renderer.aoBrightnessXYNN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y - 1, z); + renderer.aoBrightnessXZNN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z - 1); + renderer.aoBrightnessXZNP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z + 1); + renderer.aoBrightnessXYNP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y + 1, z); + grassXYPN = Block.canBlockGrass[renderer.blockAccess.getBlockId(x - 1, y + 1, z)]; + grassXYNN = Block.canBlockGrass[renderer.blockAccess.getBlockId(x - 1, y - 1, z)]; + grassYZNP = Block.canBlockGrass[renderer.blockAccess.getBlockId(x - 1, y, z - 1)]; + grassYZNN = Block.canBlockGrass[renderer.blockAccess.getBlockId(x - 1, y, z + 1)]; + + if(!grassYZNP && !grassXYNN) { + renderer.aoLightValueScratchXYZNNN = renderer.aoLightValueScratchXZNN; + renderer.aoBrightnessXYZNNN = renderer.aoBrightnessXZNN; + } else { + renderer.aoLightValueScratchXYZNNN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y - 1, z - 1); + renderer.aoBrightnessXYZNNN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y - 1, z - 1); + } + + if(!grassYZNN && !grassXYNN) { + renderer.aoLightValueScratchXYZNNP = renderer.aoLightValueScratchXZNP; + renderer.aoBrightnessXYZNNP = renderer.aoBrightnessXZNP; + } else { + renderer.aoLightValueScratchXYZNNP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y - 1, z + 1); + renderer.aoBrightnessXYZNNP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y - 1, z + 1); + } + + if(!grassYZNP && !grassXYPN) { + renderer.aoLightValueScratchXYZNPN = renderer.aoLightValueScratchXZNN; + renderer.aoBrightnessXYZNPN = renderer.aoBrightnessXZNN; + } else { + renderer.aoLightValueScratchXYZNPN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y + 1, z - 1); + renderer.aoBrightnessXYZNPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y + 1, z - 1); + } + + if(!grassYZNN && !grassXYPN) { + renderer.aoLightValueScratchXYZNPP = renderer.aoLightValueScratchXZNP; + renderer.aoBrightnessXYZNPP = renderer.aoBrightnessXZNP; + } else { + renderer.aoLightValueScratchXYZNPP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y + 1, z + 1); + renderer.aoBrightnessXYZNPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y + 1, z + 1); + } + + if(renderer.renderMinX <= 0.0D) { + ++x; + } + + mixedBrightnessForSide = mixedBrightnessForBlock; + + if(renderer.renderMinX <= 0.0D || !renderer.blockAccess.isBlockOpaqueCube(x - 1, y, z)) { + mixedBrightnessForSide = block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y, z); + } + + lightValue = block.getAmbientOcclusionLightValue(renderer.blockAccess, x - 1, y, z); + colorModTopRight = (renderer.aoLightValueScratchXYNN + renderer.aoLightValueScratchXYZNNP + lightValue + renderer.aoLightValueScratchXZNP) / 4.0F; + colorModTopLeft = (lightValue + renderer.aoLightValueScratchXZNP + renderer.aoLightValueScratchXYNP + renderer.aoLightValueScratchXYZNPP) / 4.0F; + colorModBottomLeft = (renderer.aoLightValueScratchXZNN + lightValue + renderer.aoLightValueScratchXYZNPN + renderer.aoLightValueScratchXYNP) / 4.0F; + colorModBottomRight = (renderer.aoLightValueScratchXYZNNN + renderer.aoLightValueScratchXYNN + renderer.aoLightValueScratchXZNN + lightValue) / 4.0F; + renderer.brightnessTopRight = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessXYNN, renderer.aoBrightnessXYZNNP, renderer.aoBrightnessXZNP, mixedBrightnessForSide); + renderer.brightnessTopLeft = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessXZNP, renderer.aoBrightnessXYNP, renderer.aoBrightnessXYZNPP, mixedBrightnessForSide); + renderer.brightnessBottomLeft = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessXZNN, renderer.aoBrightnessXYZNPN, renderer.aoBrightnessXYNP, mixedBrightnessForSide); + renderer.brightnessBottomRight = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessXYZNNN, renderer.aoBrightnessXYNN, renderer.aoBrightnessXZNN, mixedBrightnessForSide); + + if(locationColorFlag) { + 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; + } else { + renderer.colorRedTopLeft = renderer.colorRedBottomLeft = renderer.colorRedBottomRight = renderer.colorRedTopRight = 0.6F; + renderer.colorGreenTopLeft = renderer.colorGreenBottomLeft = renderer.colorGreenBottomRight = renderer.colorGreenTopRight = 0.6F; + renderer.colorBlueTopLeft = renderer.colorBlueBottomLeft = renderer.colorBlueBottomRight = renderer.colorBlueTopRight = 0.6F; + } + + renderer.colorRedTopLeft *= colorModTopLeft; + renderer.colorGreenTopLeft *= colorModTopLeft; + renderer.colorBlueTopLeft *= colorModTopLeft; + renderer.colorRedBottomLeft *= colorModBottomLeft; + renderer.colorGreenBottomLeft *= colorModBottomLeft; + renderer.colorBlueBottomLeft *= colorModBottomLeft; + renderer.colorRedBottomRight *= colorModBottomRight; + renderer.colorGreenBottomRight *= colorModBottomRight; + renderer.colorBlueBottomRight *= colorModBottomRight; + renderer.colorRedTopRight *= colorModTopRight; + renderer.colorGreenTopRight *= colorModTopRight; + renderer.colorBlueTopRight *= colorModTopRight; + renderer.renderFaceXNeg(block, x, y, z, icon); + + renderedFace = true; + } + + if(face == ForgeDirection.EAST && (renderer.renderAllFaces || block.shouldSideBeRendered(renderer.blockAccess, x + 1, y, z, 5))) { + if(renderer.renderMaxX >= 1.0D) { + ++x; + } + + renderer.aoLightValueScratchXYPN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y - 1, z); + renderer.aoLightValueScratchXZPN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y, z - 1); + renderer.aoLightValueScratchXZPP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y, z + 1); + renderer.aoLightValueScratchXYPP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y + 1, z); + renderer.aoBrightnessXYPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y - 1, z); + renderer.aoBrightnessXZPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z - 1); + renderer.aoBrightnessXZPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z + 1); + renderer.aoBrightnessXYPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y + 1, z); + grassXYPN = Block.canBlockGrass[renderer.blockAccess.getBlockId(x + 1, y + 1, z)]; + grassXYNN = Block.canBlockGrass[renderer.blockAccess.getBlockId(x + 1, y - 1, z)]; + grassYZNP = Block.canBlockGrass[renderer.blockAccess.getBlockId(x + 1, y, z + 1)]; + grassYZNN = Block.canBlockGrass[renderer.blockAccess.getBlockId(x + 1, y, z - 1)]; + + if(!grassXYNN && !grassYZNN) { + renderer.aoLightValueScratchXYZPNN = renderer.aoLightValueScratchXZPN; + renderer.aoBrightnessXYZPNN = renderer.aoBrightnessXZPN; + } else { + renderer.aoLightValueScratchXYZPNN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y - 1, z - 1); + renderer.aoBrightnessXYZPNN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y - 1, z - 1); + } + + if(!grassXYNN && !grassYZNP) { + renderer.aoLightValueScratchXYZPNP = renderer.aoLightValueScratchXZPP; + renderer.aoBrightnessXYZPNP = renderer.aoBrightnessXZPP; + } else { + renderer.aoLightValueScratchXYZPNP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y - 1, z + 1); + renderer.aoBrightnessXYZPNP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y - 1, z + 1); + } + + if(!grassXYPN && !grassYZNN) { + renderer.aoLightValueScratchXYZPPN = renderer.aoLightValueScratchXZPN; + renderer.aoBrightnessXYZPPN = renderer.aoBrightnessXZPN; + } else { + renderer.aoLightValueScratchXYZPPN = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y + 1, z - 1); + renderer.aoBrightnessXYZPPN = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y + 1, z - 1); + } + + if(!grassXYPN && !grassYZNP) { + renderer.aoLightValueScratchXYZPPP = renderer.aoLightValueScratchXZPP; + renderer.aoBrightnessXYZPPP = renderer.aoBrightnessXZPP; + } else { + renderer.aoLightValueScratchXYZPPP = block.getAmbientOcclusionLightValue(renderer.blockAccess, x, y + 1, z + 1); + renderer.aoBrightnessXYZPPP = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y + 1, z + 1); + } + + if(renderer.renderMaxX >= 1.0D) { + --x; + } + + mixedBrightnessForSide = mixedBrightnessForBlock; + + if(renderer.renderMaxX >= 1.0D || !renderer.blockAccess.isBlockOpaqueCube(x + 1, y, z)) { + mixedBrightnessForSide = block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y, z); + } + + lightValue = block.getAmbientOcclusionLightValue(renderer.blockAccess, x + 1, y, z); + colorModTopLeft = (renderer.aoLightValueScratchXYPN + renderer.aoLightValueScratchXYZPNP + lightValue + renderer.aoLightValueScratchXZPP) / 4.0F; + colorModBottomLeft = (renderer.aoLightValueScratchXYZPNN + renderer.aoLightValueScratchXYPN + renderer.aoLightValueScratchXZPN + lightValue) / 4.0F; + colorModBottomRight = (renderer.aoLightValueScratchXZPN + lightValue + renderer.aoLightValueScratchXYZPPN + renderer.aoLightValueScratchXYPP) / 4.0F; + colorModTopRight = (lightValue + renderer.aoLightValueScratchXZPP + renderer.aoLightValueScratchXYPP + renderer.aoLightValueScratchXYZPPP) / 4.0F; + renderer.brightnessTopLeft = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessXYPN, renderer.aoBrightnessXYZPNP, renderer.aoBrightnessXZPP, mixedBrightnessForSide); + renderer.brightnessTopRight = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessXZPP, renderer.aoBrightnessXYPP, renderer.aoBrightnessXYZPPP, mixedBrightnessForSide); + renderer.brightnessBottomRight = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessXZPN, renderer.aoBrightnessXYZPPN, renderer.aoBrightnessXYPP, mixedBrightnessForSide); + renderer.brightnessBottomLeft = brightFlag ? brightness : renderer.getAoBrightness(renderer.aoBrightnessXYZPNN, renderer.aoBrightnessXYPN, renderer.aoBrightnessXZPN, mixedBrightnessForSide); + + if(locationColorFlag) { + 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; + } else { + renderer.colorRedTopLeft = renderer.colorRedBottomLeft = renderer.colorRedBottomRight = renderer.colorRedTopRight = 0.6F; + renderer.colorGreenTopLeft = renderer.colorGreenBottomLeft = renderer.colorGreenBottomRight = renderer.colorGreenTopRight = 0.6F; + renderer.colorBlueTopLeft = renderer.colorBlueBottomLeft = renderer.colorBlueBottomRight = renderer.colorBlueTopRight = 0.6F; + } + + renderer.colorRedTopLeft *= colorModTopLeft; + renderer.colorGreenTopLeft *= colorModTopLeft; + renderer.colorBlueTopLeft *= colorModTopLeft; + renderer.colorRedBottomLeft *= colorModBottomLeft; + renderer.colorGreenBottomLeft *= colorModBottomLeft; + renderer.colorBlueBottomLeft *= colorModBottomLeft; + renderer.colorRedBottomRight *= colorModBottomRight; + renderer.colorGreenBottomRight *= colorModBottomRight; + renderer.colorBlueBottomRight *= colorModBottomRight; + renderer.colorRedTopRight *= colorModTopRight; + renderer.colorGreenTopRight *= colorModTopRight; + renderer.colorBlueTopRight *= colorModTopRight; + renderer.renderFaceXPos(block, x, y, z, icon); + + renderedFace = true; + } + + renderer.enableAO = false; + return renderedFace; + } + + private static boolean renderFaceWithColorMultiplier(RenderBlocks renderer, Block block, IBlockAccess world, Icon icon, int x, int y, int z, float r, float g, float b, int brightness, ForgeDirection face) { + renderer.enableAO = false; + Tessellator tessellator = Tessellator.instance; + boolean flag = false; + float yMod = 0.5F; + float f4 = 1.0F; + float zMod = 0.8F; + float xMod = 0.6F; + float f7 = f4 * r; + float f8 = f4 * g; + float f9 = f4 * b; + float rY = yMod; + float rZ = zMod; + float rX = xMod; + float gY = yMod; + float gZ = zMod; + float gX = xMod; + float bY = yMod; + float bZ = zMod; + float bX = xMod; + + if(block != Block.grass) { + rY = yMod * r; + rZ = zMod * r; + rX = xMod * r; + gY = yMod * g; + gZ = zMod * g; + gX = xMod * g; + bY = yMod * b; + bZ = zMod * b; + bX = xMod * b; + } + + int l = block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z); + if(face == ForgeDirection.DOWN && (renderer.renderAllFaces || block.shouldSideBeRendered(renderer.blockAccess, x, y - 1, z, 0))) { + if(brightness != -1) + tessellator.setBrightness(brightness); + else + tessellator.setBrightness(renderer.renderMinY > 0.0D ? l : block.getMixedBrightnessForBlock(renderer.blockAccess, x, y - 1, z)); + tessellator.setColorOpaque_F(rY, gY, bY); + renderer.renderFaceYNeg(block, x, y, z, icon); + flag = true; + } + + if(face == ForgeDirection.UP && (renderer.renderAllFaces || block.shouldSideBeRendered(renderer.blockAccess, x, y + 1, z, 1))) { + if(brightness != -1) + tessellator.setBrightness(brightness); + else + tessellator.setBrightness(renderer.renderMaxY < 1.0D ? l : block.getMixedBrightnessForBlock(renderer.blockAccess, x, y + 1, z)); + tessellator.setColorOpaque_F(f7, f8, f9); + renderer.renderFaceYPos(block, x, y, z, icon); + flag = true; + } + + if(face == ForgeDirection.NORTH && (renderer.renderAllFaces || block.shouldSideBeRendered(renderer.blockAccess, x, y, z - 1, 2))) { + if(brightness != -1) + tessellator.setBrightness(brightness); + else + tessellator.setBrightness(renderer.renderMinZ > 0.0D ? l : block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z - 1)); + tessellator.setColorOpaque_F(rZ, gZ, bZ); + renderer.renderFaceZNeg(block, x, y, z, icon); + + flag = true; + } + + if(face == ForgeDirection.SOUTH && (renderer.renderAllFaces || block.shouldSideBeRendered(renderer.blockAccess, x, y, z + 1, 3))) { + if(brightness != -1) + tessellator.setBrightness(brightness); + else + tessellator.setBrightness(renderer.renderMaxZ < 1.0D ? l : block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z + 1)); + tessellator.setColorOpaque_F(rZ, gZ, bZ); + renderer.renderFaceZPos(block, x, y, z, icon); + + flag = true; + } + + if(face == ForgeDirection.WEST && (renderer.renderAllFaces || block.shouldSideBeRendered(renderer.blockAccess, x - 1, y, z, 40))) { + if(brightness != -1) + tessellator.setBrightness(brightness); + else + tessellator.setBrightness(renderer.renderMinX > 0.0D ? l : block.getMixedBrightnessForBlock(renderer.blockAccess, x - 1, y, z)); + tessellator.setColorOpaque_F(rX, gX, bX); + renderer.renderFaceXNeg(block, x, y, z, icon); + + flag = true; + } + + if(face == ForgeDirection.EAST && (renderer.renderAllFaces || block.shouldSideBeRendered(renderer.blockAccess, x + 1, y, z, 5))) { + if(brightness != -1) + tessellator.setBrightness(brightness); + else + tessellator.setBrightness(renderer.renderMaxX < 1.0D ? l : block.getMixedBrightnessForBlock(renderer.blockAccess, x + 1, y, z)); + tessellator.setColorOpaque_F(rX, gX, bX); + renderer.renderFaceXPos(block, x, y, z, icon); + + flag = true; + } + + return flag; + } + +} diff --git a/src/minecraft/biomesoplenty/blocks/renderers/SmallBlockRenderer.java b/src/minecraft/biomesoplenty/blocks/renderers/SmallBlockRenderer.java index fc36e39da..64901a22e 100644 --- a/src/minecraft/biomesoplenty/blocks/renderers/SmallBlockRenderer.java +++ b/src/minecraft/biomesoplenty/blocks/renderers/SmallBlockRenderer.java @@ -75,37 +75,37 @@ public class SmallBlockRenderer implements ISimpleBlockRenderingHandler if (metadata == 0) { renderer.setRenderBounds(0.374F, 0.0F, 0.374F, 0.626F, 1.0F, 0.626F); - BiomesOPlenty.proxy.renderStandardInvBlock(renderer, block, metadata); + RenderUtils.renderStandardInvBlock(renderer, block, metadata); } else if (metadata == 1) { renderer.setRenderBounds(0.187F, 0.0F, 0.187F, 0.813F, 1.0F, 0.813F); - BiomesOPlenty.proxy.renderStandardInvBlock(renderer, block, metadata); + RenderUtils.renderStandardInvBlock(renderer, block, metadata); } else if (metadata == 3) { renderer.setRenderBounds(0.374F, 0.374F, 0.0F, 0.626F, 0.626F, 1.0F); - BiomesOPlenty.proxy.renderStandardInvBlock(renderer, block, metadata); + RenderUtils.renderStandardInvBlock(renderer, block, metadata); } else if (metadata == 4) { renderer.setRenderBounds(0.0F, 0.374F, 0.374F, 1.0F, 0.626F, 0.626F); - BiomesOPlenty.proxy.renderStandardInvBlock(renderer, block, metadata); + RenderUtils.renderStandardInvBlock(renderer, block, metadata); } else if (metadata == 5) { renderer.setRenderBounds(0.187F, 0.187F, 0.0F, 0.813F, 0.813F, 1.0F); - BiomesOPlenty.proxy.renderStandardInvBlock(renderer, block, metadata); + RenderUtils.renderStandardInvBlock(renderer, block, metadata); } else if (metadata == 6) { renderer.setRenderBounds(0.0F, 0.187F, 0.187F, 1.0F, 0.813F, 0.813F); - BiomesOPlenty.proxy.renderStandardInvBlock(renderer, block, metadata); + RenderUtils.renderStandardInvBlock(renderer, block, metadata); } else { renderer.setRenderBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F); - BiomesOPlenty.proxy.renderStandardInvBlock(renderer, block, metadata); + RenderUtils.renderStandardInvBlock(renderer, block, metadata); } } } diff --git a/src/minecraft/biomesoplenty/configuration/BOPBlocks.java b/src/minecraft/biomesoplenty/configuration/BOPBlocks.java index 05e76ba39..4a2c9e955 100644 --- a/src/minecraft/biomesoplenty/configuration/BOPBlocks.java +++ b/src/minecraft/biomesoplenty/configuration/BOPBlocks.java @@ -6,6 +6,7 @@ import net.minecraft.block.material.Material; import net.minecraft.item.ItemStack; import net.minecraftforge.common.MinecraftForge; import biomesoplenty.api.Blocks; +import biomesoplenty.blocks.BlockAltar; import biomesoplenty.blocks.BlockAsh; import biomesoplenty.blocks.BlockBOPAmethyst; import biomesoplenty.blocks.BlockBOPAppleLeaves; @@ -16,6 +17,7 @@ import biomesoplenty.blocks.BlockBOPFlower; import biomesoplenty.blocks.BlockBOPFoliage; import biomesoplenty.blocks.BlockBOPGeneric; import biomesoplenty.blocks.BlockBOPGeneric.BlockType; +import biomesoplenty.blocks.BlockBOPGlass; import biomesoplenty.blocks.BlockBOPGrass; import biomesoplenty.blocks.BlockBOPLeaves; import biomesoplenty.blocks.BlockBOPLeaves.LeafCategory; @@ -42,6 +44,7 @@ import biomesoplenty.blocks.BlockOriginGrass; import biomesoplenty.blocks.BlockPromisedPortal; import biomesoplenty.blocks.BlockTreeMoss; import biomesoplenty.blocks.BlockWillow; +import biomesoplenty.items.ItemBOPAltar; import biomesoplenty.items.ItemBOPAmethyst; import biomesoplenty.items.ItemBOPAppleLeaves; import biomesoplenty.items.ItemBOPBamboo; @@ -51,6 +54,7 @@ import biomesoplenty.items.ItemBOPColorizedSapling; import biomesoplenty.items.ItemBOPCoral; import biomesoplenty.items.ItemBOPFlower; import biomesoplenty.items.ItemBOPFoliage; +import biomesoplenty.items.ItemBOPGlass; import biomesoplenty.items.ItemBOPGrass; import biomesoplenty.items.ItemBOPIvy; import biomesoplenty.items.ItemBOPLeaves; @@ -66,6 +70,7 @@ import biomesoplenty.items.ItemBOPSapling; import biomesoplenty.items.ItemBOPSkystone; import biomesoplenty.items.ItemBOPSlab; import biomesoplenty.items.ItemBOPWillow; +import biomesoplenty.tileentity.TileEntityAltar; import com.google.common.base.Optional; @@ -77,6 +82,7 @@ public class BOPBlocks { { initializeBlocks(); registerBlocks(); + registerTileEntities(); //Shears VS Blocks Blocks.shearBlockIds.put(Blocks.leaves1.get().blockID, 15.0F); @@ -162,6 +168,10 @@ public class BOPBlocks { Blocks.cloud = Optional.of((new BlockCloud(BOPConfiguration.cloudID)).setHardness(0.1F).setLightOpacity(3).setStepSound(Block.soundClothFootstep).setUnlocalizedName("cloud")); Blocks.bones = Optional.of((new BlockBones(BOPConfiguration.bonesID)).setStepSound(Block.soundStoneFootstep).setUnlocalizedName("bones")); + + Blocks.glass = Optional.of((new BlockBOPGlass(BOPConfiguration.glassID)).setStepSound(Block.soundGlassFootstep).setUnlocalizedName("glass")); + + Blocks.altar = Optional.of((new BlockAltar(BOPConfiguration.altarID)).setStepSound(Block.soundStoneFootstep).setUnlocalizedName("altar")); Blocks.planks = Optional.of((new BlockBOPPlank(BOPConfiguration.planksID)).setResistance(5.0F).setStepSound(Block.soundWoodFootstep).setUnlocalizedName("planks")); @@ -240,6 +250,8 @@ public class BOPBlocks { GameRegistry.registerBlock(Blocks.cloud.get(), "cloud"); GameRegistry.registerBlock(Blocks.bones.get(), ItemBOPBones.class, "bones"); + GameRegistry.registerBlock(Blocks.glass.get(), ItemBOPGlass.class, "glass"); + GameRegistry.registerBlock(Blocks.altar.get(), ItemBOPAltar.class, "altar"); ItemBOPSlab.setSlabs(Blocks.stoneSingleSlab.get(), Blocks.stoneDoubleSlab.get()); GameRegistry.registerBlock(Blocks.stoneDoubleSlab.get(), ItemBOPSlab.class, "stoneDoubleSlab"); @@ -269,6 +281,11 @@ public class BOPBlocks { GameRegistry.registerBlock(Blocks.leavesColorized.get(), ItemBOPColorizedLeaves.class, "leavesColorized"); } + + private static void registerTileEntities() + { + GameRegistry.registerTileEntity(TileEntityAltar.class, "tileEntityAltar"); + } private static void registerNames() { @@ -409,6 +426,11 @@ public class BOPBlocks { LanguageRegistry.addName(new ItemStack(Blocks.bones.get(), 1, 4), "Small Bone Segment"); LanguageRegistry.addName(new ItemStack(Blocks.bones.get(), 1, 5), "Medium Bone Segment"); LanguageRegistry.addName(new ItemStack(Blocks.bones.get(), 1, 6), "Medium Bone Segment"); + + LanguageRegistry.addName(new ItemStack(Blocks.glass.get(), 1, 0), "Celestial Lens"); + LanguageRegistry.addName(new ItemStack(Blocks.glass.get(), 1, 1), "Sacrificial Focus"); + + LanguageRegistry.addName(new ItemStack(Blocks.altar.get(), 1, 0), "Altar Frame"); LanguageRegistry.addName(new ItemStack(Blocks.planks.get(), 1, 0), "Acacia Wood Planks"); LanguageRegistry.addName(new ItemStack(Blocks.planks.get(), 1, 1), "Cherry Wood Planks"); diff --git a/src/minecraft/biomesoplenty/configuration/BOPConfiguration.java b/src/minecraft/biomesoplenty/configuration/BOPConfiguration.java index 15d763cfc..df93de5c2 100644 --- a/src/minecraft/biomesoplenty/configuration/BOPConfiguration.java +++ b/src/minecraft/biomesoplenty/configuration/BOPConfiguration.java @@ -200,6 +200,8 @@ public class BOPConfiguration { public static int cloudID; public static int bonesID; + public static int glassID; + public static int altarID; //Item IDs public static int shroomPowderID; @@ -216,6 +218,7 @@ public class BOPConfiguration { public static int mudballID; public static int dartBlowerID; public static int dartID; + public static int soulManipulatorID; public static int bopBucketID; @@ -741,6 +744,10 @@ public class BOPConfiguration { pineStairsID = config.getBlock("Pine Stairs ID", 1975, null).getInt(); hellBarkStairsID = config.getBlock("Hell Bark Stairs ID", 1976, null).getInt(); jacarandaStairsID = config.getBlock("Jacaranda ID", 1977, null).getInt(); + + glassID = config.getBlock("Glass ID", 1978, null).getInt(); + + altarID = config.getBlock("Altar ID", 1979, null).getInt(); // Get Item ID's shroomPowderID = config.getItem("Shroom Powder ID", 21001, null).getInt(); @@ -781,6 +788,8 @@ public class BOPConfiguration { flowerBandID = config.getItem("Flower Band ID", 21078, null).getInt(); bopBucketID = config.getItem("Spring Water Bucket ID", 21079, null).getInt(); + + soulManipulatorID = config.getItem("Soul Manipulator ID", 21080).getInt(); //Liquid Ids springWaterStillID = config.get("Liquid IDs", "Spring Water Still ID (ID before this must be free!)", 1971, null).getInt(); diff --git a/src/minecraft/biomesoplenty/configuration/BOPCrafting.java b/src/minecraft/biomesoplenty/configuration/BOPCrafting.java index 1518f933c..d0563e5ac 100644 --- a/src/minecraft/biomesoplenty/configuration/BOPCrafting.java +++ b/src/minecraft/biomesoplenty/configuration/BOPCrafting.java @@ -221,6 +221,10 @@ public class BOPCrafting //Plants GameRegistry.addShapelessRecipe(new ItemStack(Items.shroomPowder.get(), 2), new Object[] {new ItemStack(Blocks.mushrooms.get(),1,0)}); GameRegistry.addShapelessRecipe(new ItemStack(Items.miscItems.get(), 1, 3), new Object[] {new ItemStack(Blocks.foliage.get(),1,7)}); + + //Glass + GameRegistry.addRecipe(new ItemStack(Blocks.glass.get(), 1, 0), new Object [] {"GGG", "GGG", "GGG", Character.valueOf('G'), Block.glass}); + GameRegistry.addRecipe(new ItemStack(Blocks.glass.get(), 1, 1), new Object [] {"CGC", "GGG", "CGC", Character.valueOf('G'), new ItemStack(Blocks.glass.get(), 1, 0), Character.valueOf('C'), new ItemStack(Items.miscItems.get(), 1, 4)}); } private static void addSmeltingRecipes() diff --git a/src/minecraft/biomesoplenty/configuration/BOPItems.java b/src/minecraft/biomesoplenty/configuration/BOPItems.java index 8403544bf..b1415eddc 100644 --- a/src/minecraft/biomesoplenty/configuration/BOPItems.java +++ b/src/minecraft/biomesoplenty/configuration/BOPItems.java @@ -30,6 +30,7 @@ import biomesoplenty.items.ItemDart; import biomesoplenty.items.ItemDartBlower; import biomesoplenty.items.ItemEnderporter; import biomesoplenty.items.ItemShroomPowder; +import biomesoplenty.items.ItemSoulManipulator; import biomesoplenty.items.ItemSunflowerSeeds; import biomesoplenty.items.overrides.ItemShears; @@ -114,6 +115,7 @@ public class BOPItems { Items.mudball = Optional.of(new ItemBOPMudball(BOPConfiguration.mudballID)); Items.dartBlower = Optional.of(new ItemDartBlower(BOPConfiguration.dartBlowerID)); Items.dart = Optional.of(new ItemDart(BOPConfiguration.dartID)); + Items.soulManipulator = Optional.of(new ItemSoulManipulator(BOPConfiguration.soulManipulatorID)); Items.ancientStaff = Optional.of(new ItemBOPAncientStaff(BOPConfiguration.ancientStaffID)); @@ -170,6 +172,7 @@ public class BOPItems { LanguageRegistry.addName(new ItemStack(Items.miscItems.get(), 1, 13), "Tanzanite"); LanguageRegistry.addName(new ItemStack(Items.miscItems.get(), 1, 14), "Apatite"); LanguageRegistry.addName(new ItemStack(Items.miscItems.get(), 1, 15), "Sapphire"); + LanguageRegistry.addName(new ItemStack(Items.miscItems.get(), 1, 16), "Ghastly Soul"); LanguageRegistry.addName(Items.pickaxeMud.get(), "Muddy Pickaxe"); LanguageRegistry.addName(Items.axeMud.get(), "Muddy Axe"); @@ -186,6 +189,8 @@ public class BOPItems { LanguageRegistry.addName(new ItemStack(Items.ancientStaff.get(), 1, 2), "Ancient Staff Pole"); LanguageRegistry.addName(new ItemStack(Items.ancientStaff.get(), 1, 3), "Ancient Staff Topper"); LanguageRegistry.addName(new ItemStack(Items.ancientStaff.get(), 1, 4), "Depleted Ancient Staff"); + + LanguageRegistry.addName(new ItemStack(Items.soulManipulator.get(), 1, 0), "Soul Manipulator"); LanguageRegistry.addName(Items.enderporter.get(), "Enderporter"); diff --git a/src/minecraft/biomesoplenty/items/ItemBOP.java b/src/minecraft/biomesoplenty/items/ItemBOP.java index 1b40dbdf8..ac3b4845e 100644 --- a/src/minecraft/biomesoplenty/items/ItemBOP.java +++ b/src/minecraft/biomesoplenty/items/ItemBOP.java @@ -17,7 +17,7 @@ import cpw.mods.fml.relauncher.SideOnly; public class ItemBOP extends Item { - private static String[] items = {"mudbrick", "ash", "amethyst", "poison", "crystalshard", "bluedye", "browndye", "greendye", "whitedye", "blackdye", "ruby", "peridot", "topaz", "tanzanite", "apatite", "sapphire"}; + private static String[] items = {"mudbrick", "ash", "amethyst", "poison", "crystalshard", "bluedye", "browndye", "greendye", "whitedye", "blackdye", "ruby", "peridot", "topaz", "tanzanite", "apatite", "sapphire", "ghastlysoul"}; @SideOnly(Side.CLIENT) private Icon[] textures; diff --git a/src/minecraft/biomesoplenty/items/ItemBOPAltar.java b/src/minecraft/biomesoplenty/items/ItemBOPAltar.java new file mode 100644 index 000000000..598affddb --- /dev/null +++ b/src/minecraft/biomesoplenty/items/ItemBOPAltar.java @@ -0,0 +1,33 @@ +package biomesoplenty.items; + +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; + +public class ItemBOPAltar extends ItemBlock +{ + private static final String[] altarTypes = new String[] {"altarFrame"}; + + public ItemBOPAltar(int par1) + { + super(par1); + setMaxDamage(0); + setHasSubtypes(true); + } + + @Override + public int getMetadata(int meta) + { + return meta & 15; + } + + @Override + public String getUnlocalizedName(ItemStack itemStack) + { + int meta = itemStack.getItemDamage(); + if (meta < 0 || meta >= altarTypes.length) { + meta = 0; + } + + return altarTypes[meta]; + } +} diff --git a/src/minecraft/biomesoplenty/items/ItemBOPGlass.java b/src/minecraft/biomesoplenty/items/ItemBOPGlass.java new file mode 100644 index 000000000..2a6ef08a8 --- /dev/null +++ b/src/minecraft/biomesoplenty/items/ItemBOPGlass.java @@ -0,0 +1,33 @@ +package biomesoplenty.items; + +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; + +public class ItemBOPGlass extends ItemBlock +{ + private static final String[] glassTypes = new String[] {"celestialLens", "sacrificialFocus"}; + + public ItemBOPGlass(int par1) + { + super(par1); + setMaxDamage(0); + setHasSubtypes(true); + } + + @Override + public int getMetadata(int meta) + { + return meta & 15; + } + + @Override + public String getUnlocalizedName(ItemStack itemStack) + { + int meta = itemStack.getItemDamage(); + if (meta < 0 || meta >= glassTypes.length) { + meta = 0; + } + + return glassTypes[meta]; + } +} diff --git a/src/minecraft/biomesoplenty/items/ItemSoulManipulator.java b/src/minecraft/biomesoplenty/items/ItemSoulManipulator.java new file mode 100644 index 000000000..6cfb7f67f --- /dev/null +++ b/src/minecraft/biomesoplenty/items/ItemSoulManipulator.java @@ -0,0 +1,72 @@ +package biomesoplenty.items; + +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.client.renderer.texture.IconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.Icon; +import net.minecraft.util.MathHelper; +import net.minecraft.world.World; +import biomesoplenty.BiomesOPlenty; +import biomesoplenty.api.Blocks; +import biomesoplenty.configuration.BOPConfiguration; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +public class ItemSoulManipulator extends Item +{ + private static String[] manipulatorTypes = {"soulmanipulator_empty"}; + @SideOnly(Side.CLIENT) + private Icon[] textures; + + public ItemSoulManipulator(int par1) + { + super(par1); + maxStackSize = 1; + setCreativeTab(BiomesOPlenty.tabBiomesOPlenty); + } + + @Override + public void registerIcons(IconRegister iconRegister) + { + textures = new Icon[manipulatorTypes.length]; + + for (int i = 0; i < manipulatorTypes.length; ++i) { + textures[i] = iconRegister.registerIcon("BiomesOPlenty:"+manipulatorTypes[i]); + } + } + + @Override + public String getUnlocalizedName(ItemStack itemStack) + { + int meta = itemStack.getItemDamage(); + if (meta < 0 || meta >= manipulatorTypes.length) { + meta = 0; + } + + return manipulatorTypes[meta]; + } + + @Override + public Icon getIconFromDamage(int meta) + { + if (meta < 0 || meta >= textures.length) { + meta = 0; + } + + return textures[meta]; + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + @Override + public void getSubItems(int itemId, CreativeTabs creativeTab, List subTypes) + { + for(int meta = 0; meta < manipulatorTypes.length; ++meta) { + subTypes.add(new ItemStack(itemId, 1, meta)); + } + } +} \ No newline at end of file diff --git a/src/minecraft/biomesoplenty/tileentity/TileEntityAltar.java b/src/minecraft/biomesoplenty/tileentity/TileEntityAltar.java new file mode 100644 index 000000000..e14f2124f --- /dev/null +++ b/src/minecraft/biomesoplenty/tileentity/TileEntityAltar.java @@ -0,0 +1,99 @@ +package biomesoplenty.tileentity; + +import java.lang.reflect.Field; + +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public class TileEntityAltar extends TileEntity +{ + public boolean apatitePresent = false; + public boolean peridotPresent = false; + public boolean rubyPresent = false; + public boolean sapphirePresent = false; + public boolean tanzanitePresent = false; + public boolean topazPresent = false; + + @Override + public void readFromNBT(NBTTagCompound nbt) + { + super.readFromNBT(nbt); + this.apatitePresent = nbt.getBoolean("apatitePresent"); + this.peridotPresent = nbt.getBoolean("peridotPresent"); + this.rubyPresent = nbt.getBoolean("rubyPresent"); + this.sapphirePresent = nbt.getBoolean("sapphirePresent"); + this.tanzanitePresent = nbt.getBoolean("tanzanitePresent"); + this.topazPresent = nbt.getBoolean("topazPresent"); + } + + @Override + public void writeToNBT(NBTTagCompound nbt) + { + super.writeToNBT(nbt); + nbt.setBoolean("apatitePresent", apatitePresent); + nbt.setBoolean("peridotPresent", peridotPresent); + nbt.setBoolean("rubyPresent", rubyPresent); + nbt.setBoolean("sapphirePresent", sapphirePresent); + nbt.setBoolean("tanzanitePresent", tanzanitePresent); + nbt.setBoolean("topazPresent", topazPresent); + } + + public void setPresent(String presentGem, boolean state) + { + if (presentGem == "apatite") + { + apatitePresent = state; + } + else if (presentGem == "peridot") + { + peridotPresent = state; + } + else if (presentGem == "ruby") + { + rubyPresent = state; + } + else if (presentGem == "sapphire") + { + sapphirePresent = state; + } + else if (presentGem == "tanzanite") + { + tanzanitePresent = state; + } + else if (presentGem == "topaz") + { + topazPresent = state; + } + } + + public boolean getPresent(String presentGem) + { + if (presentGem == "apatite") + { + return apatitePresent; + } + else if (presentGem == "peridot") + { + return peridotPresent; + } + else if (presentGem == "ruby") + { + return rubyPresent; + } + else if (presentGem == "sapphire") + { + return sapphirePresent; + } + else if (presentGem == "tanzanite") + { + return tanzanitePresent; + } + else if (presentGem == "topaz") + { + return topazPresent; + } + + return false; + } +} diff --git a/src/minecraft/mcmod.info b/src/minecraft/mcmod.info index b03101dcf..de1899614 100644 --- a/src/minecraft/mcmod.info +++ b/src/minecraft/mcmod.info @@ -7,7 +7,7 @@ "url": "www.minecraftforum.net/topic/1495041-", "updateUrl": "", "authors": [ "Adubbz", "Amnet", "ted80", "Forstride"], - "credits": "gamax92, enchilado, Tim Rurkowski", + "credits": "gamax92, enchilado, Tim Rurkowski, Soaryn", "logoFile": "/bop.png", "screenshots": [], "parent": "",