1.21.5 BufferRenderer is completely gone?

[bdev42]

Description

RenderSystem.setShader as well as the entire BufferRenderer class seems to have been removed, but it is not mentioned in the 1.21.5 blog as far as I can tell?

Do we have to use RenderLayers as the alternative? If so how?
Can they be used to render the BuiltBuffer I currently would have done using the BufferRenderer.drawWithGlobalProgram method?

I cannot seem to find any examples or documentation regarding this, any help would be much appreciated.

[Zpiboo]

It seems that we now need to use RenderLayer.draw(BuiltBuffer). Thus, we need to select a RenderLayer that matches what we want to render. They use a RenderPipeline, where the shader is specified. For example, the RenderLayer.SOLID layer uses the core/terrain shader through the RenderPipelines.SOLID pipeline. If you wanted to render something on the SOLID layer, you would do something like this:

RenderLayer.getSolid().draw(yourBuiltBuffer);

You might as well create your own layer using RenderLayer.of.

I am new modding, I might not be entirely correct.

[MukjepScarlet]

3d rendering can work just fine as long as you render to another texture first. Mc uses SpecialGuiElementRenderer to do this

RenderPass -> a GpuTexture -> drawTexture, somehow like draw blit?

The problem has been solved. All you need to do is replace the "gpuTextureView" object inside the "renderlayer.draw()" method with the newly created texture, and then let the "Drawcontext" draw the "gpuTextureView".

Could you please show some example code about this? I'm not sure about the detail of this way.

[Bais-dynavla]

3d rendering can work just fine as long as you render to another texture first. Mc uses SpecialGuiElementRenderer to do this

RenderPass -> a GpuTexture -> drawTexture, somehow like draw blit?

The problem has been solved. All you need to do is replace the "gpuTextureView" object inside the "renderlayer.draw()" method with the newly created texture, and then let the "Drawcontext" draw the "gpuTextureView".

Could you please show some example code about this? I'm not sure about the detail of this way.

Execute "renderLayer.draw(buff.end());"

 public void draw(BuiltBuffer buffer) {
            this.startDrawing();
            GpuBufferSlice gpuBufferSlice = RenderSystem.getDynamicUniforms().write(RenderSystem.getModelViewMatrix(), new Vector4f(1.0F, 1.0F, 1.0F, 1.0F), new Vector3f(), RenderSystem.getTextureMatrix(), RenderSystem.getShaderLineWidth());
            BuiltBuffer var3 = buffer;

            try {
                GpuBuffer gpuBuffer = this.pipeline.getVertexFormat().uploadImmediateVertexBuffer(buffer.getBuffer());
                GpuBuffer gpuBuffer2;
                VertexFormat.IndexType indexType;
                if (buffer.getSortedBuffer() == null) {
                    RenderSystem.ShapeIndexBuffer shapeIndexBuffer = RenderSystem.getSequentialBuffer(buffer.getDrawParameters().mode());
                    gpuBuffer2 = shapeIndexBuffer.getIndexBuffer(buffer.getDrawParameters().indexCount());
                    indexType = shapeIndexBuffer.getIndexType();
                } else {
                    gpuBuffer2 = this.pipeline.getVertexFormat().uploadImmediateIndexBuffer(buffer.getSortedBuffer());
                    indexType = buffer.getDrawParameters().indexType();
                }

                Framebuffer framebuffer = this.phases.target.get();
                GpuTextureView gpuTextureView = RenderSystem.outputColorTextureOverride != null ? RenderSystem.outputColorTextureOverride : framebuffer.getColorAttachmentView();
                GpuTextureView gpuTextureView2 = framebuffer.useDepthAttachment ? (RenderSystem.outputDepthTextureOverride != null ? RenderSystem.outputDepthTextureOverride : framebuffer.getDepthAttachmentView()) : null;
                RenderPass renderPass = RenderSystem.getDevice().createCommandEncoder().createRenderPass(() -> {
                    return "Immediate draw for " + this.getName();
                }, gpuTextureView, OptionalInt.empty(), gpuTextureView2, OptionalDouble.empty());

                try {
                    renderPass.setPipeline(this.pipeline);
                    ScissorState scissorState = RenderSystem.getScissorStateForRenderTypeDraws();
                    if (scissorState.isEnabled()) {
                        renderPass.enableScissor(scissorState.getX(), scissorState.getY(), scissorState.getWidth(), scissorState.getHeight());
                    }

                    RenderSystem.bindDefaultUniforms(renderPass);
                    renderPass.setUniform("DynamicTransforms", gpuBufferSlice);
                    renderPass.setVertexBuffer(0, gpuBuffer);

                    for(int i = 0; i < 12; ++i) {
                        GpuTextureView gpuTextureView3 = RenderSystem.getShaderTexture(i);
                        if (gpuTextureView3 != null) {
                            renderPass.bindSampler("Sampler" + i, gpuTextureView3);
                        }
                    }

                    renderPass.setIndexBuffer(gpuBuffer2, indexType);
                    renderPass.drawIndexed(0, 0, buffer.getDrawParameters().indexCount(), 1);
                } catch (Throwable var16) {
                    if (renderPass != null) {
                        try {
                            renderPass.close();
                        } catch (Throwable var15) {
                            var16.addSuppressed(var15);
                        }
                    }

                    throw var16;
                }

                if (renderPass != null) {
                    renderPass.close();
                }
            } catch (Throwable var17) {
                if (buffer != null) {
                    try {
                        var3.close();
                    } catch (Throwable var14) {
                        var17.addSuppressed(var14);
                    }
                }

                throw var17;
            }

            if (buffer != null) {
                buffer.close();
            }

            this.endDrawing();
        }

Copy it to your code and replace it
GpuTextureView gpuTextureView = RenderSystem.outputColorTextureOverride != null ? RenderSystem.outputColorTextureOverride : framebuffer.getColorAttachmentView();
//replace
GpuTextureView gpuTextureView = Create your gpuTextureView

Finally, use Drawcontext to draw.

Execute "Drawcontext .class"

  private void drawTexturedQuad(RenderPipeline pipeline, GpuTextureView texture, int x1, int y1, int x2, int y2, float u1, float u2, float v1, float v2, int color) {
        this.state.addSimpleElement(new TexturedQuadGuiElementRenderState(pipeline, TextureSetup.withoutGlTexture(texture), new Matrix3x2f(this.matrices), x1, y1, x2, y2, u1, u2, v1, v2, color, this.scissorStack.peekLast()));
    }

[cputnam-a11y]

Note that drawing during extraction is planned to break in future versions

[Bais-dynavla]

3d rendering can work just fine as long as you render to another texture first. Mc uses SpecialGuiElementRenderer to do this

RenderPass -> a GpuTexture -> drawTexture, somehow like draw blit?

The problem has been solved. All you need to do is replace the "gpuTextureView" object inside the "renderlayer.draw()" method with the newly created texture, and then let the "Drawcontext" draw the "gpuTextureView".

Could you please show some example code about this? I'm not sure about the detail of this way.

The overall structure should be:

@mixin (ingamehud.class or drawcontext.class)
@Inject (method = **********)
public void render() {
  getBlockVertex() // color, vertexv, uv
 //It is necessary to use "renderlayer.draw(buff.end)" to check if the drawing was successful, and to keep it within your field of vision.

BufferBuilder buff = Tessellator.getInstance().begin();

for(){
buff.vertex().texture().uv().**********
}

buff.end()

`Execute "renderLayer.draw(buff.end());" `
//replace gpuTextureView

drawTexturedQuad()

}

[Bais-dynavla]

Note that drawing during extraction is planned to break in future versions

Thanks for the heads-up!

[bdev42]

Thanks for the tip!
My mod uses DEBUG_LINES which did not get a built-in RenderLayer by the looks of it, so i made the custom layer like you suggested.

For the other people who might run into the same issue, here are the changes I made to make it work for me:

First, I made a RenderPipeline for debug lines:

public static final RenderPipeline DEBUG_LINES = RenderPipelines.register(
        RenderPipeline.builder(RenderPipelines.POSITION_COLOR_SNIPPET)
                .withLocation("pipeline/debug_lines")
                .withVertexFormat(VertexFormats.POSITION_COLOR, VertexFormat.DrawMode.DEBUG_LINES)
                .withCull(true)
                .withoutBlend()
                .withDepthTestFunction(DepthTestFunction.LEQUAL_DEPTH_TEST)
                .build()
);

This part now also includes the vertex format (but in reverse order from tesselator.begin):

Tessellator tess = Tessellator.getInstance();
BufferBuilder buff = tess.begin(VertexFormat.DrawMode.DEBUG_LINES, VertexFormats.POSITION_COLOR);

The rest of the options mostly correspond to the settings we used to set up via the RenderSystem:

RenderSystem.setShader(ShaderProgramKeys.POSITION_COLOR); // snippets
RenderSystem.disableBlend(); // .withoutBlend()
RenderSystem.enableDepthTest() // .withDepthTestFunction(...)

Second, I made a custom RenderLayer like you suggested:

private static final RenderLayer renderLayer = RenderLayer.of(
        "debug_lines",
        1536, // Not sure how this should be calculated (i used the same as the other built-in render layers.
        DEBUG_LINES,
        RenderLayer.MultiPhaseParameters.builder().lineWidth(new RenderPhase.LineWidth(OptionalDouble.of(1))).build(false)
);

Finally, instead of BufferRenderer i draw the BuildBuffer with the custom RenderLayer:

- BufferRenderer.drawWithGlobalProgram(builtBuff);
+ renderLayer.draw(builtBuff);

[Bais-dynavla]

How to use RenderLayer correctly?

@Mixin(value = InGameHud.class)
public class Test {
    @Inject(method = "render", at = @At(value = "RETURN"))
    private void onRender(DrawContext context, RenderTickCounter tickCounter, CallbackInfo ci) {
        Matrix3x2fStack matrices = context.getMatrices();
        matrices.pushMatrix();
        GlStateManager._enableBlend();
        GlStateManager._disableDepthTest();
        Tessellator tess = Tessellator.getInstance();
        BufferBuilder buff = tess.begin(ExampleModClient.renderLayer.getDrawMode(), ExampleModClient.renderLayer.getVertexFormat());
        int rgb = Color.RED.getRGB();
        buff.vertex(matrices, 0, 0).color(rgb);
        buff.vertex(matrices,1000, 1000).color(rgb);
        ExampleModClient.renderLayer.draw(buff.end());
        GlStateManager._enableDepthTest();
        GlStateManager._disableBlend();
        matrices.popMatrix();
    }
}
    public static final RenderPipeline DEBUG_LINES = RenderPipelines.register(
            RenderPipeline.builder(RenderPipelines.POSITION_COLOR_SNIPPET)
                    .withLocation("pipeline/debug_lines")
                    .withVertexFormat(VertexFormats.POSITION_COLOR, VertexFormat.DrawMode.DEBUG_LINES)
                    .withCull(false)
                    .build()
    );
    public static final RenderLayer renderLayer = RenderLayer.of(
            "debug_lines",
            1536, 
            DEBUG_LINES,
            RenderLayer.MultiPhaseParameters.builder().lineWidth(new RenderPhase.LineWidth(OptionalDouble.of(1))).build(false)
    );

[MukjepScarlet]

You can copy the code from RenderLayer.MultiPhase.draw(BuiltBuffer), following code is it in 1.21.5:

public void draw(BuiltBuffer buffer) {
    RenderPipeline renderPipeline = this.getPipeline();
    this.startDrawing();
    BuiltBuffer var3 = buffer;

    try {
        GpuBuffer gpuBuffer = renderPipeline.getVertexFormat().uploadImmediateVertexBuffer(buffer.getBuffer());
        GpuBuffer gpuBuffer2;
        VertexFormat.IndexType indexType;
        if (buffer.getSortedBuffer() == null) {
            RenderSystem.ShapeIndexBuffer shapeIndexBuffer = RenderSystem.getSequentialBuffer(buffer.getDrawParameters().mode());
            gpuBuffer2 = shapeIndexBuffer.getIndexBuffer(buffer.getDrawParameters().indexCount());
            indexType = shapeIndexBuffer.getIndexType();
        } else {
            gpuBuffer2 = renderPipeline.getVertexFormat().uploadImmediateIndexBuffer(buffer.getSortedBuffer());
            indexType = buffer.getDrawParameters().indexType();
        }

        Framebuffer framebuffer = this.phases.target.get();

        try (RenderPass renderPass = RenderSystem.getDevice().createCommandEncoder().createRenderPass(framebuffer.getColorAttachment(), OptionalInt.empty(), framebuffer.useDepthAttachment ? framebuffer.getDepthAttachment() : null, OptionalDouble.empty())) {
            renderPass.setPipeline(renderPipeline);
            renderPass.setVertexBuffer(0, gpuBuffer);
            if (RenderSystem.SCISSOR_STATE.isEnabled()) {
                renderPass.enableScissor(RenderSystem.SCISSOR_STATE);
            }

            for(int i = 0; i < 12; ++i) {
                GpuTexture gpuTexture = RenderSystem.getShaderTexture(i);
                if (gpuTexture != null) {
                    renderPass.bindSampler("Sampler" + i, gpuTexture);
                }
            }

            renderPass.setIndexBuffer(gpuBuffer2, indexType);
            renderPass.drawIndexed(0, buffer.getDrawParameters().indexCount());
        }
    } catch (Throwable var14) {
        if (buffer != null) {
            try {
                var3.close();
            } catch (Throwable var11) {
                var14.addSuppressed(var11);
            }
        }

        throw var14;
    }

    if (buffer != null) {
        buffer.close();
    }

    this.endDrawing();
}

Basically you can change this to: draw(BuiltBuffer, RenderPipeline, Framebuffer). The pipeline contains old ShaderProgramKey and other render parameter stuffs.

This function contains complex logic, you can skip many phases (e.g. index buffer) in custom render.

[Bais-dynavla]

Thank you for your suggestion. I have already fixed most of the bugs.