Java BlockRenderLayer.TRANSLUCENT属性代码示例

@Override
public BlockRenderLayer deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException
{
    if (json.isJsonPrimitive())
    {
        JsonPrimitive primitive = json.getAsJsonPrimitive();
        if (primitive.isString())
        {
            String string = primitive.getAsString();
            if (string.equals("solid"))
                return BlockRenderLayer.SOLID;
            if (string.equals("mippedCutout"))
                return BlockRenderLayer.CUTOUT_MIPPED;
            if (string.equals("cutout"))
                return BlockRenderLayer.CUTOUT;
            if (string.equals("translucent"))
                return BlockRenderLayer.TRANSLUCENT;
        }
    }

    throw new JsonParseException("Invalid block render layer: " + json);
}
 

/**
 * Returns true if given block is translucent
 */
private boolean isBlockTranslucent(@Nullable Block blockIn)
{
    return blockIn != null && blockIn.getBlockLayer() == BlockRenderLayer.TRANSLUCENT;
}
 

@Override
public BlockRenderLayer getBlockLayer() {
	return BlockRenderLayer.TRANSLUCENT;
}
 

@SideOnly(Side.CLIENT)
public BlockRenderLayer getBlockLayer() {
	return BlockRenderLayer.TRANSLUCENT;
}
 

public BlockRenderLayer getBlockLayer()
{
    return BlockRenderLayer.TRANSLUCENT;
}
 

public int renderBlockLayer(BlockRenderLayer blockLayerIn, double partialTicks, int pass, Entity entityIn)
{
    RenderHelper.disableStandardItemLighting();

    if (blockLayerIn == BlockRenderLayer.TRANSLUCENT)
    {
        this.mc.mcProfiler.startSection("translucent_sort");
        double d0 = entityIn.posX - this.prevRenderSortX;
        double d1 = entityIn.posY - this.prevRenderSortY;
        double d2 = entityIn.posZ - this.prevRenderSortZ;

        if (d0 * d0 + d1 * d1 + d2 * d2 > 1.0D)
        {
            this.prevRenderSortX = entityIn.posX;
            this.prevRenderSortY = entityIn.posY;
            this.prevRenderSortZ = entityIn.posZ;
            int k = 0;
            this.chunksToResortTransparency.clear();

            for (RenderGlobal.ContainerLocalRenderInformation renderglobal$containerlocalrenderinformation : this.renderInfos)
            {
                if (renderglobal$containerlocalrenderinformation.renderChunk.compiledChunk.isLayerStarted(blockLayerIn) && k++ < 15)
                {
                    this.chunksToResortTransparency.add(renderglobal$containerlocalrenderinformation.renderChunk);
                }
            }
        }

        this.mc.mcProfiler.endSection();
    }

    this.mc.mcProfiler.startSection("filterempty");
    int l = 0;
    boolean flag = blockLayerIn == BlockRenderLayer.TRANSLUCENT;
    int i1 = flag ? this.renderInfos.size() - 1 : 0;
    int i = flag ? -1 : this.renderInfos.size();
    int j1 = flag ? -1 : 1;

    for (int j = i1; j != i; j += j1)
    {
        RenderChunk renderchunk = ((RenderGlobal.ContainerLocalRenderInformation)this.renderInfos.get(j)).renderChunk;

        if (!renderchunk.getCompiledChunk().isLayerEmpty(blockLayerIn))
        {
            ++l;
            this.renderContainer.addRenderChunk(renderchunk, blockLayerIn);
        }
    }

    if (l == 0)
    {
        this.mc.mcProfiler.endSection();
        return l;
    }
    else
    {
        if (Config.isFogOff() && this.mc.entityRenderer.fogStandard)
        {
            GlStateManager.disableFog();
        }

        this.mc.mcProfiler.endStartSection("render_" + blockLayerIn);
        this.renderBlockLayer(blockLayerIn);
        this.mc.mcProfiler.endSection();
        return l;
    }
}
 

@SideOnly(Side.CLIENT)
public BlockRenderLayer getBlockLayer()
   {
       return BlockRenderLayer.TRANSLUCENT;
   }
 

@SideOnly(Side.CLIENT)
public BlockRenderLayer getBlockLayer()
{
    return BlockRenderLayer.TRANSLUCENT;
}
 

@Override
public BlockRenderLayer getBlockLayer()
{
    return BlockRenderLayer.TRANSLUCENT;
}
 

@Override
public BlockRenderLayer getBlockLayer()
{
	return BlockRenderLayer.TRANSLUCENT;
}
 

public void drawMultiTexture()
{
    if (this.quadSprites != null)
    {
        int i = Config.getMinecraft().getTextureMapBlocks().getCountRegisteredSprites();

        if (this.drawnIcons.length <= i)
        {
            this.drawnIcons = new boolean[i + 1];
        }

        Arrays.fill(this.drawnIcons, false);
        int j = 0;
        int k = -1;
        int l = this.vertexCount / 4;

        for (int i1 = 0; i1 < l; ++i1)
        {
            TextureAtlasSprite textureatlassprite = this.quadSprites[i1];

            if (textureatlassprite != null)
            {
                int j1 = textureatlassprite.getIndexInMap();

                if (!this.drawnIcons[j1])
                {
                    if (textureatlassprite == TextureUtils.iconGrassSideOverlay)
                    {
                        if (k < 0)
                        {
                            k = i1;
                        }
                    }
                    else
                    {
                        i1 = this.drawForIcon(textureatlassprite, i1) - 1;
                        ++j;

                        if (this.blockLayer != BlockRenderLayer.TRANSLUCENT)
                        {
                            this.drawnIcons[j1] = true;
                        }
                    }
                }
            }
        }

        if (k >= 0)
        {
            this.drawForIcon(TextureUtils.iconGrassSideOverlay, k);
            ++j;
        }

        if (j > 0)
        {
            ;
        }
    }
}
 

@SideOnly(Side.CLIENT)
public BlockRenderLayer getBlockLayer()
{
    return this.blockMaterial == Material.WATER ? BlockRenderLayer.TRANSLUCENT : BlockRenderLayer.SOLID;
}
 

public BlockRenderLayer getBlockLayer()
{
    return this.blockMaterial == Material.WATER ? BlockRenderLayer.TRANSLUCENT : BlockRenderLayer.SOLID;
}
 

@Override
public BlockRenderLayer getBlockLayer() {
    return BlockRenderLayer.TRANSLUCENT;
}
 

@Override
@SideOnly(Side.CLIENT)
public BlockRenderLayer getBlockLayer()
{
	return BlockRenderLayer.TRANSLUCENT;
}