下面列出了怎么用net.minecraft.util.BlockRenderLayer的API类实例代码及写法，或者点击链接到github查看源代码。
public MultiLayerBakedModel(Map<BlockRenderLayer, IBakedModel> models, IBakedModel base, IBakedModel missing, ImmutableMap<TransformType, TRSRTransformation> cameraTransforms) {
super(base, cameraTransforms);
this.models = ImmutableMap.copyOf(models);
this.missing = missing;
final List<BakedQuad> quads = Lists.newArrayList();
for (BlockRenderLayer layer : BlockRenderLayer.values()) {
final IBakedModel model = models.get(layer);
if (model != null) {
buildQuadsForLayer(quads, model);
}
}
this.quads = ImmutableList.copyOf(quads);
}
@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);
}
private void drawBlock() {
final Tessellator tessellator = Tessellator.getInstance();
final BufferBuilder wr = tessellator.getBuffer();
final BlockRendererDispatcher dispatcher = parent.getMinecraft().getBlockRendererDispatcher();
for (BlockRenderLayer layer : BlockRenderLayer.values()) {
if (blockState.getBlock().canRenderInLayer(blockState, layer)) {
net.minecraftforge.client.ForgeHooksClient.setRenderLayer(layer);
wr.setTranslation(-0.5, -0.5, -0.5);
wr.begin(GL11.GL_QUADS, DefaultVertexFormats.BLOCK);
dispatcher.renderBlock(blockState, FakeBlockAccess.ORIGIN, access, wr);
tessellator.draw();
}
}
wr.setTranslation(0.0D, 0.0D, 0.0D);
net.minecraftforge.client.ForgeHooksClient.setRenderLayer(null);
}
@Override
public boolean renderBlock(IBlockAccess world, BlockPos pos, IBlockState state, BufferBuilder buffer) {
CCRenderState renderState = CCRenderState.instance();
renderState.reset();
renderState.bind(buffer);
renderState.setBrightness(world, pos);
IVertexOperation[] pipeline = {new Translation(pos)};
BlockInventoryPipe block = (BlockInventoryPipe) state.getBlock();
TileEntityInventoryPipe tileEntity = (TileEntityInventoryPipe) block.getPipeTileEntity(world, pos);
if (tileEntity == null) {
return false;
}
int paintingColor = tileEntity.getInsulationColor();
int connectedSidesMask = block.getActualConnections(tileEntity, world);
BlockRenderLayer renderLayer = MinecraftForgeClient.getRenderLayer();
if (renderLayer == BlockRenderLayer.SOLID) {
renderPipe(renderState, pipeline, paintingColor, connectedSidesMask);
}
ICoverable coverable = tileEntity.getCoverableImplementation();
coverable.renderCovers(renderState, new Matrix4().translate(pos.getX(), pos.getY(), pos.getZ()), renderLayer);
return true;
}
@Override
public MultiLayerModel process(ImmutableMap<String, String> customData) {
final ModelUpdater updater = new ModelUpdater(customData);
final Optional<ResourceLocation> base = updater.get("base", ModelUpdater.MODEL_LOCATION, this.base);
final Map<BlockRenderLayer, ResourceLocation> models = Maps.newHashMap();
for (BlockRenderLayer layer : BlockRenderLayer.values()) {
final ResourceLocation result = updater.get(layer.toString(), ModelUpdater.MODEL_LOCATION, this.models.get(layer));
if (result != null) models.put(layer, result);
}
return updater.hasChanged()? new MultiLayerModel(base, models) : this;
}
/*******************************************************************************
* 2. Rendering
*******************************************************************************/
@Override
@SideOnly(Side.CLIENT)
public BlockRenderLayer getBlockLayer()
{
return BlockRenderLayer.CUTOUT;
}
public void renderBlockLayer(BlockRenderLayer layerToRender, double partialTicks,
int pass) {
switch (layerToRender) {
case CUTOUT:
if (needsCutoutUpdate) {
updateList(layerToRender);
}
GL11.glCallList(glCallListCutout);
break;
case CUTOUT_MIPPED:
if (needsCutoutMippedUpdate) {
updateList(layerToRender);
}
GL11.glCallList(glCallListCutoutMipped);
break;
case SOLID:
if (needsSolidUpdate) {
updateList(layerToRender);
}
GL11.glCallList(glCallListSolid);
break;
case TRANSLUCENT:
if (needsTranslucentUpdate) {
updateList(layerToRender);
}
GL11.glCallList(glCallListTranslucent);
break;
default:
break;
}
}
/*******************************************************************************
* 2. Rendering
*******************************************************************************/
@Override
@SideOnly(Side.CLIENT)
public BlockRenderLayer getBlockLayer()
{
return BlockRenderLayer.CUTOUT;
}
public void renderBlockLayer(BlockRenderLayer layerToRender, double partialTicks, int pass) {
switch (layerToRender) {
case CUTOUT:
if (needsCutoutUpdate) {
updateList(layerToRender);
}
FastBlockModelRenderer.renderVertexBuffer(cutoutBuffer);
break;
case CUTOUT_MIPPED:
if (needsCutoutMippedUpdate) {
updateList(layerToRender);
}
FastBlockModelRenderer.renderVertexBuffer(cutoutMippedBuffer);
break;
case SOLID:
if (needsSolidUpdate) {
updateList(layerToRender);
}
FastBlockModelRenderer.renderVertexBuffer(solidBuffer);
break;
case TRANSLUCENT:
if (needsTranslucentUpdate) {
updateList(layerToRender);
}
FastBlockModelRenderer.renderVertexBuffer(translucentBuffer);
break;
default:
break;
}
}
/*******************************************************************************
* 2. Rendering
*******************************************************************************/
@Override
@SideOnly(Side.CLIENT)
public BlockRenderLayer getBlockLayer()
{
return BlockRenderLayer.CUTOUT;
}
/*******************************************************************************
* 2. Rendering
*******************************************************************************/
@Override
@SideOnly(Side.CLIENT)
public BlockRenderLayer getBlockLayer()
{
return BlockRenderLayer.CUTOUT_MIPPED;
}
public void renderBlockLayer(BlockRenderLayer layerToRender, double partialTicks, int pass, ICamera iCamera) {
for (int i = 0; i < 16; i++) {
IVSRenderChunk renderChunk = renderChunks[i];
if (renderChunk != null) {
AxisAlignedBB renderChunkBB = new AxisAlignedBB(chunk.x << 4, renderChunk.minY(), chunk.z << 4, (chunk.x << 4) + 15, renderChunk.maxY(), (chunk.z << 4) + 15);
Polygon polygon = new Polygon(renderChunkBB, toRender.getShipTransformationManager().getRenderTransform(), TransformType.SUBSPACE_TO_GLOBAL);
AxisAlignedBB inWorldBB = polygon.getEnclosedAABB();
// Only render chunks that can be shown by the camera.
if (iCamera.isBoundingBoxInFrustum(inWorldBB)) {
renderChunk.renderBlockLayer(layerToRender, partialTicks, pass);
}
}
}
}
public void piecewiseRenderSolid(boolean renderColliding, float partialTicks)
{
if (this.renderPiecewiseBlocks)
{
this.mc.profiler.startSection("litematica_blocks_solid");
if (renderColliding)
{
GlStateManager.enablePolygonOffset();
GlStateManager.doPolygonOffset(-0.3f, -0.6f);
}
this.startShaderIfEnabled();
this.getWorldRenderer().renderBlockLayer(BlockRenderLayer.SOLID, partialTicks, this.entity);
this.disableShader();
if (renderColliding)
{
GlStateManager.doPolygonOffset(0f, 0f);
GlStateManager.disablePolygonOffset();
}
this.mc.profiler.endSection();
}
}
public void renderBlockLayer(BlockRenderLayer layerToRender, double partialTicks, int pass, ICamera iCamera) {
if (renderChunks == null) {
renderChunks = new PhysRenderChunk[parent.getOwnedChunks().chunkLengthX()][parent
.getOwnedChunks()
.chunkLengthZ()];
for (int xChunk = 0; xChunk < parent.getOwnedChunks().chunkLengthX(); xChunk++) {
for (int zChunk = 0; zChunk < parent.getOwnedChunks().chunkLengthZ(); zChunk++) {
renderChunks[xChunk][zChunk] = new PhysRenderChunk(parent, parent
.getChunkAt(xChunk + parent.getOwnedChunks().minX(),
zChunk + parent.getOwnedChunks().minZ()));
}
}
}
GL11.glPushMatrix();
Minecraft.getMinecraft().entityRenderer.enableLightmap();
// int i = parent.wrapper.getBrightnessForRender((float) partialTicks);
// int j = i % 65536;
// int k = i / 65536;
// OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, (float)
// j, (float) k);
// GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
applyRenderTransform(partialTicks);
for (PhysRenderChunk[] chunkArray : renderChunks) {
for (PhysRenderChunk renderChunk : chunkArray) {
renderChunk.renderBlockLayer(layerToRender, partialTicks, pass, iCamera);
}
}
Minecraft.getMinecraft().entityRenderer.disableLightmap();
GL11.glPopMatrix();
}
public void piecewiseRenderCutout(boolean renderColliding, float partialTicks)
{
if (this.renderPiecewiseBlocks)
{
this.mc.profiler.startSection("litematica_blocks_cutout");
if (renderColliding)
{
GlStateManager.enablePolygonOffset();
GlStateManager.doPolygonOffset(-0.3f, -0.6f);
}
this.startShaderIfEnabled();
this.getWorldRenderer().renderBlockLayer(BlockRenderLayer.CUTOUT, partialTicks, this.entity);
this.disableShader();
if (renderColliding)
{
GlStateManager.doPolygonOffset(0f, 0f);
GlStateManager.disablePolygonOffset();
}
this.mc.profiler.endSection();
}
}
@Nonnull
@Override
public List<BakedQuad> getQuads(IBlockState state, EnumFacing side, long rand) {
final BlockRenderLayer layer = MinecraftForgeClient.getRenderLayer();
if (layer == null) { return side == null? quads : ImmutableList.<BakedQuad> of(); }
final IBakedModel model = models.get(layer);
return MoreObjects.firstNonNull(model, missing).getQuads(state, side, rand);
}
public static BlockRenderLayer onRenderBlockInLayer(
Block block, IBlockState state, BlockRenderLayer layer, BlockRenderLayer compareToLayer) {
if (HOOK_onRenderBlockInLayer.reportHook()) {
RenderBlockInLayerEvent event =
new RenderBlockInLayerEvent(block, state, layer, compareToLayer);
MinecraftForge.EVENT_BUS.post(event);
return event.getLayer();
} else {
return layer;
}
}
/*******************************************************************************
* 2. Rendering
*******************************************************************************/
@Override
@SideOnly(Side.CLIENT)
public BlockRenderLayer getBlockLayer()
{
return BlockRenderLayer.CUTOUT;
}
@SideOnly(Side.CLIENT)
public BlockRenderLayer getBlockLayer() {
return BlockRenderLayer.CUTOUT;
}
@Override
public BlockRenderLayer getBlockLayer() {
return BlockRenderLayer.CUTOUT;
}
@Invoker
void invokeSetLayerUsed(BlockRenderLayer layer);
@Override
public BlockRenderLayer getRenderLayer() {
return BlockRenderLayer.CUTOUT;
}
public BlockRenderLayer getLayer() {
return layer;
}
@Override
public BlockRenderLayer getRenderLayer()
{
return BlockRenderLayer.TRANSLUCENT;
}
@SideOnly(Side.CLIENT)
public BlockRenderLayer getBlockLayer()
{
return BlockRenderLayer.CUTOUT;
}
@Override
public BlockRenderLayer getBlockLayer() {
return BlockRenderLayer.CUTOUT_MIPPED;
}
@Override
@SideOnly(Side.CLIENT)
public BlockRenderLayer getBlockLayer()
{
return BlockRenderLayer.TRANSLUCENT;
}
@SideOnly(Side.CLIENT)
public BlockRenderLayer getBlockLayer() {
return BlockRenderLayer.CUTOUT;
}
@SideOnly(Side.CLIENT)
public BlockRenderLayer getBlockLayer()
{
return BlockRenderLayer.CUTOUT;
}
@SideOnly(Side.CLIENT)
public BlockRenderLayer getBlockLayer() {
return BlockRenderLayer.CUTOUT;
}