RenderingServer in Godot – Complete Guide

Unlocking the Power of Rendering in Godot 4

When you’re ready to take your games from concept to reality, understanding rendering processes is key to bringing dynamic visuals to life. In the world of game development using Godot 4, the RenderingServer class stands as a cornerstone for customizing and optimizing the way your game looks to the player. Whether you’re new to the Godot environment or seeking to enhance your skill set, discovering the capabilities of the RenderingServer is a voyage toward unlocking the sheer visual potential of your games. Join us as we delve into the mechanics of Godot’s rendering backend, explore its uses, and learn why mastering it can set your games apart in a world full of pixels and polygons.

What is RenderingServer?

The RenderingServer class in Godot 4 is an extensive API that serves as the backbone for anything you see on the screen. It’s where all the magic of bringing your scenes and artistic visions to fruition happens behind the scenes. This server is what every game developer dreams of when looking for direct, low-level access to the graphics pipeline.

What is it for?

With the RenderingServer, developers have the flexibility to bypass the traditional scene hierarchy of Godot to draw their objects directly. This can be especially beneficial for projects where fine-tuned control over rendering is needed, or when the scene system becomes a bottleneck. From managing 3D worlds (scenarios) to handling 2D canvases, the RenderingServer provides a robust toolkit for complete control over every visible element in a game.

Why should I learn it?

By learning to utilize the RenderingServer, you’ll gain the capability to optimize the graphical performance of your Godot projects at a fundamental level. Advanced developers can tap into its power for significant performance gains, and even beginners can learn valuable skills for managing visuals more effectively. So if customizability and efficiency are what you crave in your rendering processes, the RenderingServer is your key to unlocking those doors.

CTA Small Image

Creating a Basic Rendering Scenario

Every rendered element in Godot exists within a “scenario,” which is akin to a stage where your 3D objects are placed and managed. To commence, we first need to create a scenario using the RenderingServer.

var scenario = RenderingServer.scenario_create()

With our scenario set up, we’re in position to start adding objects to this virtual stage.

Adding Objects to the Rendering Scenario

Let’s begin by constructing a mesh, a fundamental building block in 3D rendering:

var mesh_rid = RenderingServer.mesh_create()

We will then generate a material to apply to our mesh, giving it color and texture:

var material_rid = RenderingServer.material_create()
RenderingServer.mesh_surface_set_material(mesh_rid, 0, material_rid)

With our material ready, we proceed to create an instance of our mesh:

var instance = RenderingServer.instance_create()
RenderingServer.instance_set_base(instance, mesh_rid)

Next, it’s time to link our instance to the scenario we created earlier:

RenderingServer.instance_set_scenario(instance, scenario)

This positions our mesh within the 3D space of the scenario. But for it to be rendered, we need to set up the environment and lighting.

Setting Up the Environment for Rendering

For our scene to be visible, we must define the environmental lighting:

var environment_rid = RenderingServer.environment_create()
RenderingServer.environment_set_background(environment_rid, RenderingServer.ENV_BG_CLEAR_COLOR)
RenderingServer.environment_set_sky(environment_rid, sky_rid)

This code creates a clear background environment and binds a sky resource to it.

Then, we attach the environment to our scenario:

RenderingServer.scenario_set_environment(scenario, environment_rid)

Lighting Up the Scene

A scene without light is like a canvas without paint. Let’s add a directional light to illuminate our 3D objects:

var light_rid = RenderingServer.directional_light_create()
RenderingServer.light_set_color(light_rid, Color(1, 1, 1))
RenderingServer.light_set_energy(light_rid, 3.0)

After creating the light, we set its color and energy for the desired intensity:

var light_instance = RenderingServer.instance_create()
RenderingServer.instance_set_base(light_instance, light_rid)
RenderingServer.instance_set_scenario(light_instance, scenario)

This snippet assigns the light to an instance and then places it in our scenario.

By understanding these fundamental steps, we’re setting the stage for a well-lit, properly rendered scene in Godot 4. In the upcoming part, we’ll expand on our knowledge, delving into camera setup and advanced rendering techniques.

With the lighting in place, we now need to set up a camera so our scene can be viewed from a specific perspective. In Godot’s RenderingServer, a camera is also an instance that we position in our scenario:

var camera_rid = RenderingServer.camera_create()
RenderingServer.camera_set_perspective(camera_rid, 70.0, 0.1, 100.0)

This code snippet creates a new camera and sets its projection mode to perspective, along with its field of view and the near and far planes.

After defining the camera’s properties, it needs to be placed in the scenario to actually see the scene:

var camera_instance = RenderingServer.instance_create()
RenderingServer.instance_set_base(camera_instance, camera_rid)
RenderingServer.instance_set_scenario(camera_instance, scenario)

Now that we have our camera set up, let’s see how we can move it to look at the 3D objects from different angles. To move the camera, you alter its transformation matrix:

var transform = Transform()
transform.origin = Vector3(0, 2, 5) # Move it 2 units up and 5 back
RenderingServer.instance_set_transform(camera_instance, transform)

This snippet effectively positions the camera in our virtual space, but what if we want our scene to be more interactive? We can achieve this by updating the camera’s transformation in the game’s process loop:

func _process(delta):
    var transform = RenderingServer.instance_get_transform(camera_instance)
    transform.origin += Vector3(0, 0, -1 * delta) # This moves the camera forward
    RenderingServer.instance_set_transform(camera_instance, transform)

this code sample applies a continuous movement to the camera, simulating a forward motion within the scene.

Another key aspect of rendering is handling user inputs to interact with your scene. Let’s take a look at how one could rotate an object based on player input:

func _input(event):
    if event is InputEventMouseMotion:
        var instance_transform = RenderingServer.instance_get_transform(mesh_instance)
        instance_transform.basis.rotate(Vector3(0, 1, 0), event.relative.x * -0.005)
        RenderingServer.instance_set_transform(mesh_instance, instance_transform)

Here, we retrieve the mesh instance’s current transform, adjust it by applying rotation when the mouse moves, and then update the transform accordingly.

Finally, for modern game visuals, post-processing effects such as depth-of-field or glow can give your game an extra polish. They can be controlled via the RenderingServer as well:

var environment_rid = RenderingServer.environment_create()
RenderingServer.environment_set_dof_blur_far_enabled(environment_rid, true)
RenderingServer.environment_set_dof_blur_far_amount(environment_rid, 0.1)
RenderingServer.environment_set_glow_enabled(environment_rid, true)
RenderingServer.environment_set_glow_level(environment_rid, 1, true)

These lines enable depth-of-field blur for distant objects and activate glow effect at a specified intensity level.

Through these code examples, we see the depth of control that can be achieved with the RenderingServer in Godot 4. Whether you’re manipulating camera perspectives, handling user input, or applying advanced visual effects, a strong grasp of these techniques is invaluable for crafting a visually compelling game.

With our basic rendering setup in place, let’s explore advanced graphical features through further code examples using the RenderingServer.

Suppose we want to implement shadows to add depth to our scene. The process involves configuring the light instance to cast shadows:

RenderingServer.light_set_param(light_rid, RenderingServer.LIGHT_PARAM_SHADOW_ENABLED, true)

This line of code enables shadows for the light source, instantly adding realism to the objects within our scenario.

For scenes with fast-moving objects or dynamic lighting, we may need to update our light’s transform continuously. Here’s how you might handle light movement:

func _process(delta):
    var light_transform = RenderingServer.instance_get_transform(light_instance)
    light_transform.origin.x += delta
    RenderingServer.instance_set_transform(light_instance, light_transform)

This snippet will slowly move the light source along the X-axis, altering the shadows and highlights in real-time.

Animations are also a crucial part of modern game aesthetics. Animating a simple rotation for our mesh can make it much more engaging:

func _process(delta):
    var mesh_transform = RenderingServer.instance_get_transform(instance)
    mesh_transform.basis.rotate(Vector3(0, 1, 0), delta)
    RenderingServer.instance_set_transform(instance, mesh_transform)

This code applies a continuous rotation to the instance along the Y-axis, simulating an animation.

Real-time reflection is another feature that can enhance the visual fidelity of your scene. For objects like mirrors or shiny surfaces, you would set up a reflection probe:

var reflection_probe_rid = RenderingServer.reflection_probe_create()
RenderingServer.reflection_probe_set_extent(reflection_probe_rid, Vector3(2,2,2))
RenderingServer.instance_set_base(reflection_probe_instance, reflection_probe_rid)
RenderingServer.instance_set_scenario(reflection_probe_instance, scenario)

These commands configure a reflection probe instance within the scenario, defining the area it influences.

Visibility and render layers offer control over what is rendered and when. To set an object on a specific layer, use:

RenderingServer.instance_set_layer_mask(instance, 1 << 2) # Places the instance on the third layer

This assigns the object to the third layer, allowing for selective rendering based on the camera’s layer mask.

Environmental effects, like fog, can substantially alter the ambiance of a scene. Here’s how to create a fog effect within your environment:

RenderingServer.environment_set_fog_enabled(environment_rid, true)
RenderingServer.environment_set_fog_color(environment_rid, Color(0.5, 0.6, 0.7))
RenderingServer.environment_set_fog_depth_begin(environment_rid, 5)
RenderingServer.environment_set_fog_depth_end(environment_rid, 100)

These lines enable fog, set its color, and define how it fades with distance, beginning and ending at specific points.

For developers looking to push the boundaries of visual richness in their games, Godot 4 and the RenderingServer class provide the tools needed to craft a wealth of visual effects, from the basics of shadows and animation to complex features like real-time reflections and environmental effects. By mastering these elements, you’ll be able to imbue your games with a sense of depth and immersion that stands out in today’s visually-competitive gaming landscape.

Continuing Your Godot Engine Journey

Embarking on the path to mastering Godot 4 and its RenderingServer is a journey that can truly elevate your game development skills. We’ve only scratched the surface here, and there’s a whole universe of knowledge waiting for you to explore. To continue expanding your prowess in Godot 4, consider diving into our Godot Game Development Mini-Degree. This collection of comprehensive courses is specially crafted for both aspiring developers and those with some experience under their belts.

Our structured curriculum guides you through the essentials of game creation in the Godot 4 engine, from the ground up. You’ll gain practical skills in 2D and 3D game development, scripting with GDScript, and implementing various game mechanics like RPG, RTS, and survival systems. All the while, you’ll be building a suite of projects that will not only reinforce your knowledge but also populate your portfolio.

If you’re keen on broadening your expertise further, take a look at our wider array of Godot courses. Each one is designed to take you from beginner to professional, letting you learn at your own pace and earn certificates as you go. So why wait? Start your next chapter in game development with us at Zenva and unleash the full potential of your game-making imagination.


In the realm of game development, the command of your tools shapes the worlds you bring to life. With the power of Godot 4’s RenderingServer at your fingertips, your game’s canvas stretches wide, ready for the burst of creativity that only you can bring. Remember, every great game starts with knowledge, and your journey with Godot is bound to be as thrilling as the games you wish to create.

We at Zenva are excited to accompany you on this creative voyage. Whether you’re coding your first sprite or optimizing a fully-fledged 3D scene, our Godot Game Development Mini-Degree is the wind in your sails. Propel your skills, forge your path in game development, and let’s craft incredible gaming experiences together.

Python Blog Image

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