Lightmapper in Godot – Complete Guide

Diving into the world of 3D game development, you quickly realize the importance of lighting in creating immersive environments. Whether you’re a beginner developer or an experienced coder looking to refine your skill set, understanding how lighting works is crucial. In Godot 4, a popular open-source game engine, lighting can be a complex topic, but it’s made more accessible through the Lightmapper class, which we will explore in this tutorial.

What is Lightmapper?

What Is Lightmapper?

The Lightmapper class in Godot 4 serves as an abstraction for creating custom lightmappers. Lightmappers are essential tools for achieving fast and realistic global illumination in 3D scenes. Essentially, they calculate how light bounces around in a scene and bakes this into textures, allowing for high-quality lighting without the heavy performance cost of real-time computations.

What is Lightmapper Used For?

Lightmapping is used to elevate the visual quality of a game by providing fast baked global illumination. This method of pre-computing the lighting of a scene is especially useful for static or semi-static environments where the lighting doesn’t change dynamically, like in architectural visualizations or platform games.

Why Should I Learn About Lightmapping?

Understanding lightmapping is pivotal for optimizing your games and creating visually striking experiences. It helps you create more performant games that can run smoothly on various devices, as the expensive calculations are done in advance. By mastering this skill, you also open doors to creating more atmospheric and dynamic virtual worlds, enhancing the overall player experience.

CTA Small Image
FREE COURSES AT ZENVA
LEARN GAME DEVELOPMENT, PYTHON AND MORE
ACCESS FOR FREE
AVAILABLE FOR A LIMITED TIME ONLY

Setting Up Your Scene for Lightmapping

To begin with lightmapping in Godot 4, you first need to ensure your scene is set up properly. This setup includes configuring your 3D models and materials for lightmapping as well as adding a LightmapGI node to your scene tree.

var lightmap_gi = LightmapGI.new()
get_tree().get_root().add_child(lightmap_gi)
lightmap_gi.bake()

In the snippet above, we create a new LightmapGI node, add it to the root of the scene tree, and initiate the bake process. This process computes the lightmaps based on the current settings and geometry.

Adjusting Lightmap Settings

Lightmapper settings in Godot can be fine-tuned to achieve the desired balance between performance and visual fidelity. Here are a few examples of how you can adjust these settings:

lightmap_gi.energy = 0.8
lightmap_gi.bounces = 3
lightmap_gi.bias = 0.01
lightmap_gi.interior = true

The ‘energy’ property affects the overall intensity of the lightmap. ‘Bounces’ control how many times light reflects within the scene, and ‘bias’ helps in reducing shadow acne. The ‘interior’ flag tells the Lightmapper whether it’s dealing with an indoor scene.

Configuring Light for Baking

Your scene’s light sources will need to be configured to participate in the lightmapping process. Here’s how to set up a directional light for baking:

var dir_light = DirectionalLight.new()
dir_light.direction = Vector3(0, -1, 0)
dir_light.lightmap_capture = true
get_tree().get_root().add_child(dir_light)

We create a new DirectionalLight node and set its direction down the Y-axis. The ‘lightmap_capture’ property ensures that this light contributes to the lightmap.

Baking Lightmaps

Once your scene and lights are properly set up, you can proceed to bake the lightmaps. This step is crucial to capture the pre-calculated lighting into textures. The code below triggers the baking process:

lightmap_gi.bake()

Depending on the complexity of the scene, the baking process can take anywhere from a few seconds to several minutes. Patience is key as the process completes.

Inspecting Baked Lightmaps

After baking, you’ll want to inspect the lightmaps to ensure your scene’s lighting looks as expected. In Godot 4, you can examine the created lightmaps by selecting the meshes and looking at their material settings:

var mesh_instance = $MeshInstance
print(mesh_instance.material_override.lightmap_texture)

This snippet will print out the texture resource associated with the lightmap, where ‘$MeshInstance’ is a placeholder for the actual path to your mesh instance node.

By following these examples, you’ve laid the groundwork for implementing lightmapping in your Godot 4 project, which is critical for achieving realistic lighting with a focus on performance.

After baking the lightmaps and inspecting the results, you’ll often need to go back and make adjustments. Sometimes, you may want to apply different effects, such as adding ambient occlusion or tweaking the lightmap resolution. Let’s dive into how we can fine-tune the lightmapping for optimal results.

Adjusting Lightmap Resolution

To control the quality and detail of the baked lightmaps, you need to adjust the resolution. Higher resolutions offer more detail but increase bake times and memory usage. Here’s how to set the lightmap resolution for a mesh:

var mesh_instance = $MeshInstance
mesh_instance.lightmap_scale = 4.0

In the code above, a higher ‘lightmap_scale’ value will reduce the resolution, whereas a lower value will increase it. The default value is typically 1.0.

Applying Ambient Occlusion

Ambient occlusion adds realism by darkening creases, holes, and surfaces that are close to each other. It simulates the soft shadows that occur in those areas. To enable ambient occlusion in your lightmap bake:

lightmap_gi.ao = true
lightmap_gi.ao_quality = 1.0

Setting the ‘ao’ property to true turns on ambient occlusion, and ‘ao_quality’ determines the fidelity of the occlusion effect.

Adding an Infinite Grid (GIProbe)

If your scene has a large open environment, an infinite grid can be beneficial. This is commonly used with GIProbe nodes to ensure lighting is consistent to the horizon. Here’s how to add an infinite grid:

var gi_probe = GIProbe.new()
gi_probe.create_infinite_grid = true
get_tree().get_root().add_child(gi_probe)

By setting ‘create_infinite_grid’ to true, you effectively make the GIProbe’s effects endless, which is perfect for outdoor scenes.

Lightmap Post-Processing

After baking, you may want to apply post-processing effects to the lightmaps for various aesthetic reasons. For instance, increasing contrast or brightness:

var image = Image.new()
var texture = lightmap_gi.lightmap_capture_texture
image = texture.get_data()
image.adjust_brightness(1.2)
image.adjust_contrast(1.1)
lightmap_gi.lightmap_capture_texture.set_data(image)

This code alters the brightness and contrast of your baked lightmap. ‘adjust_brightness’ and ‘adjust_contrast’ are applied to the Image object containing your lightmap’s data.

Saving and Reusing Lightmaps

Sometimes, you may want to save lightmaps for reuse or editing outside Godot. Here’s how you would save a baked lightmap texture to a file:

var image = lightmap_gi.lightmap_capture_texture.get_data()
image.save_png("res://lightmaps/mesh_lightmap.png")

In this code, we access the lightmap’s image data and use the ‘save_png’ method to write it to a PNG file in your project’s ‘lightmaps’ directory.

With these code snippets, you now have several advanced techniques for tweaking lightmaps in your Godot 4 games. These adjustments help in refining the visual quality of your scenes to suit your game’s specific look and atmosphere. At Zenva, we encourage you to experiment with these settings to see firsthand how they affect your game’s lighting and to discover a setup that works best for you.

Remember that lighting can be one of the most impactful elements of your game’s environment, both aesthetically and in terms of performance. A well-lit scene can be the difference between an average gaming experience and a truly memorable one. Whether you’re building a small indie game or a large-scale virtual world, the knowledge of lightmapping in Godot 4 is a valuable tool in your game development toolkit.

Understanding the nuances of lightmapping in Godot 4 can further enhance your scenes. Here are additional code examples and information to help you dive deeper into advanced lightmapping techniques:

Let’s say you want to adjust the indirect light color in your scene. You can do this by setting the ‘indirect_energy’ property on the LightmapGI node, allowing you to add a tint to the bounced light, which can dramatically change the mood of the scene:

lightmap_gi.indirect_energy = Color(1.0, 0.9, 0.8)

This would give the indirect light a warm hue, simulating a sunset or golden hour lighting.

If you’re dealing with both interior and exterior lighting in a single scene, you can create multiple LightmapGI nodes and configure each one for the specific environmental conditions:

var interior_lightmap_gi = LightmapGI.new()
var exterior_lightmap_gi = LightmapGI.new()

interior_lightmap_gi.interior = true
exterior_lightmap_gi.interior = false

get_tree().get_root().add_child(interior_lightmap_gi)
get_tree().get_root().add_child(exterior_lightmap_gi)

With this setup, you can bake lightmaps for the interior and exterior separately, optimizing light diffusion and bounce for each zone more appropriately.

To exclude certain objects from lightmapping, which can be useful for dynamic objects or those that you plan to light differently, you can turn off lightmapping for individual MeshInstances like so:

var dynamic_mesh_instance = $DynamicMeshInstance
dynamic_mesh_instance.use_in_baked_light = false

This line sets ‘use_in_baked_light’ to false, and thus the lightmapper will ignore this mesh during the baking process.

Lightmaps can sometimes exhibit issues on the seams of UVs. To help mitigate this, you can set the ‘lightmap_unwrap_margin’ property when unwrapping your meshes, like this:

mesh.lightmap_unwrap_margin = 4

Increasing this margin helps in reducing light bleeding on the edges of UV maps by providing more space between unwrapped islands.

Finally, to automate the process of baking lightmaps for multiple levels or different variations of a scene, you can script the baking process using a for loop:

var levels = ["Level1", "Level2", "Level3"]

for level in levels:
    var scene = load("res://scenes/" + level + ".tscn").instance()
    get_tree().get_root().add_child(scene)
    scene.get_node("LightmapGI").bake()
    scene.queue_free()

This script would load each level, add it to the root, find the LightmapGI node, bake the lightmap, and then remove the level from the tree.

With these examples and tips, you now have a broad set of tools to effectively use lightmapping to its full potential in Godot 4. We at Zenva understand that learning to implement advanced lighting techniques like lightmapping can initially appear daunting. Still, with practice, you’ll find it can vastly improve the quality and performance of your 3D scenes.

Effective lightmapping not only enhances the visual appeal of your games but also improves the gaming experience by enabling your creations to run smoothly across different devices. We encourage you to experiment with these techniques to find the perfect lighting setup for your projects. Happy baking!

Where to Go Next in Your Godot 4 Journey

Congratulations on deepening your understanding of lightmapping in Godot 4! But don’t let your journey end here. To truly master the art of game development, continued learning and practice are key. At Zenva, we’ve curated the perfect resource to help you progress – our Godot Game Development Mini-Degree. This series of comprehensive courses will guide you through the process of building cross-platform games, covering a wide array of essential topics tailored for both novices and seasoned developers.

The Godot 4 Game Development Mini-Degree is designed to give you hands-on experience with the Godot 4 engine. It encompasses rich course content ranging from 2D and 3D asset management, to scriptwriting in GDScript, to the intricacies of gameplay control flow and much more. With Godot’s supportive community and our step-by-step guidance, you’ll have everything you need to transform your ideas into fully-fledged games.

For those wanting to explore our broader collection of Godot tutorials, check out all of our Godot courses for a full spectrum of learning opportunities. With flexible online access and completion certificates to showcase your achievements, Zenva makes it easy to fit learning into your schedule and take your skills from beginner to professional. Keep creating, keep learning, and most importantly, have fun on your game development journey!

Conclusion

Embarking on the adventure of mastering lighting in Godot 4 through the use of Lightmapper is more than just a step towards better visuals; it’s an embrace of the intricate dance between art and technology. With each bake, adjust, and preview, you’re not only enhancing the realism of your worlds but also sharpening a craft that sits at the very heart of memorable game experiences. And remember, we at Zenva are with you in this journey, offering resources like our Godot Game Development Mini-Degree to light your path towards becoming a Godot guru.

Whether today is the first time you’ve considered the impact of lightmapping or you’re a seasoned developer looking to up your game with Godot 4’s latest features, your dedication to learning will illuminate your potential. Let the lessons here be the spark that ignites your passion for game creation, and may your projects reflect the new depths of knowledge you’ve gained. Keep experimenting, learning, and growing with Zenva – where each line of code takes you closer to your dream game.

FREE COURSES
Python Blog Image

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