java类net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher的实例源码

void render() {
    Tessellator tessellator = Tessellator.getInstance();
    BufferBuilder buff = tessellator.getBuffer();

    buff.begin(GL11.GL_LINES, DefaultVertexFormats.POSITION_COLOR);
    buff.setTranslation(
            -TileEntityRendererDispatcher.staticPlayerX,
            -TileEntityRendererDispatcher.staticPlayerY,
            -TileEntityRendererDispatcher.staticPlayerZ
    );
    buff.pos(from.x, from.y, from.z).color(getRedColorF(), getGreenColorF(), getBlueColorF(), alpha * particleAlpha)
            .endVertex();
    buff.pos(to.x, to.y, to.z).color(getRedColorF(), getGreenColorF(), getBlueColorF(), alpha * particleAlpha)
            .endVertex();
    buff.setTranslation(0,0,0);
    tessellator.draw();
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    TileEntityRendererDispatcher tileentityrendererdispatcher = TileEntityRendererDispatcher.instance;
    TileEntitySpecialRenderer tileentityspecialrenderer = tileentityrendererdispatcher.getSpecialRendererByClass(TileEntityShulkerBox.class);

    if (!(tileentityspecialrenderer instanceof TileEntityShulkerBoxRenderer))
    {
        return null;
    }
    else
    {
        if (tileentityspecialrenderer.getEntityClass() == null)
        {
            tileentityspecialrenderer = new TileEntityShulkerBoxRenderer((ModelShulker)modelBase);
            tileentityspecialrenderer.setRendererDispatcher(tileentityrendererdispatcher);
        }

        if (!Reflector.TileEntityShulkerBoxRenderer_model.exists())
        {
            Config.warn("Field not found: TileEntityShulkerBoxRenderer.model");
            return null;
        }
        else
        {
            Reflector.setFieldValue(tileentityspecialrenderer, Reflector.TileEntityShulkerBoxRenderer_model, modelBase);
            return tileentityspecialrenderer;
        }
    }
}

public void renderChest(EntityBoatChest entity, float partialTicks) {
    TileEntitySpecialRenderer<TileEntityChest> renderer = TileEntityRendererDispatcher.instance.getSpecialRenderer(DUMMY_CHEST);
    if(renderer != null) {
        GlStateManager.pushMatrix();

        GlStateManager.translate(-0.5, 0.125, -0.5);
        GlStateManager.rotate(180, 1, 0, 0);
        GlStateManager.rotate(90, 0, 1, 0);

        DUMMY_CHEST.numPlayersUsing = entity.getPlayersUsing();
        DUMMY_CHEST.lidAngle = entity.getLidAngle();
        DUMMY_CHEST.prevLidAngle = entity.getPrevLidAngle();
        DUMMY_CHEST.setWorld(Boatifull.proxy.getClientWorld());
        renderer.renderTileEntityAt(DUMMY_CHEST, 0, 0, 0, partialTicks, -1);

        GlStateManager.popMatrix();
    }
}

@Override
public void renderTileEntityAt(TileEntityElectricOutlet te, double x, double y, double z, float partialTicks, int destroyStage) {
    if(te != null && te.hasWorld() && te.getPos() != null && te.getWorld().getBlockState(te.getPos()).getBlock() == ARKCraftBlocks.electricOutlet){
        GlStateManager.pushMatrix();
        GlStateManager.disableTexture2D();
        GlStateManager.disableLighting();
        Tessellator tessellator = Tessellator.getInstance();
        VertexBuffer vertexbuffer = tessellator.getBuffer();
        te.getConsumersClient().forEach(c -> {
            double xEnd = c.xCoord - TileEntityRendererDispatcher.staticPlayerX;
            double yEnd = c.yCoord - TileEntityRendererDispatcher.staticPlayerY;
            double zEnd = c.zCoord - TileEntityRendererDispatcher.staticPlayerZ;
            double xStart = x + .5;
            double yStart = y + .5;
            double zStart = z + .5;

            vertexbuffer.begin(3, DefaultVertexFormats.POSITION_COLOR);
            vertexbuffer.pos(xStart, yStart, zStart).color(0, 0, 0, 255).endVertex();
            vertexbuffer.pos(xEnd, yEnd, zEnd).color(0, 0, 0, 255).endVertex();
            tessellator.draw();
        });
        GlStateManager.enableLighting();
        GlStateManager.enableTexture2D();
        GlStateManager.popMatrix();
    }
}

/**
 * Renders a chest at 0,0,0 - used for item rendering
 */
public void renderChest(Block p_147715_1_, int p_147715_2_, float p_147715_3_)
{
    /*if (p_147715_1_ == Blocks.ender_chest)
    {
        TileEntityRendererDispatcher.instance.renderTileEntityAt(this.field_147716_d, 0.0D, 0.0D, 0.0D, 0.0F);
    }
    else if (p_147715_1_ == Blocks.trapped_chest)
    {
        TileEntityRendererDispatcher.instance.renderTileEntityAt(this.field_147718_c, 0.0D, 0.0D, 0.0D, 0.0F);
    }
    else*/

    {
        TileEntityRendererDispatcher.instance.renderTileEntityAt(this.field_147717_b, 0.0D, 0.0D, 0.0D, 0.0F);
    }
}

/**
 * Renders a chest at 0,0,0 - used for item rendering
 */
public void renderChest(Block p_147715_1_, int p_147715_2_, float p_147715_3_)
{
    /*if (p_147715_1_ == Blocks.ender_chest)
    {
        TileEntityRendererDispatcher.instance.renderTileEntityAt(this.field_147716_d, 0.0D, 0.0D, 0.0D, 0.0F);
    }
    else if (p_147715_1_ == Blocks.trapped_chest)
    {
        TileEntityRendererDispatcher.instance.renderTileEntityAt(this.field_147718_c, 0.0D, 0.0D, 0.0D, 0.0F);
    }
    else*/

    {
        TileEntityRendererDispatcher.instance.renderTileEntityAt(this.field_147717_b, 0.0D, 0.0D, 0.0D, 0.0F);
    }
}

@help("Disable or enable TileEntity special renderers")
public static String tesrtoggle() {
    if (backup == null) {
        if (TileEntityRendererDispatcher.instance.mapSpecialRenderers == null) {
            return "no TESRs!";
        }
        backup = TileEntityRendererDispatcher.instance.mapSpecialRenderers;
        TileEntityRendererDispatcher.instance.mapSpecialRenderers = empty;
        return "TESRs disabled";
    } else {
        empty.clear();
        TileEntityRendererDispatcher.instance.mapSpecialRenderers = backup;
        backup = null;
        return "TESRs enabled; requires chunk update to restart drawing";
    }
}

@Override
public void render(TileEntityCauldron cauldron, double x, double y, double z, float partialTicks, int destroyStage, float alpha) {
    if (cauldron != null) {
        final TileFluidTank tank = cauldron.tank;

        if (tank != null && tank.getFluid() != null && tank.getFluidAmount() > 0) {
            FluidStack fluid = tank.getFluid();
            BlockPos pos = cauldron.getPos();

            GlStateManager.pushMatrix();
            GlStateManager.enableBlend();

            final float staticX = (float) (pos.getX() - TileEntityRendererDispatcher.staticPlayerX);
            final float staticY = (float) (pos.getY() - TileEntityRendererDispatcher.staticPlayerY);
            final float staticZ = (float) (pos.getZ() - TileEntityRendererDispatcher.staticPlayerZ);

            GlStateManager.translate(staticX, staticY, staticZ);
            RenderUtils.renderFluid(fluid, cauldron.getPos(), 0.06D, 0.14D, 0.00D, 0.06D, 0.06D, 0.1D, 0.82D, (double) tank.getFluidAmount() / (double) tank.getCapacity() * 0.8d, 0.88d, fluid.getFluid().getColor(fluid));

            GlStateManager.disableBlend();
            GlStateManager.popMatrix();
        }
    }
}

@Override
public void renderInventoryBlock(Block block, int metadata, int modelID, RenderBlocks renderer) {
    DynamicBlock dynamicBlock = (block instanceof DynamicBlock) ? (DynamicBlock) block : null;
    final TileEntity te;
    if (dynamicBlock != null && dynamicBlock.shouldRenderTesrInInventory())
        te = getTileEntityForBlock(dynamicBlock);
    else
        te = null;

    if (te instanceof DynamicTileEntity) ((DynamicTileEntity) te).prepareForInventoryRender(block, metadata);

    GL11.glEnable(GL12.GL_RESCALE_NORMAL);
    GL11.glRotatef(-90.0F, 0.0F, 1.0F, 0.0F);
    if (te != null) {
        GL11.glPushAttrib(GL11.GL_TEXTURE_BIT);
        GL11.glPushMatrix();
        GL11.glTranslated(-0.5, -0.5, -0.5);
        TileEntityRendererDispatcher.instance.renderTileEntityAt(te, 0.0D, 0.0D, 0.0D, 0.0F);
        GL11.glPopMatrix();
        GL11.glPopAttrib();
    }

    RenderUtils.renderInventoryBlock(renderer, block);
    RenderUtils.resetFacesOnRenderer(renderer);
}

@SideOnly(Side.CLIENT)
public void renderEntity(IGuiLexiconEntry gui, TileEntity entity, int x, int y, int scale, float rotation) {
    entity.setWorldObj(Minecraft.getMinecraft() != null ? Minecraft.getMinecraft().theWorld : null);

    GL11.glEnable(GL11.GL_COLOR_MATERIAL);
    GL11.glPushMatrix();
    GL11.glTranslatef(x, y, 75.0F);
    GL11.glScalef(-scale, scale, scale);
    GL11.glRotatef(180F, 0.0F, 0.25F, 1.0F);
    GL11.glRotatef(rotation, 0.0F, 1.0F, 0.0F);
    RenderHelper.enableStandardItemLighting();
    GL11.glTranslatef(0.0F, 0, 0.0F);
    RenderManager.instance.playerViewY = 180.0F;
    TileEntitySpecialRenderer render = TileEntityRendererDispatcher.instance.getSpecialRenderer(te);
    if(render != null)
        render.renderTileEntityAt(entity, 0, 0, 0, 1);
    GL11.glPopMatrix();
    RenderHelper.disableStandardItemLighting();
    GL11.glDisable(GL12.GL_RESCALE_NORMAL);
    OpenGlHelper.setActiveTexture(OpenGlHelper.lightmapTexUnit);
    GL11.glDisable(GL11.GL_TEXTURE_2D);
    OpenGlHelper.setActiveTexture(OpenGlHelper.defaultTexUnit);

    if(relativeMouseX >= x - width * scale / 2 - 10  && relativeMouseY >= y - height * scale - 20 && relativeMouseX <= x + width * scale / 2 + 10 && relativeMouseY <= y + 20)
        tooltipEntity = true;
}

@SubscribeEvent
public void onBlockHighlight(DrawBlockHighlightEvent e) {
    GL11.glPushMatrix();
    if (e.player.getCurrentEquippedItem() != null) {
        Item i = e.player.getCurrentEquippedItem().getItem();
        if (Block.getBlockFromItem(i) instanceof RLMBlockContainer && e.target.getBlockPos() != null) {
            if (e.player.worldObj.getBlockState(e.target.getBlockPos()).getBlock() != Blocks.air) {
                if (TileEntityRendererDispatcher.instance != null) {
                    RLMBlockContainer b = (RLMBlockContainer) Block.getBlockFromItem(i);
                    if (b != null) {
                        BlockPos p = e.target.getBlockPos();
                        GL11.glTranslated(p.getX(), p.getY(), p.getZ());
                        // if
                        // (b.createNewTileEntity(Minecraft.getMinecraft().theWorld,
                        // 0) != null);
                        // TileEntityRendererDispatcher.instance.renderTileEntity(b.createNewTileEntity(Minecraft.getMinecraft().theWorld,
                        // 0),0.0f,1);
                    }
                }
            }
        }
    }
    GL11.glPopMatrix();
}

public void doTheRenderThing(){
    RenderingRegistry.registerEntityRenderingHandler(EntityFrankenstein.class, new RenderFrankenstein());
    RenderingRegistry.registerEntityRenderingHandler(EntityWarhorse.class, new RenderWarhorse());
    RenderingRegistry.registerEntityRenderingHandler(EntityPeep.class, new RenderPeep());
    RenderingRegistry.registerEntityRenderingHandler(EntityUnicorn.class, new RenderUnicorn());
    RenderingRegistry.registerEntityRenderingHandler(EntityCalavera.class, new RenderCalavera());
    RenderingRegistry.registerEntityRenderingHandler(EntityGingerbread.class, new RenderGingerbread());
    RenderingRegistry.registerEntityRenderingHandler(EntityShoggoth.class, new RenderShoggoth());
    RenderingRegistry.registerEntityRenderingHandler(EntityDaySkeleton.class, new RenderSkeleton());
    RenderingRegistry.registerEntityRenderingHandler(EntityDayZombie.class, new RenderZombie());
    RenderingRegistry.registerEntityRenderingHandler(EntityShadowSlime.class, new RenderShadowSlime());
    RenderingRegistry.registerEntityRenderingHandler(EntityCandySheep.class, new RenderCandySheep(new ModelSheep2(), new ModelSheep1(), 0.7F));
    RenderingRegistry.registerEntityRenderingHandler(EntityOldEnderman.class, new RenderOldEnderman());

    if(Config.heads && !Loader.isModLoaded("foxlib")){
        TileEntityRendererDispatcher.instance.mapSpecialRenderers.remove(TileEntitySkull.class);
        BlockSkullRenderer blockSkullRenderer = new BlockSkullRenderer();
        ClientRegistry.bindTileEntitySpecialRenderer(TileEntitySkull.class, blockSkullRenderer);
    }

    ClientRegistry.bindTileEntitySpecialRenderer(TileEntityChestRidiculous.class, new RenderTileEntityChest());
    BlockChestRidiculous.render = RenderingRegistry.getNextAvailableRenderId();
    MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(RidiculousBlocks.chest), new RenderItemChest());

    ShaderHelper.initShaders();
}

@Override
public boolean drawHighlight(MovingObjectPosition mop, EntityPlayer player, float frame) {

    ForgeDirection face = ForgeDirection.getOrientation(mop.sideHit);

    AxisAlignedBB c = net.quetzi.bluepower.util.RayTracer.getSelectedCuboid(mop, player, face, getSubParts(), true);

    if (c == null) return true;

    GL11.glPushMatrix();
    {
        GL11.glTranslated(x() - TileEntityRendererDispatcher.staticPlayerX, y() - TileEntityRendererDispatcher.staticPlayerY, z()
                - TileEntityRendererDispatcher.staticPlayerZ);
        GL11.glDisable(GL11.GL_TEXTURE_2D);
        GL11.glColor4d(0, 0, 0, 0);
        RenderUtils.drawCuboidOutline(new Cuboid6(c).expand(0.001));
        GL11.glColor4d(1, 1, 1, 1);
        GL11.glEnable(GL11.GL_TEXTURE_2D);
    }
    GL11.glPopMatrix();

    return true;
}

@Override
public void renderInventoryBlock(Block block, int metadata, int modelId, RenderBlocks renderer) {
    if (block instanceof ITileEntityProvider) {
        ITileEntityProvider prov = (ITileEntityProvider) block;
        te = prov.createNewTileEntity(null, metadata);
        te.blockMetadata = metadata;
    } else return;

    if (block instanceof IBlockRenderHook) {
        IBlockRenderHook hook = (IBlockRenderHook) block;
        hook.callbackInventory(te);
    }

    glRotatef(90F, 0F, 1F, 0F);
    glTranslatef(-0.5F, -0.5F, -0.5F);
    float scale = 1F;
    glScalef(scale, scale, scale);

    glAlphaFunc(GL_GREATER, 0.1F);
    TileEntityRendererDispatcher.instance.renderTileEntityAt(te, 0.0D, 0.0D, 0.0D, 0.0F);
}

@Override
public void renderInventoryBlock(Block block, int metadata, int modelId, RenderBlocks renderBlocks) {
    if (block instanceof ITileEntityProvider) {
        ITileEntityProvider prov = (ITileEntityProvider) block;
        te = prov.createNewTileEntity(null, metadata);
        te.blockMetadata = metadata;
    } else return;

    if (block instanceof IBlockRenderHook) {
        IBlockRenderHook hook = (IBlockRenderHook) block;
        hook.callbackInventory(te);
    }

    glRotatef(90F, 0F, 1F, 0F);
    glTranslatef(-0.5F, -0.5F, -0.5F);
    float scale = 1F;
    glScalef(scale, scale, scale);

    glAlphaFunc(GL_GREATER, 0.1F);
    TESRStaticHandler renderer = (TESRStaticHandler) TileEntityRendererDispatcher.instance.mapSpecialRenderers.get(te.getClass());
    renderer.renderTile(te, 0.0, 0.0, 0.0, 0, true, renderBlocks);

    renderer.renderTile(te, 0.0, 0.0, 0.0, 0, false, renderBlocks);
}

/**
 * Draws the screen and all the components in it.
 */
@Override
public void drawScreen(int par1, int par2, float par3) {
    this.drawDefaultBackground();

    drawCenteredString(fontRendererObj, screenTitle, width / 2, 40, 16777215);
    GL11.glPushMatrix();
    GL11.glTranslatef(width / 2, 0.0F, 50.0F);
    float var4 = 93.75F;
    GL11.glScalef(-var4, -var4, -var4);

    float var7 = 0.0F;
    GL11.glRotatef(var7, 0.0F, 1.0F, 0.0F);
    GL11.glTranslatef(0.0F, -1.0625F, 0.0F);

    if (updateCounter / 6 % 2 == 0) {
        entitySign.lineBeingEdited = editLine;
    }

    TileEntityRendererDispatcher.instance.renderTileEntityAt(entitySign, -0.5D, -0.75D, -0.5D, -1f);
    entitySign.lineBeingEdited = -1;
    GL11.glPopMatrix();
    super.drawScreen(par1, par2, par3);
}

/**
 * Draws the screen and all the components in it.
 */
@Override
public void drawScreen(int par1, int par2, float par3) {
    this.drawDefaultBackground();

    drawCenteredString(fontRendererObj, screenTitle, width / 2, 40, 16777215);
    GL11.glPushMatrix();
    GL11.glTranslatef(width / 2, 0.0F, 50.0F);
    float var4 = 93.75F;
    GL11.glScalef(-var4, -var4, -var4);

    float var7 = 0.0F;
    GL11.glRotatef(var7, 0.0F, 1.0F, 0.0F);
    GL11.glTranslatef(0.0F, -1.0625F, 0.0F);

    if (updateCounter / 6 % 2 == 0) {
        entitySign.lineBeingEdited = editLine;
    }

    TileEntityRendererDispatcher.instance.renderTileEntityAt(entitySign, -0.5D, -0.75D, -0.5D, -1f);
    entitySign.lineBeingEdited = -1;
    GL11.glPopMatrix();
    super.drawScreen(par1, par2, par3);
}

@Override
public void renderInventoryBlock(Block block, int metadata, int modelID, RenderBlocks renderer) {
    TileEntityGrinder tile = new TileEntityGrinder();
    tile.blockType = block;
    GL11.glPushMatrix();
    GL11.glTranslatef(-0.2F,
                      0.0F,
                      -0.3F);
    GL11.glRotatef(-5,
                   0,
                   1,
                   0);
    GL11.glRotatef(5,
                   0,
                   0,
                   1);
    GL11.glScalef(1.35F,
                  1.35F,
                  1.35F);
    TileEntityRendererDispatcher.instance.renderTileEntityAt(tile,
                                                             -0.3D,
                                                             -0.3D,
                                                             -0.3D,
                                                             0.0F);
    GL11.glPopMatrix();
}

@SideOnly(Side.CLIENT)
@Override
public void renderDynamic(Vector3 pos, float partialTicks, int renderPass){
    if(renderPass == 0) {
        /*   GL11.glPushMatrix(); // start
           // GL11.glDisable(GL11.GL_TEXTURE_2D);
           // GL11.glEnable(GL11.GL_BLEND);
           // GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
           FMLClientHandler.instance().getClient().getTextureManager().bindTexture(getTexture());

           // GL11.glColor4f(0.82F, 0.56F, 0.09F, 1.0F);
           GL11.glTranslatef((float)pos.x + 0.5F, (float)pos.y + 1.5F, (float)pos.z + 0.5F); // size
           GL11.glRotatef(0, 0.0F, 1.0F, 0.0F);

           GL11.glScalef(1.0F, -1F, -1F);
           if(tubeModel == null) tubeModel = new ModelPressureTube();
           tubeModel.renderModel(0.0625F, tube.sidesConnected);
           GL11.glPopMatrix();*/
        TileEntityRendererDispatcher.instance.getSpecialRenderer(tube).renderTileEntityAt(tube, pos.x, pos.y, pos.z, partialTicks);

    }
}

private void renderBanner(float x, float y, float z, float angle, float scale) {
    OpenGLHelper.pushMatrix();
    OpenGLHelper.rotate(angle, 0, 1, 0);
    OpenGLHelper.scale(scale, scale, scale);
    OpenGLHelper.translate(x, y, z);

    TileEntityRendererDispatcher.instance.renderTileEntityAt(banner, 0, 0, 0, 0);

    OpenGLHelper.popMatrix();
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    TileEntityRendererDispatcher tileentityrendererdispatcher = TileEntityRendererDispatcher.instance;
    TileEntitySpecialRenderer tileentityspecialrenderer = tileentityrendererdispatcher.getSpecialRendererByClass(TileEntityBanner.class);

    if (!(tileentityspecialrenderer instanceof TileEntityBannerRenderer))
    {
        return null;
    }
    else
    {
        if (tileentityspecialrenderer.getEntityClass() == null)
        {
            tileentityspecialrenderer = new TileEntityBannerRenderer();
            tileentityspecialrenderer.setRendererDispatcher(tileentityrendererdispatcher);
        }

        if (!Reflector.TileEntityBannerRenderer_bannerModel.exists())
        {
            Config.warn("Field not found: TileEntityBannerRenderer.bannerModel");
            return null;
        }
        else
        {
            Reflector.setFieldValue(tileentityspecialrenderer, Reflector.TileEntityBannerRenderer_bannerModel, modelBase);
            return tileentityspecialrenderer;
        }
    }
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    TileEntityRendererDispatcher tileentityrendererdispatcher = TileEntityRendererDispatcher.instance;
    TileEntitySpecialRenderer tileentityspecialrenderer = tileentityrendererdispatcher.getSpecialRendererByClass(TileEntityEnderChest.class);

    if (!(tileentityspecialrenderer instanceof TileEntityEnderChestRenderer))
    {
        return null;
    }
    else
    {
        if (tileentityspecialrenderer.getEntityClass() == null)
        {
            tileentityspecialrenderer = new TileEntityEnderChestRenderer();
            tileentityspecialrenderer.setRendererDispatcher(tileentityrendererdispatcher);
        }

        if (!Reflector.TileEntityEnderChestRenderer_modelChest.exists())
        {
            Config.warn("Field not found: TileEntityEnderChestRenderer.modelChest");
            return null;
        }
        else
        {
            Reflector.setFieldValue(tileentityspecialrenderer, Reflector.TileEntityEnderChestRenderer_modelChest, modelBase);
            return tileentityspecialrenderer;
        }
    }
}

public IEntityRenderer makeEntityRender(ModelBase modelBase, float shadowSize)
{
    TileEntityRendererDispatcher tileentityrendererdispatcher = TileEntityRendererDispatcher.instance;
    TileEntitySpecialRenderer tileentityspecialrenderer = tileentityrendererdispatcher.getSpecialRendererByClass(TileEntityEnchantmentTable.class);

    if (!(tileentityspecialrenderer instanceof TileEntityEnchantmentTableRenderer))
    {
        return null;
    }
    else
    {
        if (tileentityspecialrenderer.getEntityClass() == null)
        {
            tileentityspecialrenderer = new TileEntityEnchantmentTableRenderer();
            tileentityspecialrenderer.setRendererDispatcher(tileentityrendererdispatcher);
        }

        if (!Reflector.TileEntityEnchantmentTableRenderer_modelBook.exists())
        {
            Config.warn("Field not found: TileEntityEnchantmentTableRenderer.modelBook");
            return null;
        }
        else
        {
            Reflector.setFieldValue(tileentityspecialrenderer, Reflector.TileEntityEnchantmentTableRenderer_modelBook, modelBase);
            return tileentityspecialrenderer;
        }
    }
}

public static void renderTileItem(Item item, int metadata)
{
    Class<? extends TileEntity> tileClass = tileItemMap.get(Pair.of(item, metadata));
    if (tileClass != null)
    {
        TileEntitySpecialRenderer<?> r = TileEntityRendererDispatcher.instance.getSpecialRendererByClass(tileClass);
        if (r != null)
        {
            r.renderTileEntityAt(null, 0, 0, 0, 0, -1);
        }
    }
}

@SideOnly(Side.CLIENT)
public static void translateAgainstPlayer (BlockPos pos) {

    final float x = (float) (pos.getX() - TileEntityRendererDispatcher.staticPlayerX);
    final float y = (float) (pos.getY() - TileEntityRendererDispatcher.staticPlayerY);
    final float z = (float) (pos.getZ() - TileEntityRendererDispatcher.staticPlayerZ);
    GlStateManager.translate(x + 0.5, y + 0.5, z + 0.5);
}

public void renderChest(Block par1Block, int par2, float par3)
{
    if (par1Block == MarsBlocks.tier2TreasureChest)
    {
        TileEntityRendererDispatcher.instance.renderTileEntityAt(this.chest, 0.0D, 0.0D, 0.0D, 0.0F);
    }
}

public void renderChest(Block par1Block, int par2, float par3)
{
    if (par1Block == AsteroidBlocks.treasureChestTier3)
    {
        TileEntityRendererDispatcher.instance.renderTileEntityAt(this.chest, 0.0D, 0.0D, 0.0D, 0.0F);
    }
}

public void renderChest(Block par1Block, int par2, float par3)
{
    if (par1Block == GCBlocks.parachest)
    {
        TileEntityRendererDispatcher.instance.renderTileEntityAt(this.chest, 0.0D, 0.0D, 0.0D, 0.0F);
    }
}

@Override
public void renderInventoryBlock(Block block, int metadata, int modelID, RenderBlocks renderer)
{
    GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F);
    GL11.glTranslatef(-0.5F, -1.1F, -0.1F);
    GL11.glScalef(0.7F, 0.6F, 0.7F);
    TileEntityRendererDispatcher.instance.renderTileEntityAt(this.table, 0.0D, 0.0D, 0.0D, 0.0F);
    GL11.glEnable(GL12.GL_RESCALE_NORMAL);
}

public void renderChest(Block par1Block, int par2, float par3)
{
    if (par1Block == GCBlocks.treasureChestTier1)
    {
        TileEntityRendererDispatcher.instance.renderTileEntityAt(this.chest, 0.0D, 0.0D, 0.0D, 0.0F);
    }
}