@@ -3,119 +3,162 @@
Introduction to shaders
=======================
Introduction
------------
This page explains what shaders are and will give you an overview of how they
:ref: `doc_shading_language` .
o, you have decided to give shaders a try. You have likely heard that they can be used to
create interesting effects that run incredibly fast. You have also likely heard that they
are terrifying. Both are true.
haders are a special kind of program that runs on Graphics Processing Units
(GPUs). They were initially used to shade 3D scenes but can nowadays do much
more. You can use them to control how the engine draws geometry and pixels on
Shaders can be used to create a wide range of effects (in fact everything drawn in a modern
rendering engine is done with shaders).
Modern rendering engines like Godot draw everything with shaders: graphics cards
can run thousands of instructions in parallel, leading to incredible rendering
Writing shaders can also be very difficult for people unfamiliar with them. Godot tries to make writing
shaders a little easier by exposing many useful built-in features and handling some of the
lower-level initialization work for you. However, GLSL (the OpenGL Shading Language, which Godot uses)
is still unintuitive and restricting, especially for users who are used to GDScript.
Because of their parallel nature, though, shaders don't process information the
way a typical program does. Shader code runs on each vertex or pixel in
isolation. You cannot store data between frames either. As a result, when
working with shaders, you need to code and think differently from other
But what are they?
------------------
::
Suppose you want to update all the pixels in a texture to a given color. In
`` for `` loops::
for x in range(width):
for y in range(height):
set_color(x, y, some_color)
In a shader you are given access only to the inside of the loop so what you write looks like this:
Your code is already part of a loop in a shader, so the corresponding code would
.. code-block :: glsl
// function called for each pixel
void fragment ( ) {
COLOR = some_color ;
}
You have no control over how this function is called. So you have to design your shaders
.. note ::
A consequence of the shader pipeline is that you cannot access the results from a previous
The graphics card calls the `` fragment() `` function once or more for each pixel it has to draw. More on that below.
W hat can they do
^^^^^^^^^^^^^^^^
S haders in Go dot
----------------
- position vertices very fast
- compute color very fast
- compute lighting very fast
- lots and lots of math
(GLSL) but simplified. The engine handles some of the lower-level initialization
work for you, making it easier to write complex shaders.
What can't they do
^^^^^^^^^^^^^^^^^^
In Godot, shaders are made up of three main functions: `` vertex() `` ,
`` fragment() `` , and `` light() `` .
- draw outside mesh
- access oixels from current pixel (or vertic es)
- store previous iterations
- update on the fly (they can, but they need to be compiled)
1. The `` vertex() `` function runs over all the vertices in the mesh and sets
thei r positions and some other per-vertex variabl es.
Structure of a shader
---------------------
2. The `` fragment() `` function runs for every pixel covered by the mesh. It uses
`` vertex() `` function, interpolated between the
`` vertex ()`` function, the `` fragment() ``
function and the `` ligh t()`` function.
`` vertex() `` function runs over all the vertices in the mesh and sets their positions as well
`` fragment() `` function runs for every pixel that is covered by the mesh. It uses the variables
`` vertex() `` function to run. The variables from the `` vertex() `` function are interpolated
`` fragment() `` function.
`` light() `` function runs for every pixel and for every light. It takes variables from the
`` fragment() `` function and from previous runs of itself.
:ref: `Shaders <doc_shaders>` doc.
3. T`` light ()`` function runs for every pixel and for every light. It takes
variables from the `` fragmen t()`` function and from its previous runs .
.. warning ::
`` light() `` function won't be run if the `` vertex_lighting `` render mode
is enabled, or if
**Rendering > Quality > Shading > Force Vertex Shading** is enabled in th
Project Settings. (It's enabled by default on mobile platforms.)
`` light() `` function won't run if the `` vertex_lighting `` render mode is
**Rendering > Quality > Shading > Force Vertex Shading** is
enabled in the Project Settings. It's enabled by default on mobil e
Technical overview
------------------
Shader types
------------
GPUs are able to render graphics much faster than CPUs for a few reasons, but most notably ,
because they are able to run calculations massively in parallel. A CPU typically has 4 or 8 cor es
while a GPU typically has thousands. That means a GPU can do hundreds of tasks at once. GPU architects
Instead of supplying a general-purpose configuration for all uses (2D, 3D ,
particles), you must specify the type of shader you're writing. Different typ es
support different render modes, built-in variables, and processing functions.
That is where shaders come in. The GPU will call the shader a bunch of times simultaneously, and then
×
In Godot, all shaders need to specify their type in the first line, like so:
This is different from CPU-based operations. On a CPU, if you can speed up even one
.. code-block :: glsl
shader_type spatial ;
Here are the available types:
* :ref: `spatial <doc_spatial_shader>` for 3D rendering.
* :ref: `canvas_item <doc_canvas_item_shader>` for 2D rendering.
* :ref: `particles <doc_particle_shader>` for particle systems.
* :ref: `sky <doc_sky_shader>` to render :ref: `Skies <class_Sky>` .
Render modes
------------
.. code-block :: glsl
shader_type spatial ;
render_mode unshaded , cull_disabled ;
Render modes alter the way Godot applies the shader. For example, the
`` unshaded `` mode makes the engine skip the built-in light processor function.
Processor functions
-------------------
`` spatial `` and `` canvas_item `` , you have access to `` vertex() `` ,
`` fragment() `` , and `` light() `` . For `` particles `` , you only have access to
`` vertex() `` .
Vertex processor
^^^^^^^^^^^^^^^^
`` vertex() `` processing function is called once for every vertex in
`` spatial `` and `` canvas_item `` shaders. For `` particles `` shaders, it is called
:ref: `Spatial shader doc <doc_spatial_shader>` for an
Fragment processor
^^^^^^^^^^^^^^^^^^
`` fragment() `` processing function is used to set up the Godot material
`` spatial `` and `` canvas_item `` shaders.
`` ROUGHNESS `` ,
`` RIM `` , or `` TRANSMISSION `` , which would tell the light function how the lights
`` RIM `` , Godot will not calculate rim lighting. During compilation,
`` RIM `` is used; if not, it cuts all the corresponding
Light processor
^^^^^^^^^^^^^^^
`` light() `` processor runs per pixel too, and it runs once for every light
`` fragment() `` processor and typically
`` fragment() `` function.
`` light() `` processor works differently in 2D than it does in 3D; for a
` and :ref:`
<doc_spatial_shader> `, respectively.
Nathan Lovato