public void renderChunkLayer(BlockRenderLayer layer) { if (this.initialized) { for (RenderChunk renderchunk : this.renderChunks) { net.minecraft.client.renderer.vertex.VertexBuffer vertexbuffer = renderchunk.getVertexBufferByLayer(layer.ordinal()); GlStateManager.pushMatrix(); this.preRenderChunk(renderchunk); renderchunk.multModelviewMatrix(); vertexbuffer.bindBuffer(); this.setupArrayPointers(); vertexbuffer.drawArrays(7); GlStateManager.popMatrix(); } OpenGlHelper.glBindBuffer(OpenGlHelper.GL_ARRAY_BUFFER, 0); GlStateManager.resetColor(); this.renderChunks.clear(); } }
@Override public List<BakedQuad> getQuads(IBlockState state, EnumFacing side, long rand) { IBakedModel model; BlockRenderLayer layer = MinecraftForgeClient.getRenderLayer(); if(layer == null) { return quads.get(Optional.fromNullable(side)); } else if(!models.containsKey(Optional.of(layer))) { model = missing; } else { model = models.get(Optional.of(layer)); } // assumes that child model will handle this state properly. FIXME? return model.getQuads(state, side, rand); }
public RenderChunk(World p_i47120_1_, RenderGlobal p_i47120_2_, int p_i47120_3_) { for (int i = 0; i < this.mapEnumFacing.length; ++i) { this.mapEnumFacing[i] = new BlockPos.MutableBlockPos(); } this.world = p_i47120_1_; this.renderGlobal = p_i47120_2_; this.index = p_i47120_3_; if (OpenGlHelper.useVbo()) { for (int j = 0; j < BlockRenderLayer.values().length; ++j) { this.vertexBuffers[j] = new VertexBuffer(DefaultVertexFormats.BLOCK); } } }
private BlockRenderLayer fixBlockLayer(Block p_fixBlockLayer_1_, BlockRenderLayer p_fixBlockLayer_2_) { if (this.isMipmaps) { if (p_fixBlockLayer_2_ == BlockRenderLayer.CUTOUT) { if (p_fixBlockLayer_1_ instanceof BlockRedstoneWire) { return p_fixBlockLayer_2_; } if (p_fixBlockLayer_1_ instanceof BlockCactus) { return p_fixBlockLayer_2_; } return BlockRenderLayer.CUTOUT_MIPPED; } } else if (p_fixBlockLayer_2_ == BlockRenderLayer.CUTOUT_MIPPED) { return BlockRenderLayer.CUTOUT; } return p_fixBlockLayer_2_; }
public BlockRenderLayer parseBlockRenderLayer(String p_parseBlockRenderLayer_1_, BlockRenderLayer p_parseBlockRenderLayer_2_) { if (p_parseBlockRenderLayer_1_ == null) { return p_parseBlockRenderLayer_2_; } else { p_parseBlockRenderLayer_1_ = p_parseBlockRenderLayer_1_.toLowerCase().trim(); BlockRenderLayer[] ablockrenderlayer = BlockRenderLayer.values(); for (int i = 0; i < ablockrenderlayer.length; ++i) { BlockRenderLayer blockrenderlayer = ablockrenderlayer[i]; if (p_parseBlockRenderLayer_1_.equals(blockrenderlayer.name().toLowerCase())) { return blockrenderlayer; } } return p_parseBlockRenderLayer_2_; } }
public MultiLayerBakedModel(ImmutableMap<Optional<BlockRenderLayer>, IBakedModel> models, IBakedModel missing, ImmutableMap<TransformType, TRSRTransformation> cameraTransforms) { this.models = models; this.cameraTransforms = cameraTransforms; this.missing = missing; if(models.containsKey(Optional.absent())) { base = models.get(Optional.absent()); } else { base = missing; } ImmutableMap.Builder<Optional<EnumFacing>, ImmutableList<BakedQuad>> quadBuilder = ImmutableMap.builder(); quadBuilder.put(Optional.<EnumFacing>absent(), buildQuads(models, Optional.<EnumFacing>absent())); for(EnumFacing side: EnumFacing.values()) { quadBuilder.put(Optional.of(side), buildQuads(models, Optional.of(side))); } quads = quadBuilder.build(); }
public static void renderBlockModel(World world, BlockPos pos, IBlockState state) { VertexBuffer wr = Tessellator.getInstance().getBuffer(); wr.begin(GL11.GL_QUADS, DefaultVertexFormats.BLOCK); wr.setTranslation(-pos.getX(), -pos.getY(), -pos.getZ()); BlockRendererDispatcher blockrendererdispatcher = Minecraft.getMinecraft().getBlockRendererDispatcher(); BlockModelShapes modelShapes = blockrendererdispatcher.getBlockModelShapes(); IBakedModel ibakedmodel = modelShapes.getModelForState(state); Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.LOCATION_BLOCKS_TEXTURE); for(BlockRenderLayer layer : BlockRenderLayer.values()) { if(state.getBlock().canRenderInLayer(state, layer)) { ForgeHooksClient.setRenderLayer(layer); blockrendererdispatcher.getBlockModelRenderer().renderModel(world, ibakedmodel, state, pos, wr, true); } } ForgeHooksClient.setRenderLayer(null); wr.setTranslation(0, 0, 0); Tessellator.getInstance().draw(); }
public void resortTransparency(float x, float y, float z, ChunkCompileTaskGenerator generator) { CompiledChunk compiledchunk = generator.getCompiledChunk(); if (compiledchunk.getState() != null && !compiledchunk.isLayerEmpty(BlockRenderLayer.TRANSLUCENT)) { this.preRenderBlocks(generator.getRegionRenderCacheBuilder().getWorldRendererByLayer(BlockRenderLayer.TRANSLUCENT), this.position); generator.getRegionRenderCacheBuilder().getWorldRendererByLayer(BlockRenderLayer.TRANSLUCENT).setVertexState(compiledchunk.getState()); this.postRenderBlocks(BlockRenderLayer.TRANSLUCENT, x, y, z, generator.getRegionRenderCacheBuilder().getWorldRendererByLayer(BlockRenderLayer.TRANSLUCENT), compiledchunk); } }
public ListQuadsOverlay getListQuadsOverlay(BlockRenderLayer p_getListQuadsOverlay_1_) { ListQuadsOverlay listquadsoverlay = this.listsQuadsOverlay[p_getListQuadsOverlay_1_.ordinal()]; if (listquadsoverlay == null) { listquadsoverlay = new ListQuadsOverlay(); this.listsQuadsOverlay[p_getListQuadsOverlay_1_.ordinal()] = listquadsoverlay; } return listquadsoverlay; }
private static boolean isTranslucentBlock(ItemStack stack) { if (stack == null) { return false; } else { Item item = stack.getItem(); if (item == null) { return false; } else if (!(item instanceof ItemBlock)) { return false; } else { ItemBlock itemblock = (ItemBlock)item; Block block = itemblock.getBlock(); if (block == null) { return false; } else { BlockRenderLayer blockrenderlayer = block.getBlockLayer(); return blockrenderlayer == BlockRenderLayer.TRANSLUCENT; } } } }
public RegionRenderCacheBuilder() { this.worldRenderers[BlockRenderLayer.SOLID.ordinal()] = new VertexBuffer(2097152); this.worldRenderers[BlockRenderLayer.CUTOUT.ordinal()] = new VertexBuffer(131072); this.worldRenderers[BlockRenderLayer.CUTOUT_MIPPED.ordinal()] = new VertexBuffer(131072); this.worldRenderers[BlockRenderLayer.TRANSLUCENT.ordinal()] = new VertexBuffer(262144); }
public void renderChunkLayer(BlockRenderLayer layer) { if (this.initialized) { if (this.renderChunks.size() == 0) { return; } for (RenderChunk renderchunk : this.renderChunks) { ListedRenderChunk listedrenderchunk = (ListedRenderChunk)renderchunk; GlStateManager.pushMatrix(); this.preRenderChunk(renderchunk); GlStateManager.callList(listedrenderchunk.getDisplayList(layer, listedrenderchunk.getCompiledChunk())); GlStateManager.popMatrix(); } if (Config.isMultiTexture()) { GlStateManager.bindCurrentTexture(); } GlStateManager.resetColor(); this.renderChunks.clear(); } }
public void resortTransparency(float x, float y, float z, ChunkCompileTaskGenerator generator) { CompiledChunk compiledchunk = generator.getCompiledChunk(); if (compiledchunk.getState() != null && !compiledchunk.isLayerEmpty(BlockRenderLayer.TRANSLUCENT)) { net.minecraft.client.renderer.VertexBuffer vertexbuffer = generator.getRegionRenderCacheBuilder().getWorldRendererByLayer(BlockRenderLayer.TRANSLUCENT); this.preRenderBlocks(vertexbuffer, this.position); vertexbuffer.setVertexState(compiledchunk.getState()); this.postRenderBlocks(BlockRenderLayer.TRANSLUCENT, x, y, z, vertexbuffer, compiledchunk); } }
private void postRenderBlocks(BlockRenderLayer layer, float x, float y, float z, net.minecraft.client.renderer.VertexBuffer worldRendererIn, CompiledChunk compiledChunkIn) { if (layer == BlockRenderLayer.TRANSLUCENT && !compiledChunkIn.isLayerEmpty(layer)) { worldRendererIn.sortVertexData(x, y, z); compiledChunkIn.setState(worldRendererIn.getVertexState()); } worldRendererIn.finishDrawing(); }
public ListenableFuture<Object> uploadChunk(final BlockRenderLayer p_188245_1_, final VertexBuffer p_188245_2_, final RenderChunk p_188245_3_, final CompiledChunk p_188245_4_, final double p_188245_5_) { if (Minecraft.getMinecraft().isCallingFromMinecraftThread()) { if (OpenGlHelper.useVbo()) { this.uploadVertexBuffer(p_188245_2_, p_188245_3_.getVertexBufferByLayer(p_188245_1_.ordinal())); } else { this.uploadDisplayList(p_188245_2_, ((ListedRenderChunk)p_188245_3_).getDisplayList(p_188245_1_, p_188245_4_), p_188245_3_); } p_188245_2_.setTranslation(0.0D, 0.0D, 0.0D); return Futures.<Object>immediateFuture((Object)null); } else { ListenableFutureTask<Object> listenablefuturetask = ListenableFutureTask.<Object>create(new Runnable() { public void run() { ChunkRenderDispatcher.this.uploadChunk(p_188245_1_, p_188245_2_, p_188245_3_, p_188245_4_, p_188245_5_); } }, (Object)null); synchronized (this.queueChunkUploads) { this.queueChunkUploads.add(new ChunkRenderDispatcher.PendingUpload(listenablefuturetask, p_188245_5_)); return listenablefuturetask; } } }
public void setBlockLayer(BlockRenderLayer p_setBlockLayer_1_) { this.blockLayer = p_setBlockLayer_1_; if (p_setBlockLayer_1_ == null) { if (this.quadSprites != null) { this.quadSpritesPrev = this.quadSprites; } this.quadSprites = null; this.quadSprite = null; } }
@SideOnly(Side.CLIENT) public BlockRenderLayer getBlockLayer() { return BlockRenderLayer.CUTOUT; }
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; } }
public VertexBuffer getWorldRendererByLayer(BlockRenderLayer layer) { return this.worldRenderers[layer.ordinal()]; }
@Override public BlockRenderLayer getBlockLayer() { return BlockRenderLayer.CUTOUT_MIPPED; }
@SideOnly(Side.CLIENT) public BlockRenderLayer getBlockLayer() { return BlockRenderLayer.TRANSLUCENT; }
public BlockRenderLayer getBlockLayer() { return BlockRenderLayer.CUTOUT; }
@SideOnly(Side.CLIENT) public BlockRenderLayer getBlockLayer() { return BlockRenderLayer.CUTOUT_MIPPED; }
@Override public boolean canRenderInLayer(IBlockState state, BlockRenderLayer layer) { return BlockRenderLayer.CUTOUT == layer; }
@Override public boolean canRenderInLayer(IBlockState state, BlockRenderLayer layer) { return layer == BlockRenderLayer.SOLID; }
@Override public boolean canRenderInLayer(IBlockState state, BlockRenderLayer layer) { return false; }
public boolean isLayerStarted(BlockRenderLayer layer) { return this.layersStarted[layer.ordinal()]; }
@Override @SideOnly(Side.CLIENT) public BlockRenderLayer getBlockLayer() { return BlockRenderLayer.CUTOUT; }
@Override @SideOnly(Side.CLIENT) public BlockRenderLayer getBlockLayer() { return BlockRenderLayer.CUTOUT_MIPPED; }
public BlockRenderLayer getBlockLayer() { return BlockRenderLayer.SOLID; }