ShaderInclude in Godot – Complete Guide

Welcome to an exciting exploration of the Godot Engine’s ShaderInclude class, a remarkable feature introduced in Godot 4. This tutorial is designed to unveil the mysteries of shader code reusability to both budding and seasoned game developers alike. We aim to demystify shader programming, making it an engaging and less daunting subject. By the end of this article, you’ll understand how this feature can drastically streamline your shader code management and inspire you to create more dynamic and visually appealing games.

What is ShaderInclude?

ShaderInclude is a Godot resource that acts like a library for shader snippets. Think of it as a bookshelf in your programming toolkit, where you can store and retrieve pieces of shader code whenever you need them. In Godot 4, ShaderInclude allows developers to write modular shader code, breaking down complex shaders into digestible, reusable components.

What is it for?

The purpose of ShaderInclude is to help you avoid code duplication. Instead of copying and pasting the same code into multiple shaders, you reference it through the #include directive. This not only saves time but also keeps your projects organized and makes it easier to maintain and update your shaders across different materials and effects.

Why Should I Learn It?

If you’re aiming to master the Godot Engine and dive into the vast possibilities of creating visually rich games, understanding ShaderInclude is crucial. It encourages code reuse, improves readability, and makes the daunting world of shader programming much more approachable. Plus, it’s a skill that significantly increases the quality of your game’s visuals without the overhead of managing complex shader code. That’s a win-win for any game developer!

CTA Small Image

Creating a Basic ShaderInclude Resource

Let’s start with the basics of creating a ShaderInclude resource in Godot 4. The process is straightforward: you first create a new resource in the Godot editor and then write your reusable shader code pieces within it. Here’s how:

// 1. Create a new ShaderInclude resource
var shader_include =

// 2. Load code from an existing file or write your code as a string
shader_include.code = "void shared_function() { /* ... */ }"

Or you can create a ShaderInclude resource by using the Godot Editor:

  • Select “Resource” in the Godot editor menu
  • Choose “New Resource”
  • Search and select “ShaderInclude”
  • Click on “Create”

After creating the resource, you save it as a .gdinc file, which is the Godot shader include file.

Writing Reusable Shader Functions

ShaderInclude shines when you create functions that can be shared across various shaders. Here’s an example of a simple lighting calculation function that can be reused:

// lighting_calculation.gdinc
vec3 calculateDiffuse(vec3 normal, vec3 lightDir, vec3 lightColor) {
    float diff = max(dot(normal, lightDir), 0.0);
    return diff * lightColor;

This function calculates a basic diffuse lighting component, which you may want to use in multiple shaders affording different types of surfaces.

Including ShaderIncludes in Your Shader

Once you have a ShaderInclude file with your desired functions, you can then include it in your shaders using the #include directive. Here’s how to incorporate the lighting calculation we’ve just written:

// Your shader .gdshader file
shader_type spatial;

#include "res://path_to_your_shader_include/lighting_calculation.gdinc"

void fragment() {
    // Call your reusable function from ShaderInclude
    ALBEDO = calculateDiffuse(NORMAL, vec3(1.0, 1.0, 1.0), vec3(1.0, 1.0, 1.0));

Notice how the full resource path to the ShaderInclude file is specified. The path should be adjusted according to where you saved your file.

Creating a Shader Library with Multiple Includes

Another powerful feature of ShaderInclude is the ability to maintain a library of common shader functions. You can essentially create a collection of .gdinc files, each containing related functions.

// math_helpers.gdinc
float lerp(float a, float b, float t) {
    return a + t * (b - a);

vec3 hueShift(vec3 color, float hue) {
    // Implementation goes here...

// color_effects.gdinc
vec3 applyGamma(vec3 color, float gamma) {
    return pow(color, vec3(gamma));

vec3 toGrayscale(vec3 color) {
    float average = (color.r + color.g + color.b) / 3.0;
    return vec3(average);

By organizing your code in these include files, you can easily build a library and fetch only the snippets you need, improving modularity and project clarity.

Stay tuned for the next part of our tutorial, where we’ll dive into more advanced ShaderInclude usage scenarios and explore how we can elevate our game graphics with even more control and finesse!

Great! Now that you’re familiar with creating a ShaderInclude resource and incorporating it into your shaders, we’ll take things up a notch. Let’s delve into more advanced usage scenarios to leverage the full potential of ShaderInclude and take your game graphics further.

Handling Shader Uniforms in ShaderInclude

You can also define shader uniforms within ShaderInclude files. This is especially handy when you have a set of parameters that you frequently use across multiple shaders.

// uniforms_include.gdinc
uniform float specularity;
uniform vec3 light_position;

Then, include this file in your shaders to access these uniforms:

// Main shader file
shader_type spatial;

#include "res://uniforms_include.gdinc"

void fragment() {
    // Access uniforms defined in ShaderInclude
    float brightness = dot(NORMAL, normalize(light_position -;
    ALBEDO = vec3(specularity) * brightness;

By defining uniforms in a ShaderInclude, you can change their values globally and update all shaders that use them, streamlining the tweaking process.

Overriding Functions from ShaderIncludes

In some cases, you may want to override a function provided by a ShaderInclude for specific shaders. This can be achieved by redefining the function in your shader after the #include directive.

// lighting_effects.gdinc
vec3 applyAmbientLight(vec3 color, float intensity) {
    return color * intensity;

// Main shader file
shader_type spatial;

#include "res://lighting_effects.gdinc"

// Redefine applyAmbientLight for a specific case
vec3 applyAmbientLight(vec3 color, float intensity) {
    return color * (intensity + 0.25); // Slightly brighter

void fragment() {
    ALBEDO = applyAmbientLight(ALBEDO, 0.5);

Here, the applyAmbientLight function is modified for a particular shader to create a unique effect.

Chaining ShaderIncludes

You might find cases where ShaderIncludes depend on other includes. Godot allows you to chain includes, just like you’d include headers in C++. Here’s an example:

// vector_helpers.gdinc
vec3 multiplyVectors(vec3 a, vec3 b) {
    return a * b;

// lighting_helpers.gdinc
#include "res://vector_helpers.gdinc"

vec3 applyLightIntensity(vec3 light, float intensity) {
    return multiplyVectors(light, vec3(intensity));

// Main shader file
shader_type spatial;

#include "res://lighting_helpers.gdinc"

void fragment() {
    ALBEDO = applyLightIntensity(ALBEDO, 0.8);

This chaining of includes promotes code organization and allows you to build upon previously defined functions.

Using ShaderInclude for Complex Effects

In more sophisticated graphics programming, ShaderInclude can manage snippets that implement complex visual effects. For example, a noise function that could be the backbone for various procedural textures:

// noise_include.gdinc
float random(vec2 st) {
    return fract(sin(dot(st.xy, vec2(12.9898,78.233))) * 43758.5453123);

// Main shader file for procedural texture
shader_type canvas_item;

#include "res://noise_include.gdinc"

void fragment() {
    float noise = random(UV);
    COLOR = vec4(vec3(noise), 1.0);

By isolating the noise function, you can effortlessly bring procedural generation features into any shader.

ShaderInclude is a versatile tool that can make your shader code more maintainable, modular, and powerful. With these advanced tips and code snippets, you’ll be well on your way to creating shaders that are not only functional but are also easy to manage and expand upon. As we continue to explore the functionalities of Godot 4 and the capabilities of ShaderIncludes, we can push the boundaries of what we thought possible in our game visuals. Keep experimenting with these features, and you’ll be surprised at the complexity and beauty you can achieve in your games.

Remember, the power of shaders lies in their flexibility and the ability to create stunning visual effects tailored exactly to your needs. Happy coding, and may your scenes be ever vibrant!

Moving on in our journey with the Godot Engine’s ShaderIncludes, we’ll explore how to create a suite of environmental effects that can impart atmosphere and depth to any scene. We’re going all out with multiple code snippets that showcase the versatility of ShaderIncludes. Let’s get started!

Creating a Fog Effect with ShaderInclude

Add a sense of depth to your scenes with a modular fog shader code. First, we craft a ShaderInclude that calculates fog density based on distance from the camera.

// fog_calculations.gdinc
uniform float fog_start;
uniform float fog_end;
uniform vec4 fog_color;

float computeFogFactor(float depth) {
    float fogFactor = (fog_end - depth) / (fog_end - fog_start);
    return clamp(fogFactor, 0.0, 1.0);

Then, use this include in your spatial shader to apply the fog effect:

// Main shader with fog
shader_type spatial;

#include "res://fog_calculations.gdinc"

void fragment() {
    float depth = length(VERTEX - CAMERA_MATRIX[3].xyz);
    float fogFactor = computeFogFactor(depth);
    ALBEDO = mix(ALBEDO, fog_color.rgb, 1.0 - fogFactor);

It’s easy to maintain and update fog parameters across multiple shaders when encapsulating them within a ShaderInclude.

Water Reflection Shader Using ShaderIncludes

Create realistic water surfaces with reflections by breaking down the components into ShaderIncludes.

// reflection_helpers.gdinc
vec2 getReflectionUV(vec3 normal, vec3 viewDir) {
    vec3 reflected = reflect(viewDir, normal);
    return vec2(0.5) + reflected.xy * 0.5;

// Main shader for water surface
shader_type spatial;

#include "res://reflection_helpers.gdinc"

void fragment() {
    vec3 viewDir = normalize(CAMERA_MATRIX[3].xyz - VERTEX);
    vec2 reflectionUV = getReflectionUV(NORMAL, viewDir);
    vec4 reflectionColor = texture(SCREEN_TEXTURE, reflectionUV).rgba;
    ALBEDO = mix(ALBEDO, reflectionColor.rgb, 0.35);

Such modular snippets greatly assist in achieving complex effects like water simulation.

Dynamic Shadow Enhancements

Improve the visual fidelity of shadows in your game with dynamic soft shadows. First, let’s start with an include file for a shadow filter:

// shadow_filters.gdinc
vec3 softenShadow(vec3 shadowColor, float distance, float range) {
    float shadowSoftness = smoothstep(0.0, 1.0, (distance - range) * 0.1);
    return mix(vec3(1.0), shadowColor, shadowSoftness);

And then integrate this into a ShaderInclude for dynamic shadows:

// Main shader adjusting shadows
shader_type spatial;

#include "res://shadow_filters.gdinc"

void light() {

This ShaderInclude can be used to soften shadows from multiple light sources, making your scene lighting look more natural and nuanced.

Wave Animation for Flags or Clothes

Animating objects like flags or clothing to simulate wind can add life to your game scene. A ShaderInclude with a simple sine wave function can be the foundation.

// wave_animation.gdinc
uniform float wave_speed;
uniform float wave_height;

vec3 applyWave(vec3 position, float time) {
    position.y += sin(position.x * wave_speed + time) * wave_height;
    return position;

Implementing the wave animation in the vertex function of your material shader:

// Main shader for cloth or flag
shader_type spatial;

#include "res://wave_animation.gdinc"

void vertex() {
    VERTEX = applyWave(VERTEX, TIME);

Notice how we’ve called `applyWave` within the vertex function to alter the Y-position of each vertex over time, creating a waving effect. By adjusting the `wave_speed` and `wave_height`, we can simulate various wind intensities.

These are just a few examples of how Godot’s ShaderInclude class can elevate your game’s visuals by making shader code reusable, maintainable, and accessible. Integrating these shading techniques into your project would not just enhance its visual appeal but can also serve as a useful learning curve in understanding the intricacies of shader programming.

Remember, while the code snippets provided above are small, when they come together in a project, they can have large impacts. The beauty of using ShaderInclude is the ability to iterate quickly, make changes in one place, and see them propagate throughout your game. So go ahead, experiment, and watch your virtual worlds come to life with stunning graphical effects. Happy shading!

Continue Your Game Development Journey

Now that you’ve unlocked new possibilities with ShaderInclude in Godot 4, your journey has just begun. There’s a vast world of game development to explore, and we’re thrilled to support you in taking the next steps. To continue honing your skills and discovering the full potential of Godot Engine, we invite you to check out our Godot Game Development Mini-Degree. Through a comprehensive collection of courses, you’ll dive into a variety of game types and mechanics, crafting your own unique gaming experiences with Godot 4’s powerful features.

Whether you’re just starting out or looking to polish your developer toolkit, our mini-degree has something for you. From understanding the basics of GDScript to designing intricate gameplay systems, our curriculum is designed to be flexible and accessible, empowering you to build games from the ground up.

And that’s not all – for those who seek a broader spectrum of Godot content, our Godot courses cater to all levels, providing you with the knowledge to turn your creativity into reality. Seize the opportunity – the demand for skilled game developers is on the rise, and your next step could lead to an exciting career in this dynamic industry.


In mastering the ShaderInclude class and diving deep into the shader programming of Godot 4, you’ve equipped yourself with a powerful toolkit for game development. But remember, learning is an ongoing quest, especially in the ever-evolving world of game creation. We hope this tutorial inspires you to continue experimenting with shaders and explore the limitless potential of Godot Engine.

As you continue to develop your skills, consider joining us at Zenva for an even deeper exploration into Godot and game development. Our Godot Game Development Mini-Degree is tailored to foster your growth as a developer, providing you with the guidance and resources needed to bring your most ambitious game ideas to life. So, keep exploring, keep learning, and most importantly, keep creating. Your next game could be the next big hit!

Python Blog Image

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