tutorials/shaders/shader_reference/shading_language

[giscus[bot]]

tutorials/shaders/shader_reference/shading_language

Introduction: Godot uses a shading language similar to GLSL ES 3.0. Most datatypes and functions are supported, and the few remaining ones will likely be added over time. If you are already familia...

https://docs.godotengine.org/en/stable/tutorials/shaders/shader_reference/shading_language.html

[luisacarrion]

Note that the source_color hint doesn't work on global uniforms. The workaround is to do the color conversion using the formula shared by clayjohn on the Github issue:

ALBEDO = mix(pow((col.rgb + vec3(0.055)) * (1.0 / (1.0 + 0.055)), vec3(2.4)), col.rgb * (1.0 / 12.92), lessThan(col.rgb, vec3(0.04045)));

[Samvkes]

It says "Per instance Uniforms are only available in Spatial (3D) shaders". I think that's no longer true as of 4.4?

[Calinou]

Pull request opened:

• Document support for 2D per-instance uniforms in Shading language godot-docs#10749

[kudorgyozo]

Albedo means color for anyone else wandering.

[chuckwolber]

For anyone looking for references to the TIME variable, it is found in the list of shader specific built-ins. Despite being documented identically for each shader, this information is duplicated. Some sort of index cross-reference would be nice in these situations.

[Bogost]

In current godot (4.4.1) you set up shader globals under tab globals ->shader globals. The menu image here is no longer up to date.

[Bogost]

Remember that changing uniform default of material already assigned to node wont change its current uniform value.

[Steinbeuge]

It doesn't say this in the documents, but all shader params and variables must be lower case. Godot will not warn you, the shader compiler will not warn you, things will just silently not work.
As an example I had a param called R, and a function parameter r, R was obsuring r and there was no warning. Likewise, I had capitals in my params, when using set_shader_param() nothing was working until I set the names to all lower case, instead of what they actually are.

[Calinou]

I can't reproduce this in 4.5.stable:

However, remember that the parameter name passed to set_shader_param() should match the uniform name in the shader, not the capitalized property name you see in the shader. You can see the raw uniform name from the inspector by hovering the name with the mouse. The name is what appears in the tooltip, minus the shader_parameter/ prefix.

[Steinbeuge]

Thanks for checking, I'll test it again in 4.4.1 and 4.5 and see if I can reproduce it. Specifically I had a shader uniform R, and a function in my shader like
float my_function( float r, vec3 otherthing) {
//my code that uses little r
return something
}
on a hunch I changed the shader function parameter to _r and it all came good

[Theome]

The "Uniform limits" section suggests to pack data into a texture. To elaborate on that, here are the high level steps:

• Create an Image object with the data you want to send
• Create an ImageTexture with that image
• Use set_shader_parameter() to assign the texture to a uniform with an appropriate sampler type
• In the shader, use texelFetch to read the data from the texture.

The Image.Format and the sampler type must be chosen appropriately, depending on the data you want to send.

If the data is int or uint, be aware that there is a known bug in Godot, and if you select an "integer" image format like FORMAT_R8, FORMAT_RG8, etc., an isampler2D will read incorrect values. See:
godotengine/godot#57841

As a workaround, create an image with format FORMAT_RF, and fill its buffer with little endian int32 values.

In C# it might look like this:

int bytesPerPixel = 4;
byte[] data = new byte[width * height * bytesPerPixel];
int position = 0;
Span<byte> buffer = new(data);

// Looping over each pixel:
foreach (....) {
  System.Buffers.Binary.BinaryPrimitives.WriteInt32LittleEndian(buffer[position..], pixelData);
  position += bytesPerPixel;
}
Image.Format format = Image.Format.Rf;
Image image = Image.CreateFromData(width, height, false, format, data);

In your shader, use an isampler2D to read the data like this:

int value = texelFetch(sampler, position, 0).r;

This will read the correct value. Note that no conversion in the shader is needed, and as no real typecasting happens, there will be no precision loss. For more details, see the linked issue above.

[RayKoopa]

It seems that a Transform2D can also be set as a mat4 uniform, not documented in the table here. In this case, the z column/row becomes identity and the origin is set in the 4th column, just as one would expect.
However, I can not set it as a mat3 uniform, which is how I'd actually imagine it to be represented internally.

[opponent019]

You can replace hint_normal_roughness_texture for Mobile with:

float depth = texture(DEPTH_TEXTURE, SCREEN_UV).r;
vec4 upos = INV_PROJECTION_MATRIX * vec4(SCREEN_UV * 2.0 – 1.0, depth, 1.0);
vec3 pixel_position = upos.xyz / upos.w;
vec3 normal = normalize(cross(dFdy(pixel_position),dFdx(pixel_position)));

on fragment()

While uniform sampler2D DEPTH_TEXTURE :source_color, hint_depth_texture;

[Calinou]

To clarify what this does, this reconstructs the normal buffer from the depth buffer. This is not guaranteed to deliver the same result, especially on meshes that use custom normals (such as weighted face normals). Also, this won't reconstruct the roughness buffer at all.