RDFramebufferPass in Godot – Complete Guide

Welcome to our comprehensive tutorial on RDFramebufferPass in Godot 4! If you’re diving into advanced game development using the Godot engine, you’ll want to understand the intricate details of rendering and how you can optimize it for better performance and visual quality. RDFramebufferPass plays a crucial role in the rendering pipeline, particularly if you’re looking to fine-tune your game’s graphics, especially on mobile platforms. In this tutorial, you will learn not only the intricacies of RDFramebufferPass but also how to effectively use it in various scenarios, enhancing your development skills.

What is RDFramebufferPass?

RDFramebufferPass is a class in Godot 4 that enables developers to describe framebuffer pass attachments when using the RenderingDevice API. Framebuffers are essentially containers for textures or images that you render to, instead of rendering directly to the screen.

What is it for?

This class is particularly useful for configuring multiple rendering passes, an essential technique for achieving more complex rendering effects. By manipulating framebuffer passes, you can create advanced graphics features such as shadows, reflections, and post-processing effects that can take your game visuals to the next level.

Why Should I Learn It?

Understanding RDFramebufferPass is vital for any aspiring game developer working with Godot 4, especially if you aim to fully utilize the engine’s capabilities on different hardware. Notably, on mobile devices, multipass framebuffers can provide optimization benefits that can improve performance on less powerful hardware. So, mastering this will enable you to craft games that look great and run smoothly across various platforms.

CTA Small Image

Creating and Configuring a Framebuffer

Before jumping into RDFramebufferPass, let’s start by creating and configuring a basic framebuffer. In Godot 4, you use the RenderingDevice API to create a framebuffer, which serves as a target for rendering operations.

var rd = RenderingDevice
var texture_format = RenderingDevice.TextureFormat.new()
texture_format.format = RenderingDevice.DATA_FORMAT_R8G8B8A8_UNORM
var texture = rd.texture_create(texture_format, RenderingDevice.TEXTURE_TYPE_2D, RenderingDevice.TEXTURE_USAGE_RENDERTARGET)
var framebuffer = rd.framebuffer_create()
rd.framebuffer_texture_attach(framebuffer, texture, 0, RenderingDevice.TEXTURE_TYPE_2D)

In the above code, we initialize a new TextureFormat and set its `format` to `DATA_FORMAT_R8G8B8A8_UNORM`, which is a standard color format. Next, we create a texture with this format, which will be used as a render target. Finally, we create a framebuffer and attach the texture to it.

Defining RDFramebufferPass and Attaching Textures

With the framebuffer created, the next step is to define a RDFramebufferPass and attach textures to it. The RDFramebufferPass specifies what textures should be included when you’re rendering a pass.

var pass = RDFramebufferPass.new()

The above snippet showcases the creation of a new RDFramebufferPass object. We’re adding the previously created texture as a color attachment.

To better understand the significance of such setup, you can try rendering simple geometry using the pass:

// Assume geometry and shader code are already defined.
rd.draw(geometry, shader, transform, PASS_MODE_COLOR)

This example illustrates how you would use RDFramebufferPass to render geometry to the framebuffer with a color pass. Similar setups are used for depth and stencil passes.

Working with Multiple Attachments

In more complex scenes, you may need to handle multiple attachments. This can be useful for effects like bloom, where you might want to output multiple brightness levels.

// Create additional texture for bloom.
var bloom_texture = rd.texture_create(texture_format, RenderingDevice.TEXTURE_TYPE_2D, RenderingDevice.TEXTURE_USAGE_RENDERTARGET)
rd.framebuffer_texture_attach(framebuffer, bloom_texture, 1, RenderingDevice.TEXTURE_TYPE_2D)

// Add bloom texture to the pass.

With this setup, you can store additional information in another texture while rendering your scene, which will be useful for post-processing effects.

Advanced Pass Configurations

You can further customize your RDFramebufferPass by setting additional parameters, such as the clear mode or determining if a pass is readable or writable.

// Set the clear mode for the pass.

Here we have set the clear mode to `CLEAR_MODE_ONLY_NEXT_PASS`, which indicates that the framebuffer should only be cleared at the start of the next pass. This can be used to achieve specific visual effects or to improve performance.

// Configure the pass to be readable for later use.

// Configure the pass to be writable, so it can be the target of rendering commands.

These configurations are crucial for developing flexible and efficient rendering pipelines in your Godot 4 projects.

At this stage, you’ve learned how to set up and configure basic RDFramebufferPass objects in Godot 4. In the next part of our tutorial, we will delve deeper into advanced usage and optimization tips. Stay tuned to elevate your game development skills!As we dive deeper into utilizing RDFramebufferPass for advanced effects, it’s important to understand how to work with depth and stencil buffers, multipass rendering, and how we can optimize these processes.

Using Depth and Stencil Buffers

Depth and stencil buffers often accompany color attachments in a framebuffer to create depth testing and stencil testing effects. Here’s how you can create and attach a depth buffer:

// Create depth texture.
var depth_texture_format = RenderingDevice.TextureFormat.new()
depth_texture_format.format = RenderingDevice.DATA_FORMAT_D32_FLOAT
var depth_texture = rd.texture_create(depth_texture_format, RenderingDevice.TEXTURE_TYPE_2D, RenderingDevice.TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT)

// Attach depth texture to framebuffer.
rd.framebuffer_texture_attach(framebuffer, depth_texture, 0, RenderingDevice.TEXTURE_TYPE_2D, true)

An essential aspect of depth textures is that they’re not intended for color output. Instead, they store distance information relative to the viewer, which is crucial for accurately rendering 3D scenes and enabling depth testing.

Multipass Rendering and Framebuffer Switching

Multipass rendering involves several rendering passes, sometimes with different framebuffers, to achieve elaborate graphics effects. Below is an example of two-pass rendering with separate framebuffers for each pass:

// First pass.
// ... perform drawing operations

// Second pass - rendering to another framebuffer using textures from the first pass.
// Attach texture from first pass to the shader.
rd.draw_set_uniform(shader, "u_first_pass_texture", first_framebuffer_color_attachment)
// ... perform drawing operations

By rendering to multiple framebuffers, you can create complex visual effects, such as applying post-processing or blending textures from different rendering stages.

Optimizing with Render Target Flags

When creating textures for framebuffers, we can optimize them by specifying render target flags that indicate the intended usage:

// Create a texture that will be used for sampling in shaders and as a render target.
var sample_texture_format = RenderingDevice.TextureFormat.new()
sample_texture_format.usage_flags = RenderingDevice.TEXTURE_USAGE_TEXTURE_BIT | RenderingDevice.TEXTURE_USAGE_RENDERTARGET_BIT
var sample_texture = rd.texture_create(sample_texture_format, RenderingDevice.TEXTURE_TYPE_2D, RenderingDevice.TEXTURE_USAGE_RENDERTARGET)

This combination of flags indicates that the texture will be both sampled from shaders and used as a render target.

Offscreen Rendering and Readback

Sometimes, you may want to render something offscreen and read the pixels back for processing or saving. Let’s render offscreen and then read back the pixels:

// ... perform draw operations

// Read pixels from the framebuffer.
var image_data = rd.texture_get_data(texture)

After rendering, we retrieve the data from the framebuffer’s texture. This can be used for generating thumbnails, saving screenshots, or post-processing effects that require pixel manipulation.


Learning to work with RDFramebufferPasses and the RenderingDevice API opens up a myriad of possibilities for graphics programming in Godot 4. Whether you’re developing intricate visual effects or striving for maximum performance on all platforms, understanding these systems is key.

Keep exploring and experimenting with different rendering techniques, and remember, with great power comes great responsibility. Use these tools wisely to enhance your players’ experience without sacrificing performance. And as always, we’re here to guide you further on your game development journey with Zenva’s plethora of courses and tutorials.Continuing our exploration of RDFramebufferPass and advanced rendering techniques, let’s delve into more complex scenarios including handling transparency, blending modes, and multi-sampling for anti-aliasing.

Handling Transparency

To properly render transparent objects, we must ensure that our framebuffer configuration supports alpha blending. Here’s how you can enable blending:

// Set blend modes for the color attachment.
rd.framebuffer_color_blend_state_set(framebuffer, 0, true, RenderingDevice.BLEND_FACTOR_SRC_ALPHA, RenderingDevice.BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, RenderingDevice.BLEND_OP_ADD)

By setting the blend factors to `SRC_ALPHA` and `ONE_MINUS_SRC_ALPHA`, we’re able to blend transparent objects based on their alpha values.

Custom Blending for Special Effects

Custom blending modes can be used to create various visual effects such as additive blending for light effects, or subtractive blending for shadows.

// Additive blending for light glows.
rd.framebuffer_color_blend_state_set(framebuffer, 0, true, RenderingDevice.BLEND_FACTOR_ONE, RenderingDevice.BLEND_FACTOR_ONE, RenderingDevice.BLEND_OP_ADD)

// Subtractive blending for shadows.
rd.framebuffer_color_blend_state_set(framebuffer, 0, true, RenderingDevice.BLEND_FACTOR_ZERO, RenderingDevice.BLEND_FACTOR_ONE_MINUS_SRC_COLOR, RenderingDevice.BLEND_OP_SUBTRACT)

These blend state configurations alter the way colors are mixed in the framebuffer based on the blend factors and operations defined.

Multi-Sampling for Anti-Aliasing

Jagged edges can distract from a game’s visual appeal, but multi-sampling anti-aliasing (MSAA) can smooth them out. The RDFramebufferPass can be configured to handle multi-sampled textures effectively.

// Create a multi-sampled texture.
var msaa_texture_format = RenderingDevice.TextureFormat.new()
msaa_texture_format.texture_format_msaa = RenderingDevice.TEXTURE_MSAA_4X
var msaa_texture = rd.texture_create(msaa_texture_format, RenderingDevice.TEXTURE_TYPE_2D, RenderingDevice.TEXTURE_USAGE_RENDERTARGET_BIT)

// Attach the multi-sampled texture to the framebuffer.
rd.framebuffer_texture_attach(framebuffer, msaa_texture, 0, RenderingDevice.TEXTURE_TYPE_2D)

Here we create a texture with `TEXTURE_MSAA_4X`. This denotes 4x MSAA, which is generally a good balance between quality and performance.

Resolve Multi-Sampled Framebuffers

After rendering to a multi-sampled framebuffer, before it can be used or displayed, it must be resolved to a non-multi-sampled texture.

// Create a resolve texture, similar to normal textures but without MSAA.
var resolve_texture_format = RenderingDevice.TextureFormat.new()
var resolve_texture = rd.texture_create(resolve_texture_format, RenderingDevice.TEXTURE_TYPE_2D, RenderingDevice.TEXTURE_USAGE_RENDERTARGET_BIT)

// Resolve the multi-sampled texture to the non-multi-sampled resolve texture.
rd.texture_resolve_to(framebuffer, resolving_framebuffer, RenderingDevice.RESOLVE_MODE_AVERAGE, msaa_texture, resolve_texture)

The `texture_resolve_to` method averages the samples in a multi-sampled texture and writes the result to the resolve texture.

Rendering to Cubemaps for Environment Effects

For effects like dynamic reflections or skyboxes, rendering to cubemaps is essential. Here’s how you can set up a cubemap render target:

// Create a cubemap texture.
var cube_texture_format = RenderingDevice.TextureFormat.new()
var cube_texture = rd.texture_create(cube_texture_format, RenderingDevice.TEXTURE_TYPE_CUBE, RenderingDevice.TEXTURE_USAGE_RENDERTARGET_BIT)

// Set the current cubemap face to render to.
rd.framebuffer_cubemap_attach(framebuffer, cube_texture, 0, RenderingDevice.CUBEMAP_SIDE_NEGATIVE_X)

This code snippet initializes a cubemap texture and attaches one of its faces to the framebuffer as the current render target. You would typically loop through all cubemap sides and render the scene from the corresponding perspective.

Post-Processing with Framebuffer Shaders

Finally, after rendering a scene to a framebuffer, it’s common to apply post-processing effects through screen-space shaders.

// Perform post-processing.
rd.draw_set_uniform(shader, "u_scene_texture", color_attachment)
// ... set additional shader uniform values
rd.draw(fullscreen_quad_geometry, post_processing_shader, transform)

In the given code, we’re drawing a fullscreen quad and using a post-processing shader that takes the scene’s color attachment as input. This technique allows for the implementation of a wide range of effects from color grading and brightness adjustment to more complex effects like bloom or motion blur.

With this further understanding of RDFramebufferPass, accompanied by practical examples, you now have a robust toolkit for enhancing the visuals of your Godot 4 projects. Whether your focus is on achieving stunning graphics or maintaining performance, the principles covered here will be instrumental in developing professional-quality games.

Continuing Your Game Development Journey

Mastering RDFramebufferPass and the RenderingDevice API in Godot 4 is a fantastic achievement that’ll empower you to create visually stunning games. But, don’t stop there! We encourage you to continue your game development journey and dive even deeper into the powerful features of the Godot engine.

Our Godot Game Development Mini-Degree is the perfect next step. This comprehensive collection of courses will guide you through the process of building cross-platform games using the latest iteration of the Godot engine. Covering a range of topics from 2D and 3D game creation to scripting and user interface design, it’s suited for developers of all levels who wish to expand their skillset.

Plus, for a broader collection of resources, explore our full range of Godot courses. Whether you’re a budding game creator or looking to sharpen your skills, our curriculum is designed to propel you from beginner to professional, with plenty of hands-on projects and completion certificates along the way. Seize the moment and make your mark in the world of game development with Zenva Academy!


Delving into the complexities of RDFramebufferPass and RenderingDevice in Godot 4 marks a significant milestone in your journey as a game developer. With the skills and knowledge gained, you’re well on your way to unlocking the full potential of this powerful game engine. Remember, the tools and techniques covered here are just the beginning. There’s a whole world of advanced game development concepts waiting for you to explore and implement in your future projects.

As part of the Zenva family, we’re dedicated to supporting and nurturing your growth every step of the way. Continue to build on your foundation with our Godot Game Development Mini-Degree, and watch as your game ideas come to life with the finesse and sophistication of a seasoned developer. The path you’re carving in the industry starts with knowledge and is paved with creation—it’s time to let your creativity soar and redefine the boundaries of interactive entertainment!

Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.