SmelteryRender.java

package tconstruct.client.block;

import mantle.blocks.BlockUtils;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.item.ItemStack;
import net.minecraft.util.MathHelper;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidStack;
import tconstruct.blocks.logic.SmelteryLogic;
import tconstruct.client.TProxyClient;
import tconstruct.library.crafting.Smeltery;
import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
import cpw.mods.fml.client.registry.RenderingRegistry;

public class SmelteryRender implements ISimpleBlockRenderingHandler
{
    public static int smelteryModel = RenderingRegistry.getNextAvailableRenderId();

    @Override
    public void renderInventoryBlock (Block block, int metadata, int modelID, RenderBlocks renderer)
    {
        if (modelID == smelteryModel)
        {
            TProxyClient.renderStandardInvBlock(renderer, block, metadata);
        }
    }

    @Override
    public boolean renderWorldBlock (IBlockAccess world, int x, int y, int z, Block block, int modelID, RenderBlocks renderer)
    {
        if (modelID == smelteryModel)
        {
            if (world.getBlockMetadata(x, y, z) == 0)
                return renderSmeltery(world, x, y, z, block, modelID, renderer);
            else
                renderer.renderStandardBlock(block, x, y, z);
        }
        return true;
    }

    public boolean renderSmeltery (IBlockAccess world, int x, int y, int z, Block block, int modelID, RenderBlocks renderer)
    {
        renderer.renderStandardBlock(block, x, y, z);
        SmelteryLogic logic = (SmelteryLogic) world.getTileEntity(x, y, z);
        if (logic.validStructure)
        {
            int posX = logic.centerPos.x - 1, posY = logic.centerPos.y, posZ = logic.centerPos.z - 1;
            // Melting
            if (logic.getSizeInventory() > 0)
            {
                for (int i = 0; i < logic.layers; i++)
                {
                    renderLayer(logic, i * 9, posX, posY + i, posZ, renderer, world);
                }
            }

            // Liquids
            float base = 0F;
            int yBase = 0;
            int liquidBase = 0;
            for (FluidStack liquid : logic.moltenMetal)
            {
                int liquidSize = liquid.amount;
                while (liquidSize > 0)
                {
                    int room = 20000 - liquidBase;
                    int countSize = liquidSize > room ? room : liquidSize;
                    liquidSize -= countSize;

                    float height = countSize > 20000 ? 1.0F : countSize / 20000F;
                    // renderer.setRenderBounds(0, base, 0, 1, height + base,
                    // 1);
                    float renderBase = base;
                    float renderHeight = height + base;
                    base += height;
                    liquidBase += countSize;

                    Fluid fluid = liquid.getFluid();
                    for (int i = 0; i < 9; i++)
                    {
                        float minX = i % 3 == 0 ? -0.001F : 0F;
                        float minZ = i / 3 == 0 ? -0.001F : 0F;
                        float maxX = i % 3 == 2 ? 1.001F : 1F;
                        float maxZ = i / 3 == 2 ? 1.001F : 1F;
                        renderer.setRenderBounds(minX, renderBase, minZ, maxX, renderHeight, maxZ);
                        if (fluid.canBePlacedInWorld())
                            BlockSkinRenderHelper.renderMetadataBlock(fluid.getBlock(), 0, posX + i % 3, posY + yBase, posZ + i / 3, renderer, world);
                        else
                            BlockSkinRenderHelper.renderLiquidBlock(fluid.getStillIcon(), fluid.getFlowingIcon(), posX + i % 3, posY + yBase, posZ + i / 3, renderer, world);
                    }
                    /*
                     * if (liquid.itemID < 4096) //Block { Block liquidBlock =
                     * Block.blocksList[liquid.itemID]; for (int i = 0; i < 9;
                     * i++) { float minX = i % 3 == 0 ? -0.001F : 0F; float minZ
                     * = i / 3 == 0 ? -0.001F : 0F; float maxX = i % 3 == 2 ?
                     * 1.001F : 1F; float maxZ = i / 3 == 2 ? 1.001F : 1F;
                     * renderer.setRenderBounds(minX, renderBase, minZ, maxX,
                     * renderHeight, maxZ);
                     * BlockSkinRenderHelper.renderMetadataBlock(liquidBlock,
                     * liquid.itemMeta, posX + i % 3, posY + yBase, posZ + i /
                     * 3, renderer, world); } } else //Item { Item liquidItem =
                     * Item.itemsList[liquid.itemID]; for (int i = 0; i < 9;
                     * i++) { float minX = i % 3 == 0 ? -0.001F : 0F; float minZ
                     * = i / 3 == 0 ? -0.001F : 0F; float maxX = i % 3 == 2 ?
                     * 1.001F : 1F; float maxZ = i / 3 == 2 ? 1.001F : 1F;
                     * renderer.setRenderBounds(minX, renderBase, minZ, maxX,
                     * renderHeight, maxZ);
                     * BlockSkinRenderHelper.renderFakeBlock
                     * (liquidItem.getIconFromDamage(liquid.itemMeta), posX,
                     * posY + yBase, posZ, renderer, world); } }
                     */

                    if (countSize == room)
                    {
                        base = 0F;
                        yBase++;
                        liquidBase = 0;
                    }
                }
            }
        }
        return true;
    }

    void renderLayer (SmelteryLogic logic, int start, int posX, int posY, int posZ, RenderBlocks renderer, IBlockAccess world)
    {
        renderer.setRenderBounds(-0.001F, -0.001F, -0.001F, 1.001F, 1.001F, 1.001F);
        for (int i = 0; i < 9; i++)
        {
            ItemStack input = logic.getStackInSlot(i + start);
            if (input != null && logic.getTempForSlot(i + start) > 20)
            {
                ItemStack blockToRender = Smeltery.getRenderIndex(input);
                if (blockToRender != null)
                {
                    float blockHeight = input.stackSize / (float) blockToRender.stackSize;
                    renderer.setRenderBounds(0.0F, 0.0F, 0.0F, 1.0F, MathHelper.clamp_float(blockHeight, 0.01F, 1.0F), 1.0F);

                    // TODO is this needed???
                    // if (blockToRender.itemID < 4096) //Block
                    // {
                    Block liquidBlock = BlockUtils.getBlockFromItemStack(blockToRender);
                    BlockSkinRenderHelper.renderMetadataBlock(liquidBlock, blockToRender.getItemDamage(), posX + i % 3, posY, posZ + i / 3, renderer, world);
                    // }

                    /*
                     * else //No items, only blocks //Item { Item liquidItem =
                     * Item.itemsList[blockToRender.itemID]; int metadata =
                     * blockToRender.getItemDamage();
                     * BlockSkinRenderHelper.renderFakeBlock
                     * (liquidItem.getIconFromDamage(metadata), posX + i % 3,
                     * posY, posZ + i / 3, renderer, world); }
                     */
                }
            }
        }
    }

    @Override
    public boolean shouldRender3DInInventory (int modelID)
    {
        return true;
    }

    @Override
    public int getRenderId ()
    {
        return smelteryModel;
    }
}