Spatial-Shader

Spatial-Shader werden zum Schattieren von 3D-Objekten verwendet, Sie sind die komplexesten, die Godot bietet. Spatial-Shader sind mit verschiedenen Rendermodi und verschiedenen Rendering-Optionen (z.B. Subsurface Scattering, Transmission, Ambient Occlusion, Randbeleuchtung usw.) hochgradig konfigurierbar. Benutzer können optional Vertex-, Fragment- und Lichtprozessorfunktionen schreiben, um zu beeinflussen, wie Objekte gezeichnet werden.

Render-Modi

For visual examples of these render modes, see Standard Material 3D and ORM Material 3D.

Rendermodus	Beschreibung
blend_mix	Mix-Blending-Modus (Alpha ist Transparenz), Default.
blend_add	Additiver Blending-Modus.
blend_sub	Subtraktiver Blending-Modus.
blend_mul	Multiplikativer Blending-Modus.
blend_premul_alpha	Premultiplied alpha blend mode (fully transparent = add, fully opaque = mix).
depth_draw_opaque	Tiefe nur für undurchsichtige Geometrie (nicht transparent) zeichnen.
depth_draw_always	Tiefe immer zeichnen (undurchsichtig und transparent).
depth_draw_never	Tiefe niemals zeichnen.
depth_prepass_alpha	Für transparente Geometrie einen undurchsichtig-Tiefenvorlauf ausführen.
depth_test_disabled	Tiefenprüfung Deaktivieren.
sss_mode_skin	Subsurface Scattering mode for skin (optimizes visuals for human skin, e.g. boosted red channel).
cull_back	Backface-Culling durchführen (Default).
cull_front	Frontface-Culling durchführen.
cull_disabled	Culling deaktiviert (beidseitig).
unshaded	Result is just albedo. No lighting/shading happens in material, making it faster to render.
wireframe	Geometry draws using lines (useful for troubleshooting).
debug_shadow_splits	Directional shadows are drawn using different colors for each split (useful for troubleshooting).
diffuse_burley	Burley (Disney PBS) für diffuses Licht (Default).
diffuse_lambert	Lambert-Schattierung für diffuses Licht.
diffuse_lambert_wrap	Lambert-wrap shading (roughness-dependent) for diffuse.
diffuse_toon	Toon-Shading für diffuses Licht.
specular_schlick_ggx	Schlick-GGX for direct light specular lobes (default).
specular_toon	Toon for direct light specular lobes.
specular_disabled	Disable direct light specular lobes. Doesn't affect reflected light (use `SPECULAR = 0.0` instead).
skip_vertex_transform	`VERTEX`, `NORMAL`, `TANGENT`, and `BITANGENT` need to be transformed manually in the `vertex()` function.
world_vertex_coords	`VERTEX`, `NORMAL`, `TANGENT`, and `BITANGENT` are modified in world space instead of model space.
ensure_correct_normals	Use when non-uniform scale is applied to mesh (note: currently unimplemented).
shadows_disabled	Disable computing shadows in shader. The shader will not receive shadows, but can still cast them.
ambient_light_disabled	Deaktivieren des Beitrags von Umgebungslicht und der Radiance Map.
shadow_to_opacity	Durch die Beleuchtung wird das Alpha so geändert, dass schattierte Bereiche undurchsichtig und nicht schattierte Bereiche transparent sind. Nützlich zum Überlagern von Schatten auf einen Kamera-Feed in AR.
vertex_lighting	Use vertex-based lighting instead of per-pixel lighting.
particle_trails	Aktiviert die Trails, wenn sie auf Partikelgeometrien verwendet werden.
alpha_to_coverage	Alpha-Antialiasing-Modus, siehe hier für mehr.
alpha_to_coverage_and_one	Alpha-Antialiasing-Modus, siehe hier für mehr.
fog_disabled	Disable receiving depth-based or volumetric fog. Useful for `blend_add` materials like particles.

Built-ins

Values marked as in are read-only. Values marked as out can optionally be written to and will not necessarily contain sensible values. Values marked as inout provide a sensible default value, and can optionally be written to. Samplers cannot be written to so they are not marked.

Not all built-ins are available in all processing functions. To access a vertex built-in from the fragment() function, you can use a varying. The same applies for accessing fragment built-ins from the light() function.

Globale Built-ins

Globale Built-ins sind überall verfügbar, einschließlich benutzerdefinierter Funktionen.

Built-in	Beschreibung
in float TIME	Global time since the engine has started, in seconds. It repeats after every `3,600` seconds (which can be changed with the rollover setting). It's affected by time_scale but not by pausing. If you need a `TIME` variable that is not affected by time scale, add your own global shader uniform and update it each frame.
in float PI	Eine `PI`-Konstante (`3,141592`). Das Verhältnis des Umfangs eines Kreises zu seinem Durchmesser und die Anzahl der Bogenmaßeinheiten in einer halben Umdrehung.
in float TAU	Eine `TAU`-Konstante (`6.283185`). Ein Äquivalent von `PI * 2` und die Anzahl der Bogenmaßeinheiten in einer vollen Umdrehung.
in float E	Eine `E`-Konstante (`2,718281`). Eulersche Zahl und eine Basis des natürlichen Logarithmus.
in bool OUTPUT_IS_SRGB	`true` when output is in sRGB color space (this is `true` in the Compatibility renderer, `false` in Forward+ and Mobile).
in float CLIP_SPACE_FAR	Clip space far `z` value. In the Forward+ or Mobile renderers, it's `0.0`. In the Compatibility renderer, it's `-1.0`.

Vertex-Built-ins

Vertex data (VERTEX, NORMAL, TANGENT, and BITANGENT) are presented in model space (also called local space). If not written to, these values will not be modified and be passed through as they came, then transformed into view space to be used in fragment().

They can optionally be presented in world space by using the world_vertex_coords render mode.

Benutzer können die Built-in-Modellansichtstransformation deaktivieren (die Projektion wird später immer noch durchgeführt) und sie mit dem folgenden Code manuell durchführen:

shader_type spatial;
render_mode skip_vertex_transform;

void vertex() {
    VERTEX = (MODELVIEW_MATRIX * vec4(VERTEX, 1.0)).xyz;
    NORMAL = normalize((MODELVIEW_MATRIX * vec4(NORMAL, 0.0)).xyz);
    BINORMAL = normalize((MODELVIEW_MATRIX * vec4(BINORMAL, 0.0)).xyz);
    TANGENT = normalize((MODELVIEW_MATRIX * vec4(TANGENT, 0.0)).xyz);
}

Other built-ins, such as UV, UV2, and COLOR, are also passed through to the fragment() function if not modified.

Der Benutzer kann die Modellansicht und die Projektionstransformationen mit Hilfe der eingebauten POSITION überschreiben. Wenn POSITION irgendwo in den Shader geschrieben wird, wird es immer benutzt, so dass der Benutzer dafür verantwortlich ist, dass es immer einen akzeptablen Wert hat. Wenn POSITION verwendet wird, wird der Wert von VERTEX ignoriert und es findet keine Projektion statt. Der Wert, der an den Fragment-Shader übergeben wird, stammt jedoch immer noch von VERTEX.

For instancing, the INSTANCE_CUSTOM variable contains the instance custom data. When using particles, this information is usually:

x: Rotationswinkel in Bogenmaß.
y: Phase during lifetime (0.0 to 1.0).
z: Animations-Frame.

Dies ermöglicht es Ihnen, den Shader einfach an ein Partikelsystem anzupassen, das Default-Partikelmaterial verwendet. Wenn Sie einen benutzerdefinierten Partikel-Shader schreiben, können Sie diesen Wert nach Belieben verwenden.

Built-in	Beschreibung
in vec2 VIEWPORT_SIZE	Größe des Viewports (in Pixeln).
in mat4 VIEW_MATRIX	Transformation von World-Space nach View-Space.
in mat4 INV_VIEW_MATRIX	Transformation von View-Space nach World-Space.
in mat4 MAIN_CAM_INV_VIEW_MATRIX	Transformation der Kamera, die zum Zeichnen des aktuellen Viewports verwendet wird, vom View Space in den World Space.
in mat4 INV_PROJECTION_MATRIX	Transformation von Clip-Space nach View-Space.
in vec3 NODE_POSITION_WORLD	Node-Position im World-Space.
in vec3 NODE_POSITION_VIEW	Node-Position im View-Space.
in vec3 CAMERA_POSITION_WORLD	Kamera-Position im World-Space.
in vec3 CAMERA_DIRECTION_WORLD	Kamera-Richtung im World-Space.
in uint CAMERA_VISIBLE_LAYERS	Ebenen der Kamera beim Rendern des aktuellen Durchlaufs cullen.
in int INSTANCE_ID	Instanz-ID zum Instanziieren.
in vec4 INSTANCE_CUSTOM	Benutzerdefinierte Instanzdaten (meistens für Partikel).
in int VIEW_INDEX	Die Ansicht, die gerendert wird. `VIEW_MONO_LEFT` (`0`) für Mono (nicht Multiview) oder linkes Auge, `VIEW_RIGHT` (`1`) für rechtes Auge.
in int VIEW_MONO_LEFT	Konstante für Mono oder linkes Auge, immer `0`.
in int VIEW_RIGHT	Konstante für das rechte Auge, immer `1`.
in vec3 EYE_OFFSET	Positions-Offset für das gerenderte Auge. Gilt nur für Multiview-Rendering.
inout vec3 VERTEX	Position of the vertex, in model space. In world space if `world_vertex_coords` is used.
in int VERTEX_ID	Der Index des aktuellen Vertex im Vertex-Puffer.
inout vec3 NORMAL	Normal in model space. In world space if `world_vertex_coords` is used.
inout vec3 TANGENT	Tangent in model space. In world space if `world_vertex_coords` is used.
inout vec3 BINORMAL	Binormal in model space. In world space if `world_vertex_coords` is used.
out vec4 POSITION	If written to, overrides final vertex position in clip space.
inout vec2 UV	UV Hauptkanal.
inout vec2 UV2	UV Sekundärkanal.
inout vec4 COLOR	Farbe der Vertices.
out float ROUGHNESS	Rauheit für Vertex-Beleuchtung.
inout float POINT_SIZE	Punktgröße für Punkt-Rendering.
inout mat4 MODELVIEW_MATRIX	Model/local space to view space transform (use if possible).
inout mat3 MODELVIEW_NORMAL_MATRIX
in mat4 MODEL_MATRIX	Model/local space to world space transform.
in mat3 MODEL_NORMAL_MATRIX
inout mat4 PROJECTION_MATRIX	Transformation von View-Space nach Clip-Space.
in uvec4 BONE_INDICES
in vec4 BONE_WEIGHTS
in vec4 CUSTOM0	Custom value from vertex primitive. When using extra UVs, `xy` is UV3 and `zw` is UV4.
in vec4 CUSTOM1	Custom value from vertex primitive. When using extra UVs, `xy` is UV5 and `zw` is UV6.
in vec4 CUSTOM2	Custom value from vertex primitive. When using extra UVs, `xy` is UV7 and `zw` is UV8.
in vec4 CUSTOM3	Benutzerdefinierter Wert vom Scheitelpunktprimitiv.

Bemerkung

MODELVIEW_MATRIX kombiniert sowohl MODEL_MATRIX als auch VIEW_MATRIX und ist besser geeignet, wenn Float-Probleme auftreten können. Wenn zum Beispiel das Objekt sehr weit vom Weltursprung entfernt ist, kann es bei der Verwendung des getrennten MODEL_MATRIX und VIEW_MATRIX zu Float-Problemen kommen.

Bemerkung

INV_VIEW_MATRIX ist die Matrix, die zum Rendern des Objekts in diesem Durchgang verwendet wird, nicht wie MAIN_CAM_INV_VIEW_MATRIX, welche die Matrix der Kamera in der Szene ist. Im Schattendurchgang basiert die Ansicht von INV_VIEW_MATRIX auf der Kamera, die sich an der Position des Lichts befindet.

Fragment-Built-ins

Die Standardverwendung einer Godot-Fragmentprozessorfunktion besteht darin, die Materialeigenschaften Ihres Objekts einzurichten und den Built-in-Renderer die endgültige Schattierung vornehmen zu lassen. Sie müssen jedoch nicht alle diese Propertys verwenden, und wenn Sie sie nicht befüllen, wird Godot die entsprechenden Funktionalitäten wegoptimieren.

Built-in	Beschreibung
in vec2 VIEWPORT_SIZE	Größe des Viewports (in Pixeln).
in vec4 FRAGCOORD	Coordinate of pixel center in screen space. `xy` specifies position in window. Origin is lower left. `z` specifies fragment depth. It is also used as the output value for the fragment depth unless `DEPTH` is written to.
in bool FRONT_FACING	`true` if current face is front facing, `false` otherwise.
in vec3 VIEW	Normalisierter Vektor von der Fragmentposition zur Kamera (im View-Space). Dies gilt sowohl für perspektivische als auch für orthogonale Kameras.
in vec2 UV	UV that comes from the `vertex()` function.
in vec2 UV2	UV2 that comes from the `vertex()` function.
in vec4 COLOR	COLOR that comes from the `vertex()` function.
in vec2 POINT_COORD	Point coordinate for drawing points with `POINT_SIZE`.
in mat4 MODEL_MATRIX	Model/local space to world space transform.
in mat3 MODEL_NORMAL_MATRIX	Model/local space to world space transform for normals. This is the same as `MODEL_MATRIX` by default unless the object is scaled non-uniformly, in which case this is set to `transpose(inverse(mat3(MODEL_MATRIX)))`.
in mat4 VIEW_MATRIX	Transformation von World-Space nach View-Space.
in mat4 INV_VIEW_MATRIX	Transformation von View-Space nach World-Space.
in mat4 PROJECTION_MATRIX	Transformation von View-Space nach Clip-Space.
in mat4 INV_PROJECTION_MATRIX	Transformation von Clip-Space nach View-Space.
in vec3 NODE_POSITION_WORLD	Node-Position im World-Space.
in vec3 NODE_POSITION_VIEW	Node-Position im View-Space.
in vec3 CAMERA_POSITION_WORLD	Kamera-Position im World-Space.
in vec3 CAMERA_DIRECTION_WORLD	Kamera-Richtung im World-Space.
in uint CAMERA_VISIBLE_LAYERS	Ebenen der Kamera beim Rendern des aktuellen Durchlaufs cullen.
in vec3 VERTEX	Position of the fragment (pixel), in view space. It is the `VERTEX` value from `vertex()` interpolated between the face's vertices and transformed into view space. If `skip_vertex_transform` is enabled, it may not be in view space.
inout vec3 LIGHT_VERTEX	Eine beschreibbare Version von `VERTEX`, die zur Veränderung von Licht und Schatten verwendet werden kann. Durch das Schreiben wird die Position des Fragments nicht verändert.
in int VIEW_INDEX	The view that we are rendering. Used to distinguish between views in multiview/stereo rendering. `VIEW_MONO_LEFT` (`0`) for Mono (not multiview) or left eye, `VIEW_RIGHT` (`1`) for right eye.
in int VIEW_MONO_LEFT	Konstante für Mono oder linkes Auge, immer `0`.
in int VIEW_RIGHT	Konstante für das rechte Auge, immer `1`.
in vec3 EYE_OFFSET	Positions-Offset für das gerenderte Auge. Gilt nur für Multiview-Rendering.
sampler2D SCREEN_TEXTURE	Entfernt in Godot 4. Verwenden Sie stattdessen ein `sampler2D` mit `hint_screen_texture`.
in vec2 SCREEN_UV	Screen-UV-Koordinate für das aktuelle Pixel.
sampler2D DEPTH_TEXTURE	Entfernt in Godot 4. Verwenden Sie stattdessen ein `sampler2D` mit `hint_depth_texture`.
out float DEPTH	Custom depth value (range of `[0.0, 1.0]`). If `DEPTH` is being written to in any shader branch, then you are responsible for setting the `DEPTH` for all other branches. Otherwise, the graphics API will leave them uninitialized.
inout vec3 NORMAL	Normal that comes from the `vertex()` function, in view space. If `skip_vertex_transform` is enabled, it may not be in view space.
inout vec3 TANGENT	Tangent that comes from the `vertex()` function, in view space. If `skip_vertex_transform` is enabled, it may not be in view space.
inout vec3 BINORMAL	Binormal that comes from the `vertex()` function, in view space. If `skip_vertex_transform` is enabled, it may not be in view space.
out vec3 NORMAL_MAP	Set normal here if reading normal from a texture instead of `NORMAL`.
out float NORMAL_MAP_DEPTH	Depth from `NORMAL_MAP`. Defaults to `1.0`.
out vec3 ALBEDO	Albedo (default white). Base color.
out float ALPHA	Alpha (range of `[0.0, 1.0]`). If read from or written to, the material will go to the transparent pipeline.
out float ALPHA_SCISSOR_THRESHOLD	Beim Befüllen werden Werte unter einem bestimmten Alpha-Wert verworfen.
out float ALPHA_HASH_SCALE	Alpha hash scale when using the alpha hash transparency mode. Defaults to `1.0`. Higher values result in more visible pixels in the dithering pattern.
out float ALPHA_ANTIALIASING_EDGE	The threshold below which alpha to coverage antialiasing should be used. Defaults to `0.0`. Requires the `alpha_to_coverage` render mode. Should be set to a value lower than `ALPHA_SCISSOR_THRESHOLD` to be effective.
out vec2 ALPHA_TEXTURE_COORDINATE	The texture coordinate to use for alpha-to-coverge antialiasing. Requires the `alpha_to_coverage` render mode. Typically set to `UV * vec2(albedo_texture_size)` where `albedo_texture_size` is the size of the albedo texture in pixels.
out float PREMUL_ALPHA_FACTOR	Premultiplied alpha factor. Only effective if `render_mode blend_premul_alpha;` is used. This should be written to when using a shaded material with premultiplied alpha blending for interaction with lighting. This is not required for unshaded materials.
out float METALLIC	Metallic (range of `[0.0, 1.0]`).
out float SPECULAR	Specular (not physically accurate to change). Defaults to `0.5`. `0.0` disables reflections.
out float ROUGHNESS	Roughness (range of `[0.0, 1.0]`).
out float RIM	Rim (range of `[0.0, 1.0]`). If used, Godot calculates rim lighting. Rim size depends on `ROUGHNESS`.
out float RIM_TINT	Rim Tint, range of `0.0` (white) to `1.0` (albedo). If used, Godot calculates rim lighting.
out float CLEARCOAT	Small specular blob added on top of the existing one. If used, Godot calculates clearcoat.
out float CLEARCOAT_GLOSS	Gloss of clearcoat. If used, Godot calculates clearcoat.
out float ANISOTROPY	Zum Verzerren des Spiegelkleckses entsprechend des Tangentenraums.
out vec2 ANISOTROPY_FLOW	Verzerrungsrichtung, mit Flowmaps verwenden.
out float SSS_STRENGTH	Strength of subsurface scattering. If used, subsurface scattering will be applied to the object.
out vec4 SSS_TRANSMITTANCE_COLOR	Color of subsurface scattering transmittance. If used, subsurface scattering transmittance will be applied to the object.
out float SSS_TRANSMITTANCE_DEPTH	Depth of subsurface scattering transmittance. Higher values allow the effect to reach deeper into the object.
out float SSS_TRANSMITTANCE_BOOST	Boosts the subsurface scattering transmittance if set above `0.0`. This makes the effect show up even on directly lit surfaces
inout vec3 BACKLIGHT	Color of backlighting (works like direct light, but it's received even if the normal is slightly facing away from the light). If used, backlighting will be applied to the object. Can be used as a cheaper approximation of subsurface scattering.
out float AO	Strength of ambient occlusion. For use with pre-baked AO.
out float AO_LIGHT_AFFECT	How much ambient occlusion affects direct light (range of `[0.0, 1.0]`, default `0.0`).
out vec3 EMISSION	Emission color (can go over `(1.0, 1.0, 1.0)` for HDR).
out vec4 FOG	If written to, blends final pixel color with `FOG.rgb` based on `FOG.a`.
out vec4 RADIANCE	If written to, blends environment map radiance with `RADIANCE.rgb` based on `RADIANCE.a`.
out vec4 IRRADIANCE	If written to, blends environment map irradiance with `IRRADIANCE.rgb` based on `IRRADIANCE.a`.

Bemerkung

Shader, welche die transparente Pipeline durchlaufen, wenn in ALPHA geschrieben wird, können Probleme mit der Transparenzsortierung aufweisen. Lesen Sie den Abschnitt Transparenzsortierung in der "3D-Rendering-Beschränkungen"-Seite für weitere Informationen und Möglichkeiten zur Vermeidung von Problemen.

Licht-Built-ins

Writing light processor functions is completely optional. You can skip the light() function by using the unshaded render mode. If no light function is written, Godot will use the material properties written to in the fragment() function to calculate the lighting for you (subject to the render mode).

The light() function is called for every light in every pixel. It is called within a loop for each light type.

Below is an example of a custom light() function using a Lambertian lighting model:

void light() {
    DIFFUSE_LIGHT += clamp(dot(NORMAL, LIGHT), 0.0, 1.0) * ATTENUATION * LIGHT_COLOR / PI;
}

Wenn mehrere Lichter addiert werden sollen, fügen Sie den Lichtanteil zu DIFFUSE_LIGHT mittels += hinzu, anstatt ihn zu überschreiben.

Warnung

The 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 the Project Settings. (It's enabled by default on mobile platforms.)

Built-in	Beschreibung
in vec2 VIEWPORT_SIZE	Größe des Viewports (in Pixeln).
in vec4 FRAGCOORD	Koordinate der Pixelmitte im Bildschirmraum. `xy` spezifiziert die Position im Fenster, `z` spezifiziert die Fragmenttiefe, wenn `DEPTH` nicht benutzt wird. Der Ursprung ist unten links.
in mat4 MODEL_MATRIX	Model/local space to world space transform.
in mat4 INV_VIEW_MATRIX	Transformation von View-Space nach World-Space.
in mat4 VIEW_MATRIX	Transformation von World-Space nach View-Space.
in mat4 PROJECTION_MATRIX	Transformation von View-Space nach Clip-Space.
in mat4 INV_PROJECTION_MATRIX	Transformation von Clip-Space nach View-Space.
in vec3 NORMAL	Normalvektor im View-Space.
in vec2 SCREEN_UV	Screen-UV-Koordinate für das aktuelle Pixel.
in vec2 UV	UV that comes from the `vertex()` function.
in vec2 UV2	UV2 that comes from the `vertex()` function.
in vec3 VIEW	View-Vektor im View-Space.
in vec3 LIGHT	Light vector, in view space.
in vec3 LIGHT_COLOR	Light color multiplied by light energy multiplied by `PI`. The `PI` multiplication is present because physically-based lighting models include a division by `PI`.
in float SPECULAR_AMOUNT	For OmniLight3D and SpotLight3D, `2.0` multiplied by light_specular. For DirectionalLight3D, `1.0`.
in bool LIGHT_IS_DIRECTIONAL	`true` if this pass is a DirectionalLight3D.
in float ATTENUATION	Dämpfung basierend auf Entfernung oder Schatten.
in vec3 ALBEDO	Basis-Albedo.
in vec3 BACKLIGHT
in float METALLIC	Metallisch.
in float ROUGHNESS	Rauheit.
out vec3 DIFFUSE_LIGHT	Diffuses Licht-Ergebnis.
out vec3 SPECULAR_LIGHT	Specular Licht-Ergebnis.
out float ALPHA	Alpha (range of `[0.0, 1.0]`). If written to, the material will go to the transparent pipeline.

Bemerkung

Shader, welche die transparente Pipeline durchlaufen, wenn in ALPHA geschrieben wird, können Probleme mit der Transparenzsortierung aufweisen. Lesen Sie den Abschnitt Transparenzsortierung in der "3D-Rendering-Beschränkungen"-Seite für weitere Informationen und Möglichkeiten zur Vermeidung von Problemen.

Transparente Materialien können auch keine Schatten werfen oder in hint_screen_texture und hint_depth_texture Uniforms erscheinen. Dies wiederum verhindert, dass diese Materialien in Screen-Space-Reflexionen oder Brechung erscheinen. SDFGI scharfe Reflexionen sind auf transparenten Materialien nicht sichtbar (nur grobe Reflexionen sind auf transparenten Materialien sichtbar).