net.minecraft.client.renderer.RenderBlocks Java Examples

@Override
@SideOnly(Side.CLIENT)
public void render (RenderBlocks renderer, int x, int y, int z, int meta, int pass) {
    float unit = 0.0625f;
    BlockCandelabra block = ModBlocks.candelabra;

    RenderHelper.instance.state.setRenderOffset(0, -.375f, 0);
    RenderHelper.instance.state.setColorMult(1, .9f, .8f, .5f);

    boxrender.setUnit(0);
    boxrender.setColor(ModularBoxRenderer.COLOR_WHITE);
    boxrender.setIcon(block.getIconCandleTop(), 1);
    for (int i = 2; i < 6; i++)
        boxrender.setIcon(block.getIconCandleSide(), i);

    // Candle
    boxrender.renderExterior(renderer.blockAccess, block, x, y, z, unit * 6.5f, unit * 7, unit * 6.5f, unit * 9.5f, unit * 13, unit * 9.5f, 0, ModularBoxRenderer.CUT_YNEG);

    RenderHelper.instance.state.resetColorMult();

    RenderHelper.instance.setRenderBounds(0, 0, 0, 1, 1, 1);
    RenderHelper.instance.renderCrossedSquares(renderer.blockAccess, block, x, y, z, block.getIconCandleSide());

    RenderHelper.instance.state.clearRenderOffset();
}
 

@Override
public void renderInventoryBlock(Block blck, int meta, int modelID, RenderBlocks renderer) {
	if (blck == null || !(blck instanceof BlockMultiLayerBase))
		return;

	BlockMultiLayerBase block = (BlockMultiLayerBase) blck;

	if (block.icon != null) {
		renderer.overrideBlockTexture = block.icon;
		renderer.renderBlockAsItem(Blocks.stone, meta, 1.0f);
		renderer.overrideBlockTexture = null;
	} else if (block.base != null) {
		renderer.renderBlockAsItem(block.base, meta, 1.0f);
	}
	
	glPushMatrix();
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	renderer.setRenderBounds(bot, bot, bot, top, top, top);
	glTranslatef(-0.5F, -0.5F, -0.5F);
	Drawing.drawBlock(block, meta, renderer);
	glDisable(GL_BLEND);
	glPopMatrix();
}
 

@Override
public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
	renderer.renderAllFaces = true;

	renderer.setRenderBounds(2 / 16F, 14 / 16F, 2 / 16F, 14 / 16F, 1, 14 / 16F);
	renderer.renderStandardBlock(block, x, y, z);

	renderer.setRenderBounds(0, 2 / 16F, 2 / 16F, 2 / 16F, 14 / 16F, 14 / 16F);
	renderer.renderStandardBlock(block, x, y, z);

	renderer.setRenderBounds(2 / 16F, 2 / 16F, 0, 14 / 16F, 14 / 16F, 2 / 16F);
	renderer.renderStandardBlock(block, x, y, z);

	renderer.setRenderBounds(2 / 16F, 2 / 16F, 14 / 16F, 14 / 16F, 14 / 16F, 1);
	renderer.renderStandardBlock(block, x, y, z);

	renderer.setRenderBounds(14 / 16F, 2 / 16F, 2 / 16F, 1, 14 / 16F, 14 / 16F);
	renderer.renderStandardBlock(block, x, y, z);

	renderer.setRenderBounds(2 / 16F, 0, 2 / 16F, 14 / 16F, 14 / 16F, 14 / 16F);
	renderer.renderStandardBlock(block, x, y, z);

	renderer.renderAllFaces = false;
	return true;
}
 

@Override
public void renderInventoryBlock(Block blck, int meta, int modelID, RenderBlocks renderer)
{
    if(blck == null || !(blck instanceof BlockTexturedOre))
        return;

    BlockTexturedOre block = (BlockTexturedOre) blck;

    if(block.icon != null)
    {
        renderer.overrideBlockTexture = block.icon;
        renderer.renderBlockAsItem(Blocks.stone, meta, 1.0f);
        renderer.overrideBlockTexture = null;
    } else if(block.base != null)
    {
        renderer.renderBlockAsItem(block.base, meta, 1.0f);
    }

    GL11.glEnable(3042);
    GL11.glBlendFunc(770, 771);
    renderer.setRenderBounds(bot, bot, bot, top, top, top);
    GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
    Drawing.drawBlock(block, meta, renderer);
    GL11.glDisable(3042);
}
 

@Override
public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block blck, int modelId, RenderBlocks renderer) {
	if (blck == null || !(blck instanceof BlockTexturedOre))
		return false;
	BlockTexturedOre block = (BlockTexturedOre) blck;

	if (block.currentPass == 0) {
		if (block.icon != null) {
			renderer.overrideBlockTexture = block.icon;
			renderer.renderStandardBlock(block, x, y, z);
			renderer.overrideBlockTexture = null;
		} else if (block.base != null) {
			renderer.renderBlockByRenderType(block.base, x, y, z);
		}
	} else {
		renderer.setRenderBounds(bot, bot, bot, top, top, top);
		renderer.renderStandardBlock(block, x, y, z);
	}

	return true;
}
 

@Override
public void load()
{
    ItemQuantumGoggles.s_renderIndex = RenderingRegistry.addNewArmourRendererPrefix( "qcraft:goggles" );

    super.load();

    // Setup renderers
    int gateID = RenderingRegistry.getNextAvailableRenderId();
    QCraft.Blocks.quantumLogic.blockRenderID = gateID;

    m_renderBlocks = new RenderBlocks();
    QCraft.Blocks.qBlock.blockRenderID = RenderingRegistry.getNextAvailableRenderId();

    // Setup client forge handlers
    registerForgeHandlers();
}
 

@Override
public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
    int bb = setBrightness(world, x, y, z, block);
    int metadata = world.getBlockMetadata(x, y, z);
    block.setBlockBounds(W3, 0.0F, W3, W13, W12, W13);
    renderer.setRenderBoundsFromBlock(block);
    renderer.renderStandardBlock(block, x, y, z);
    block.setBlockBounds(W5, W12, W5, W11, W14, W11);
    renderer.setRenderBoundsFromBlock(block);
    renderer.renderStandardBlock(block, x, y, z);

    renderer.clearOverrideBlockTexture();
    block.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
    renderer.setRenderBoundsFromBlock(block);
    return true;
}
 

protected void renderEquippedItems(EntityChiselSnowman snowman, float size){
    super.renderEquippedItems(snowman, size);
    ItemStack itemStack = snowman.getEquipmentInSlot(2);

    if(itemStack.getItem() instanceof ItemBlock){
        GL11.glPushMatrix();
        this.snowMan.head.postRender(0.0625F);

        IItemRenderer customRenderer = MinecraftForgeClient.getItemRenderer(itemStack, EQUIPPED);
        boolean is3D = (customRenderer != null && customRenderer.shouldUseRenderHelper(EQUIPPED, itemStack, BLOCK_3D));

        if(is3D || RenderBlocks.renderItemIn3d(Block.getBlockFromItem(itemStack.getItem()).getRenderType())){
            float f1 = 0.625F;
            GL11.glTranslatef(0.0F, -0.34375F, 0.0F);
            GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F);
            GL11.glScalef(f1, -f1, f1);
        }
        this.renderManager.itemRenderer.renderItem(snowman, itemStack, 0);
        GL11.glPopMatrix();
    }
}
 

@Override
@SideOnly(Side.CLIENT)
public void preRenderSide(RenderBlocks renderer, IBlockAccess world, int x, int y, int z, ForgeDirection side) {
	RenderBlocksCTM rbctm = (RenderBlocksCTM) renderer;
	if (side.ordinal() < 2 && !rbctm.rendererOld.hasOverrideBlockTexture()) {
		rbctm.rendererOld.setOverrideBlockTexture(sideTexture);
		hadOverride = false;
	} else {
		hadOverride = true;
	}
}
 

@Override
public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
	Tessellator.instance.setColorOpaque_I(Configurations.configColors[world.getBlockMetadata(x, y, z)]);
	Tessellator.instance.setBrightness(0xF000F0);
	Drawing.renderAllFaces(renderer, block, x, y, z, ((BlockCarvableGlow) block).getGlowTexture());
	renderer.renderStandardBlock(block, x, y, z);
	return true;
}
 

@Override
public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, BlockPIM block, int modelId, RenderBlocks renderer) {
	renderer.setRenderBoundsFromBlock(block);
	renderer.renderStandardBlock(block, x, y, z);

	final boolean isBreaking = renderer.hasOverrideBlockTexture();
	if (!isBreaking) renderer.setOverrideBlockTexture(BlockPIM.Icons.black);

	final boolean hasPlayer = hasPlayer(world, x, y, z);
	setTopPartBounds(renderer, hasPlayer);
	renderer.renderStandardBlock(block, x, y, z);

	if (!isBreaking) renderer.clearOverrideBlockTexture();
	return true;
}
 

@Override
public void renderInventoryBlock(BlockPIM block, int metadata, int modelID, RenderBlocks renderer) {
	RenderUtils.renderInventoryBlock(renderer, block, 0);

	renderer.setOverrideBlockTexture(BlockPIM.Icons.black);
	setTopPartBounds(renderer, false);
	RenderUtils.renderInventoryBlockNoBounds(renderer, block, 0);
	renderer.clearOverrideBlockTexture();
}
 

@Override
public void renderInventoryBlock(Block block, int meta, int modelID, RenderBlocks renderer) {
	setRenderRotate(renderer, (BlockSnakestone) block, meta);
	GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
	Drawing.drawBlock(block, meta, renderer);
	GL11.glTranslatef(0.5F, 0.5F, 0.5F);
	restoreRendererRotate(renderer);
}
 

public void renderInnerBlock(Block block, int x, int y, int z, RenderBlocks renderer, IBlockAccess world)
{
	Tessellator tessellator = Tessellator.instance;
	boolean tankUp = world.getBlockTileEntity(x, y + 1, z) instanceof TileEntityCertusTank;
	boolean tankDown = world.getBlockTileEntity(x, y - 1, z) instanceof TileEntityCertusTank;
	int meta = 0;
	if (tankUp && tankDown)
		meta = 3;
	else if (tankUp)
		meta = 2;
	else if (tankDown)
		meta = 1;
	if (!tankDown)
	{
		tessellator.setNormal(0.0F, -1F, 0.0F);
		renderer.renderFaceYNeg(block, x, y + 0.001D, z, block.getIcon(0, 0));
	}
	if (!(tankUp))
	{
		tessellator.setNormal(0.0F, 1.0F, 0.0F);
		renderer.renderFaceYPos(block, x, y - 0.001D, z, block.getIcon(1, 0));
	}
	Icon sideIcon = block.getIcon(3, meta);
	tessellator.setNormal(0.0F, 0.0F, -1F);
	renderer.renderFaceZNeg(block, x, y, z + 0.001D, sideIcon);
	tessellator.setNormal(0.0F, 0.0F, 1.0F);
	renderer.renderFaceZPos(block, x, y, z - 0.001D, sideIcon);
	tessellator.setNormal(-1F, 0.0F, 0.0F);
	renderer.renderFaceXNeg(block, x + 0.001D, y, z, sideIcon);
	tessellator.setNormal(1.0F, 0.0F, 0.0F);
	renderer.renderFaceXPos(block, x - 0.001D, y, z, sideIcon);

}
 

@Override
@SideOnly(Side.CLIENT)
public RenderBlocks createRenderContext(RenderBlocks rendererOld, Block block, IBlockAccess world) {
	if (rb == null) {
		rb = new RenderBlocksCTM();
	}
	rb.setRenderBoundsFromBlock(block);
	rb.submap = submap;
	rb.submapSmall = submapSmall;
	return rb;
}
 

@Override
@SideOnly(Side.CLIENT)
public RenderBlocks createRenderContext(RenderBlocks rendererOld, Block block, IBlockAccess world) {
	if (rb == null) {
		rb = new RenderBlocksCTM();
	}
	rb.setRenderBoundsFromBlock(block);
	rb.submap = submap;
	rb.submapSmall = submapSmall;
	return rb;
}
 

public static void drawBlock(Block block, int meta, RenderBlocks renderer)
{
    Tessellator tessellator = Tessellator.instance;

    tessellator.startDrawingQuads();
    tessellator.setNormal(0.0F, -1.0F, 0.0F);
    renderer.renderFaceYNeg(block, 0.0D, 0.0D, 0.0D, block.getIcon(0, meta));
    tessellator.draw();
    tessellator.startDrawingQuads();
    tessellator.setNormal(0.0F, 1.0F, 0.0F);
    renderer.renderFaceYPos(block, 0.0D, 0.0D, 0.0D, block.getIcon(1, meta));
    tessellator.draw();
    tessellator.startDrawingQuads();
    tessellator.setNormal(0.0F, 0.0F, -1.0F);
    renderer.renderFaceZNeg(block, 0.0D, 0.0D, 0.0D, block.getIcon(2, meta));
    tessellator.draw();
    tessellator.startDrawingQuads();
    tessellator.setNormal(0.0F, 0.0F, 1.0F);
    renderer.renderFaceZPos(block, 0.0D, 0.0D, 0.0D, block.getIcon(3, meta));
    tessellator.draw();
    tessellator.startDrawingQuads();
    tessellator.setNormal(-1.0F, 0.0F, 0.0F);
    renderer.renderFaceXNeg(block, 0.0D, 0.0D, 0.0D, block.getIcon(4, meta));
    tessellator.draw();
    tessellator.startDrawingQuads();
    tessellator.setNormal(1.0F, 0.0F, 0.0F);
    renderer.renderFaceXPos(block, 0.0D, 0.0D, 0.0D, block.getIcon(5, meta));
    tessellator.draw();
}
 

@Override
public void renderInventoryBlock(Block block, int meta, int modelID, RenderBlocks renderer)
{
    GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
    renderer.setRenderBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 0.5F);
    Drawing.drawBlock(block, meta, renderer);
    renderer.setRenderBounds(0.0F, 0.0F, 0.5F, 1.0F, 0.5F, 1.0F);
    Drawing.drawBlock(block, meta, renderer);
}
 

private void renderInventoryBlock (BlockHoop block, int metadata, int modelId, RenderBlocks renderer) {
    GL11.glRotatef(90, 0, 1, 0);
    GL11.glTranslatef(-.5f, -.5f, -.5f);

    boxrender.setUnit(0.0625f);
    boxrender.setIcon(block.getIcon(0, 0));
    boxrender.setColor(ModularBoxRenderer.COLOR_WHITE);

    boxrender.renderBox(null, block, 0, 0, 0, 0, .0625f, 0, 1, .375f, 1, 0, ModularBoxRenderer.CUT_YNEG | ModularBoxRenderer.CUT_YPOS);

    GL11.glTranslatef(.5f, .5f, .5f);
}
 

@Override
public boolean renderWorldBlock (IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
    if (!(block instanceof BlockGardenProxy))
        return false;

    return renderWorldBlock(world, x, y, z, (BlockGardenProxy) block, modelId, renderer);
}
 

@Override
public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer)
{
    int meta = world.getBlockMetadata(x, y, z);

    setRenderRotate(renderer, (BlockSnakestone) block, meta);
    boolean didRender = renderer.renderStandardBlock(block, x, y, z);
    restoreRendererRotate(renderer);

    return didRender;
}
 

@Override
public boolean renderWorldBlock (IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
    if (block instanceof BlockSmallFire)
        return renderWorldBlock(world, x, y, z, (BlockSmallFire) block, modelId, renderer);

    return false;
}
 

@Override
public void renderInventoryBlock(Block block, int metadata, int modelID, RenderBlocks renderer)
{
    if(block != ChickenChunks.blockChunkLoader)
        return;

    ChickenChunks.blockChunkLoader.setBlockBoundsForItemRender(metadata);
    int actualRenderID = renderID;
    renderID = 0;
    renderer.renderBlockAsItem(block, metadata, 1);
    renderID = actualRenderID;
}
 

@Override
@SideOnly(Side.CLIENT)
public void renderItem (RenderBlocks renderer, IItemRenderer.ItemRenderType renderType, int meta) {
    float unit = 0.0625f;
    BlockCandelabra block = ModBlocks.candelabra;

    RenderHelper.instance.state.setRenderOffset(0, -.375f, 0);
    RenderHelper.instance.state.setColorMult(1, .9f, .8f, .5f);

    boxrender.setUnit(0);
    boxrender.setColor(ModularBoxRenderer.COLOR_WHITE);
    boxrender.setIcon(block.getIconCandleTop(), 1);
    for (int i = 2; i < 6; i++)
        boxrender.setIcon(block.getIconCandleSide(), i);

    int x = 0;
    int y = 0;
    int z = 0;

    // Candle
    boxrender.renderExterior(null, block, x, y, z, unit * 6.5f, unit * 7, unit * 6.5f, unit * 9.5f, unit * 13, unit * 9.5f, 0, ModularBoxRenderer.CUT_YNEG);

    RenderHelper.instance.state.resetColorMult();

    RenderHelper.instance.setRenderBounds(0, 0, 0, 1, 1, 1);
    RenderHelper.instance.renderCrossedSquares(block, meta, block.getIconCandleSide());

    RenderHelper.instance.state.clearRenderOffset();
}
 

@Override
public void renderInventoryBlock(Block block, int metadata, int modelID,
		RenderBlocks renderer) {
	Tessellator tessellator = Tessellator.instance;
       GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
       tessellator.startDrawingQuads();
       tessellator.setNormal(0.0F, -1.0F, 0.0F);
       renderer.renderFaceYNeg(block, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(block, 0, metadata));
       tessellator.draw();
       tessellator.startDrawingQuads();
       tessellator.setNormal(0.0F, 1.0F, 0.0F);
       renderer.renderFaceYPos(block, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(block, 1, metadata));
       tessellator.draw();
       tessellator.startDrawingQuads();
       tessellator.setNormal(0.0F, 0.0F, -1.0F);
       renderer.renderFaceZNeg(block, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(block, 2, metadata));
       tessellator.draw();
       tessellator.startDrawingQuads();
       tessellator.setNormal(0.0F, 0.0F, 1.0F);
       renderer.renderFaceZPos(block, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(block, 3, metadata));
       tessellator.draw();
       tessellator.startDrawingQuads();
       tessellator.setNormal(-1.0F, 0.0F, 0.0F);
       renderer.renderFaceXNeg(block, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(block, 4, metadata));
       tessellator.draw();
       tessellator.startDrawingQuads();
       tessellator.setNormal(1.0F, 0.0F, 0.0F);
       renderer.renderFaceXPos(block, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(block, 5, metadata));
       tessellator.draw();
       GL11.glTranslatef(0.5F, 0.5F, 0.5F);
}
 

@Override
public void renderInventoryBlock(Block block, int metadata, int modelID, RenderBlocks renderer)
{
	if (block instanceof BlockTerminalFluid)
	{
		terminalRender.renderInventoryBlock(block, metadata, modelID, renderer);
	}
	if (block instanceof BlockMonitorStorageFluid)
	{
		monitorRender.renderInventoryBlock(block, metadata, modelID, renderer);
	}
}
 

@Override
public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer)
{
    int meta = world.getBlockMetadata(x, y, z);

    if(meta != 0) renderer.overrideBlockTexture = block.getIcon(0, meta);
    renderer.setRenderBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
    renderer.renderStandardBlock(block, x, y, z);
    renderer.overrideBlockTexture = null;

    return false;
}
 

@Override
public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks rendererOld)
{
    int meta = world.getBlockMetadata(x, y, z);

    CarvableVariation var = ((ICarvable) block).getVariation(meta);

    switch(var == null ? 0 : var.kind)
    {
        case CarvableHelper.CTMX:
            rendererCTM.blockAccess = world;
            rendererCTM.renderMaxX = 1.0;
            rendererCTM.renderMaxY = 1.0;
            rendererCTM.renderMaxZ = 1.0;

            rendererCTM.submap = var.submap;
            rendererCTM.submapSmall = var.submapSmall;

            rendererCTM.rendererOld = rendererOld;

            return rendererCTM.renderStandardBlock(block, x, y, z);
        case CarvableHelper.CTMV:
            rendererColumn.blockAccess = world;
            rendererColumn.renderMaxX = 1.0;
            rendererColumn.renderMaxY = 1.0;
            rendererColumn.renderMaxZ = 1.0;

            rendererColumn.submap = var.seamsCtmVert;
            rendererColumn.iconTop = var.iconTop;

            return rendererColumn.renderStandardBlock(block, x, y, z);
        default:
            return rendererOld.renderStandardBlock(block, x, y, z);
    }
}
 

@Override
public boolean renderWorldBlock (IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
    if (!(block instanceof BlockFlowerLeaves))
        return false;

    return renderWorldBlock(world, x, y, z, (BlockFlowerLeaves) block, modelId, renderer);
}
 

@Override
public void renderInventoryBlock(Block block, int metadata, int modelId, RenderBlocks renderer) {
    if(metadata == 1) {
        BlockStoneMachine blockStoneMachine = (BlockStoneMachine)block;
        DEVICE_BLOCK.iconPedestal[0] = blockStoneMachine.pedestalSideIcon;
        DEVICE_BLOCK.iconPedestal[1] = blockStoneMachine.pedestalTopIcon;
        DEVICE_RENDERER.renderInventoryBlock(DEVICE_BLOCK, 1, modelId, renderer);
    }
}