Examples with ChunkMeshBuilder me.jellysquid.mods.sodium.client.render.mesh.ChunkMeshBuilder used on opensource projects

Example 1 with ChunkMeshBuilder

use of me.jellysquid.mods.sodium.client.render.mesh.ChunkMeshBuilder in project sodium-fabric by CaffeineMC.

the class ChunkBlockRenderPipeline method renderQuad.

private void renderQuad(BlockRenderView world, BlockState state, BlockPos pos, VertexConsumer builder, Vector3f translation, ModelQuadView quad, float[] brightnesses, int[] lights) {
    int color = this.getQuadColor(quad, world, state, pos);
    float r, g, b;
    if (color != Integer.MIN_VALUE) {
        r = ColorUtil.normalize(ColorUtil.unpackColorR(color));
        g = ColorUtil.normalize(ColorUtil.unpackColorG(color));
        b = ColorUtil.normalize(ColorUtil.unpackColorB(color));
    } else {
        r = 1.0f;
        g = 1.0f;
        b = 1.0f;
    }
    ModelQuadOrder order = ModelQuadOrder.orderOf(brightnesses);
    ModelQuadViewMutable copy = this.cachedQuad;
    int norm = QuadUtil.getNormal(quad.getFacing());
    for (int i = 0; i < 4; i++) {
        int o = order.getVertexIndex(i);
        copy.setX(i, quad.getX(o) + translation.getX());
        copy.setY(i, quad.getY(o) + translation.getY());
        copy.setZ(i, quad.getZ(o) + translation.getZ());
        float br = brightnesses[o];
        if (color != Integer.MIN_VALUE) {
            copy.setColor(i, ColorUtil.mulPackedRGB(quad.getColor(o), r * br, g * br, b * br));
        } else {
            copy.setColor(i, ColorUtil.mulPacked(quad.getColor(o), br));
        }
        copy.setTexU(i, quad.getTexU(o));
        copy.setTexV(i, quad.getTexV(o));
        copy.setLight(i, lights[o]);
        copy.setNormal(i, norm);
    }
    ((ChunkMeshBuilder) builder).write(copy);
}

Example 2 with ChunkMeshBuilder

use of me.jellysquid.mods.sodium.client.render.mesh.ChunkMeshBuilder in project sodium-fabric by CaffeineMC.

the class MixinRebuildTask method render.

/**
 * @author JellySquid
 */
@Overwrite
private Set<BlockEntity> render(float cameraX, float cameraY, float cameraZ, ChunkBuilder.ChunkData data, BlockBufferBuilderStorage buffers) {
    ExtendedChunkData edata = (ExtendedChunkData) data;
    BlockPos from = this.parent.getOrigin().toImmutable();
    BlockPos to = from.add(15, 15, 15);
    ChunkOcclusionDataBuilder occlusion = new ChunkOcclusionDataBuilder();
    Set<BlockEntity> set = Sets.newHashSet();
    ChunkRendererRegion world = this.region;
    Vector3f translation = new Vector3f();
    if (world != null) {
        BlockRenderManager blockRenderManager = MinecraftClient.getInstance().getBlockRenderManager();
        int minX = from.getX();
        int minY = from.getY();
        int minZ = from.getZ();
        int maxX = to.getX();
        int maxY = to.getY();
        int maxZ = to.getZ();
        BlockPos.Mutable pos = new BlockPos.Mutable();
        for (int z = minZ; z <= maxZ; z++) {
            for (int y = minY; y <= maxY; y++) {
                for (int x = minX; x <= maxX; x++) {
                    pos.set(x, y, z);
                    BlockState blockState = world.getBlockState(pos);
                    FluidState fluidState = blockState.getFluidState();
                    Block block = blockState.getBlock();
                    if (blockState.isFullOpaque(world, pos)) {
                        occlusion.markClosed(pos);
                    }
                    if (block.hasBlockEntity()) {
                        BlockEntity entity = world.getBlockEntity(pos, WorldChunk.CreationType.CHECK);
                        if (entity != null) {
                            this.addBlockEntity(data, set, entity);
                        }
                    }
                    if (!fluidState.isEmpty()) {
                        RenderLayer layer = RenderLayers.getFluidLayer(fluidState);
                        BufferBuilder builder = buffers.get(layer);
                        if (!builder.isBuilding()) {
                            builder.begin(GL11.GL_QUADS, VertexFormats.POSITION_COLOR_TEXTURE_LIGHT_NORMAL);
                            edata.getInitializedLayers().add(layer);
                        }
                        blockRenderManager.renderFluid(pos, world, builder, fluidState);
                    }
                    if (blockState.getRenderType() != BlockRenderType.INVISIBLE) {
                        RenderLayer layer = RenderLayers.getBlockLayer(blockState);
                        BufferBuilder builder = buffers.get(layer);
                        if (!builder.isBuilding()) {
                            builder.begin(GL11.GL_QUADS, VertexFormats.POSITION_COLOR_TEXTURE_LIGHT_NORMAL);
                            edata.getInitializedLayers().add(layer);
                        }
                        translation.set(pos.getX() & 15, pos.getY() & 15, pos.getZ() & 15);
                        this.pipeline.renderBlock(blockState, pos, world, translation, builder, true);
                    }
                }
            }
        }
        for (RenderLayer layer : edata.getInitializedLayers()) {
            BufferBuilder builder = buffers.get(layer);
            if (layer == RenderLayer.getTranslucent()) {
                builder.sortQuads(cameraX - (float) from.getX(), cameraY - (float) from.getY(), cameraZ - (float) from.getZ());
                edata.setTranslucentBufferState(builder.popState());
            }
            builder.end();
            if (((ChunkMeshBuilder) builder).isEmpty()) {
                continue;
            }
            edata.getNonEmptyLayers().add(layer);
        }
        if (edata.getNonEmptyLayers().size() > 0) {
            edata.markNonEmpty();
        }
    }
    edata.setOcclusionData(occlusion.build());
    this.region = null;
    this.pipeline = null;
    return set;
}

Example 3 with ChunkMeshBuilder

use of me.jellysquid.mods.sodium.client.render.mesh.ChunkMeshBuilder in project sodium-fabric by CaffeineMC.

the class ChunkRenderRebuildTask method generateMesh.

private ChunkMeshInfo generateMesh(VertexBufferCache buffers) {
    ChunkMeshInfo info = new ChunkMeshInfo();
    ChunkOcclusionDataBuilder occlusionDataBuilder = new ChunkOcclusionDataBuilder();
    Vector3f translation = new Vector3f();
    BlockPos from = this.render.getOrigin();
    BlockPos to = from.add(16, 16, 16);
    int minX = from.getX();
    int minY = from.getY();
    int minZ = from.getZ();
    int maxX = to.getX();
    int maxY = to.getY();
    int maxZ = to.getZ();
    BlockPos.Mutable pos = new BlockPos.Mutable();
    for (int z = minZ; z < maxZ; z++) {
        for (int y = minY; y < maxY; y++) {
            for (int x = minX; x < maxX; x++) {
                pos.set(x, y, z);
                BlockState blockState = this.region.getBlockState(pos);
                FluidState fluidState = blockState.getFluidState();
                Block block = blockState.getBlock();
                if (blockState.isFullOpaque(this.region, pos)) {
                    occlusionDataBuilder.markClosed(pos);
                }
                if (block.hasBlockEntity()) {
                    BlockEntity entity = this.region.getBlockEntity(pos, WorldChunk.CreationType.CHECK);
                    if (entity != null) {
                        BlockEntityRenderer<BlockEntity> renderer = BlockEntityRenderDispatcher.INSTANCE.get(entity);
                        if (renderer != null) {
                            info.blockEntities.add(entity);
                            if (renderer.rendersOutsideBoundingBox(entity)) {
                                info.globalEntities.add(entity);
                            }
                        }
                    }
                }
                if (!fluidState.isEmpty()) {
                    RenderLayer layer = RenderLayers.getFluidLayer(fluidState);
                    BufferBuilder builder = buffers.get(layer);
                    if (!builder.isBuilding()) {
                        builder.begin(GL11.GL_QUADS, VertexFormats.POSITION_COLOR_TEXTURE_LIGHT_NORMAL);
                    }
                    this.fallbackPipeline.renderFluid(pos, this.region, builder, fluidState);
                }
                if (blockState.getRenderType() != BlockRenderType.INVISIBLE) {
                    RenderLayer layer = RenderLayers.getBlockLayer(blockState);
                    BufferBuilder builder = buffers.get(layer);
                    if (!builder.isBuilding()) {
                        builder.begin(GL11.GL_QUADS, VertexFormats.POSITION_COLOR_TEXTURE_LIGHT_NORMAL);
                    }
                    translation.set(pos.getX() & 15, pos.getY() & 15, pos.getZ() & 15);
                    this.pipeline.renderBlock(blockState, pos, this.region, translation, builder, true);
                }
            }
        }
    }
    BufferBuilder.State translucentBufferState = null;
    for (RenderLayer layer : RenderLayer.getBlockLayers()) {
        BufferBuilder builder = buffers.get(layer);
        if (!builder.isBuilding()) {
            continue;
        }
        if (((ChunkMeshBuilder) builder).isEmpty()) {
            continue;
        }
        if (layer == RenderLayer.getTranslucent()) {
            builder.sortQuads((float) this.camera.x - (float) from.getX(), (float) this.camera.y - (float) from.getY(), (float) this.camera.z - (float) from.getZ());
            translucentBufferState = builder.popState();
        }
        info.presentLayers.add(layer);
    }
    info.occlusionGraph = occlusionDataBuilder.build();
    info.translucentBufferState = translucentBufferState;
    return info;
}