diff --git a/img/shader_material_convert.png b/img/shader_material_convert.png new file mode 100644 index 000000000..7ea02bd19 Binary files /dev/null and b/img/shader_material_convert.png differ diff --git a/img/shader_material_create.png b/img/shader_material_create.png index 7cd41830f..58f53e4c0 100644 Binary files a/img/shader_material_create.png and b/img/shader_material_create.png differ diff --git a/img/shader_material_editor.png b/img/shader_material_editor.png index e52b5a684..3d0c969ad 100644 Binary files a/img/shader_material_editor.png and b/img/shader_material_editor.png differ diff --git a/learning/features/shading/screen-reading_shaders.rst b/learning/features/shading/screen-reading_shaders.rst index 9fd5c274f..1003ec05c 100644 --- a/learning/features/shading/screen-reading_shaders.rst +++ b/learning/features/shading/screen-reading_shaders.rst @@ -17,67 +17,74 @@ The workaround is to make a copy of the screen, or a part of the screen, to a back-buffer and then read from it while drawing. Godot provides a few tools that makes this process easy! -TexScreen shader instruction -~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +SCREEN_TEXTURE built-in texture. +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -Godot :ref:`doc_shading_language` has a special instruction, "texscreen", it takes as -parameter the UV of the screen and returns a vec3 RGB with the color. A +Godot :ref:`doc_shading_language` has a special texture, "SCREEN_TEXTURE" (and "DEPTH_TEXTURE" for depth, in case of 3D). +It takes as parameter the UV of the screen and returns a vec3 RGB with the color. A special built-in varying: SCREEN_UV can be used to obtain the UV for the current fragment. As a result, this simple 2D fragment shader: :: - COLOR=vec4( texscreen(SCREEN_UV), 1.0 ); + COLOR=textureLod( SCREEN_TEXTURE, SCREEN_UV, 0.0); results in an invisible object, because it just shows what lies behind. -The same shader using the visual editor looks like this: -.. image:: /img/texscreen_visual_shader.png +The reason why textureLod must be used is because, when Godot copies back +a chunk of the screen, it also does an efficient separatable gaussian blur to it's mipmaps. -TexScreen example -~~~~~~~~~~~~~~~~~ +This allows for not only reading from the screen, but reading from it with different amounts +of blur at no cost. -Texscreen instruction can be used for a lot of things. There is a +SCREEN_TEXTURE example +~~~~~~~~~~~~~~~~~~~~~~ + +SCREEN_TEXTURE can be used for a lot of things. There is a special demo for *Screen Space Shaders*, that you can download to see and learn. One example is a simple shader to adjust brightness, contrast and saturation: :: - uniform float brightness = 1.0; - uniform float contrast = 1.0; - uniform float saturation = 1.0; + shader_type canvas_item; - vec3 c = texscreen(SCREEN_UV); + uniform float brightness = 1.0; + uniform float contrast = 1.0; + uniform float saturation = 1.0; - c.rgb = mix(vec3(0.0), c.rgb, brightness); - c.rgb = mix(vec3(0.5), c.rgb, contrast); - c.rgb = mix(vec3(dot(vec3(1.0), c.rgb)*0.33333), c.rgb, saturation); + vec3 c = textureLod(SCREEN_TEXTURE, SCREEN_UV, 0.0).rgb; - COLOR.rgb = c; + c.rgb = mix(vec3(0.0), c.rgb, brightness); + c.rgb = mix(vec3(0.5), c.rgb, contrast); + c.rgb = mix(vec3(dot(vec3(1.0), c.rgb)*0.33333), c.rgb, saturation); + + COLOR.rgb = c; Behind the scenes ~~~~~~~~~~~~~~~~~ -While this seems magical, it's not. The Texscreen instruction, when +While this seems magical, it's not. The SCREEN_TEXTURE built-in, when first found in a node that is about to be drawn, does a full-screen -copy to a back-buffer. Subsequent nodes that use texscreen() in +copy to a back-buffer. Subsequent nodes that use it in shaders will not have the screen copied for them, because this ends up being very inefficient. -As a result, if shaders that use texscreen() overlap, the second one +As a result, if shaders that use SCREEN_TEXTURE overlap, the second one will not use the result of the first one, resulting in unexpected visuals: .. image:: /img/texscreen_demo1.png In the above image, the second sphere (top right) is using the same -source for texscreen() as the first one below, so the first one +source for SCREEN_TEXTURE as the first one below, so the first one "disappears", or is not visible. -To correct this, a -:ref:`BackBufferCopy ` -node can be instanced between both spheres. BackBufferCopy can work by +In 3D, this is unavoidable because copying happens when opaque rendering +completes. + +In 2D this can be corrected via the :ref:`BackBufferCopy ` +node, which can be instantiated between both spheres. BackBufferCopy can work by either specifying a screen region or the whole screen: .. image:: /img/texscreen_bbc.png @@ -92,13 +99,13 @@ Back-buffer logic So, to make it clearer, here's how the backbuffer copying logic works in Godot: -- If a node uses the texscreen(), the entire screen is copied to the +- If a node uses the SCREEN_TEXTURE, the entire screen is copied to the back buffer before drawing that node. This only happens the first time, subsequent nodes do not trigger this. - If a BackBufferCopy node was processed before the situation in the - point above (even if texscreen() was not used), this behavior + point above (even if SCREEN_TEXTURE was not used), this behavior described in the point above does not happen. In other words, - automatic copying of the entire screen only happens if texscreen() is + automatic copying of the entire screen only happens if SCREEN_TEXTURE is used in a node for the first time and no BackBufferCopy node (not disabled) was found before in tree-order. - BackBufferCopy can copy either the entire screen or a region. If set @@ -106,4 +113,23 @@ Godot: not in the region copied, the result of that read is undefined (most likely garbage from previous frames). In other words, it's possible to use BackBufferCopy to copy back a region of the screen - and then use texscreen() on a different region. Avoid this behavior! + and then use SCREEN_TEXTURE on a different region. Avoid this behavior! + + +DEPTH_TEXTURE +~~~~~~~~~~~~ + +For 3D Shaders, it's also possible to access the screen depth buffer. For this, +the DEPTH_TEXTURE built-in is used. This texture is not linear, it must be +converted via the inverse projection matrix. + +The following code retrieves the 3D position below the pixel being drawn: + +:: + + float depth = textureLod(DEPTH_TEXTURE,SCREEN_UV,0.0).r; + vec4 upos = INV_PROJECTION_MATRIX * vec4(SCREEN_UV*2.0-1.0,depth*2.0-1.0,1.0); + vec3 pixel_position = upos.xyz/upos.w; + + + diff --git a/learning/features/shading/shader_materials.rst b/learning/features/shading/shader_materials.rst index bb0cbd9c6..38a3106d8 100644 --- a/learning/features/shading/shader_materials.rst +++ b/learning/features/shading/shader_materials.rst @@ -6,9 +6,13 @@ Shader materials Introduction ------------ -For the most common cases, :ref:`doc_fixed_materials` are enough to create the -desired textures or look and feel. Shader materials are a step beyond -that, adding a huge amount of flexibility. With them, it is possible to: +For the most common cases, Godot provides ready to use materials for +most types of shaders, such as SpatialMaterial, CanvasItemMaterial and +ParticlesMaterial (@TODO link to tutorials/classes). They are flexible implementations that cover most +use cases. + +Shader materials allow writing a custom shader directly, for maximum flexibility. +Examples of this are: - Create procedural textures. - Create complex texture blendings. @@ -16,6 +20,7 @@ that, adding a huge amount of flexibility. With them, it is possible to: - Create refractive effects or other advanced effects. - Create special lighting shaders for more exotic materials. - Animate vertices, like tree leaves or grass. +- Create custom particle code, that responds to baked animations or force fields. - And much more! Traditionally, most engines will ask you to learn GLSL, HLSL or CG, @@ -28,8 +33,7 @@ Creating a ShaderMaterial ------------------------- Create a new ShaderMaterial in some object of your choice. Go to the -"Shader" property, then create a new "MaterialShader" (use -"MaterialShaderGraph" for access to the visual graph editor): +"Material" property and create a ShaderMaterial. .. image:: /img/shader_material_create.png @@ -37,28 +41,15 @@ Edit the newly created shader, and the shader editor will open: .. image:: /img/shader_material_editor.png -There are three code tabs open, the first is for the vertex shader, the -second for the fragment and the third for the lighting. The shader -language is documented in :ref:`doc_shading_language` so a small example will be -presented next. +Converting to ShaderMaterial +---------------------------- -Create a very simple fragment shader that writes a color: +It is possible to convert from SpatialMaterial, CanvasItemMaterial and +ParticlesMaterial to ShaderMaterial. Just go to the material properties +and enable the convert option. -:: +.. image:: /img/shader_material_convert.png - uniform color col; - DIFFUSE = col.rgb; -Code changes take place in real-time. If the code is modified, it will -be instantly recompiled and the object will be updated. If a typo is -made, the editor will notify of the compilation failure: -.. image:: /img/shader_material_typo.png -Finally, go back and edit the material, and the exported uniform will be -instantly visible: - -.. image:: /img/shader_material_col.png - -This allows to very quickly create custom, complex materials for every -type of object. diff --git a/learning/features/shading/shading_language.rst b/learning/features/shading/shading_language.rst index 19d09a5d4..bc7fb5c95 100644 --- a/learning/features/shading/shading_language.rst +++ b/learning/features/shading/shading_language.rst @@ -384,25 +384,30 @@ to make the compiler understand what the uniform is used for. Full list of hints below: -+-------------------+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| Type | Hint | Description | -+===================+===============================+========================================================================================================================================================================================================================+ -| **vec4** | hint_color | This uniform is exported as a color parameter in property editor. Color is also converted from SRGB for 3D shaders. | -+-------------------+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| **int**, **float**| hint_range(min,max [,step] ) | This scalar uniform is exported as a given range in property editor. | -+-------------------+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| **sampler2D** | hint_albedo | This texture is used as albedo color. Godot will try to make sure the texture has SRGB -> Linear conversion turned on. If no texture is supplied, this is assumed to be white. | -+-------------------+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| **sampler2D** | hint_black_albedo | Same as above but, if no texture is supplied, it's assumed to be black. | -+-------------------+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| **sampler2D** | hint_normal | The texture supplied is a normal map. Godot will attempt to convert the texture to a more efficient normalmap format when used here. Also, an empty texture results in a vec3(0.0,0.0,1.0) normal assigned by default. | -+-------------------+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| **sampler2D** | hint_white | Regular texture (non albedo). White is used if unasigned. | -+-------------------+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| **sampler2D** | hint_black | Regular texture (non albedo). Black is used if unassigned. | -+-------------------+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| **sampler2D** | hint_aniso | Same as above, but vec3(1.0, 0.5, 0.0) is assigned by default (useful for flowmaps) | -+-------------------+-------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ++----------------+-------------------------------+-------------------------------------+ +| Type | Hint | Description | ++================+===============================+=====================================+ +| **vec4** | hint_color | Used as color | ++----------------+-------------------------------+-------------------------------------+ +| **int, float** | hint_range(min,max [,step] ) | Used as range (with min/max/step) | ++----------------+-------------------------------+-------------------------------------+ +| **sampler2D** | hint_albedo | Used as albedo color, default white | ++----------------+-------------------------------+-------------------------------------+ +| **sampler2D** | hint_black_albedo | Used as albedo color, default black | ++----------------+-------------------------------+-------------------------------------+ +| **sampler2D** | hint_normal | Used as normalmap | ++----------------+-------------------------------+-------------------------------------+ +| **sampler2D** | hint_white | As value, default to white. | ++----------------+-------------------------------+-------------------------------------+ +| **sampler2D** | hint_black | As value, default to black | ++----------------+-------------------------------+-------------------------------------+ +| **sampler2D** | hint_aniso | As flowmap, default to right. | ++----------------+-------------------------------+-------------------------------------+ + + +As Godot 3D engine renders in linear color space, it's important to understand that textures +that are supplied as color (ie, albedo) need to be specified as such for proper SRGB->linear +conversion. Uniforms can also be assigned default values: @@ -424,157 +429,159 @@ When vec_type (float), vec_int_type, vec_uint_type, vec_bool_type, nomenclature + +-----------------------------------------------------------------------+---------------------------------------------+ | Function | Description | +=======================================================================+=============================================+ -| float *sin* ( float ) | Sine | +| float **sin** ( float ) | Sine | +-----------------------------------------------------------------------+---------------------------------------------+ -| float *cos* ( float ) | Cosine | +| float **cos** ( float ) | Cosine | +-----------------------------------------------------------------------+---------------------------------------------+ -| float *tan* ( float ) | Tangent | +| float **tan** ( float ) | Tangent | +-----------------------------------------------------------------------+---------------------------------------------+ -| float *asin* ( float ) | arc-Sine | +| float **asin** ( float ) | arc-Sine | +-----------------------------------------------------------------------+---------------------------------------------+ -| float *acos* ( float ) | arc-Cosine | +| float **acos** ( float ) | arc-Cosine | +-----------------------------------------------------------------------+---------------------------------------------+ -| float *atan* ( float ) | arc-Tangent | +| float **atan** ( float ) | arc-Tangent | +-----------------------------------------------------------------------+---------------------------------------------+ -| float *atan2* ( float x, float y) | arc-Tangent to convert vector to angle | +| float **atan2** ( float x, float y) | arc-Tangent to convert vector to angle | +-----------------------------------------------------------------------+---------------------------------------------+ -| float *sinh* ( float ) | Hyperbolic-Sine | +| float **sinh** ( float ) | Hyperbolic-Sine | +-----------------------------------------------------------------------+---------------------------------------------+ -| float *cosh* ( float ) | Hyperbolic-Cosine | +| float **cosh** ( float ) | Hyperbolic-Cosine | +-----------------------------------------------------------------------+---------------------------------------------+ -| float *tanh* ( float ) | Hyperbolic-Tangent | +| float **tanh** ( float ) | Hyperbolic-Tangent | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *pow* ( float x, float y) | Power, x elevated to y | +| vec\_type **pow** ( float x, float y) | Power, x elevated to y | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *pow* ( vec\_type, vec\_type ) | Power (Vec. Exponent) | +| vec\_type **pow** ( vec\_type, vec\_type ) | Power (Vec. Exponent) | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *exp* ( vec\_type ) | Base-e Exponential | +| vec\_type **exp** ( vec\_type ) | Base-e Exponential | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *log* ( vec\_type ) | Natural Logarithm | +| vec\_type **log** ( vec\_type ) | Natural Logarithm | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *sqrt* ( vec\_type ) | Square Root | +| vec\_type **sqrt** ( vec\_type ) | Square Root | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *inversesqrt* ( vec\_type ) | Inverse Square Root | +| vec\_type **inversesqrt** ( vec\_type ) | Inverse Square Root | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *abs* ( vec\_type ) | Absolute | +| vec\_type **abs** ( vec\_type ) | Absolute | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *sign* ( vec\_type ) | Sign | +| vec\_type **sign** ( vec\_type ) | Sign | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *floor* ( vec\_type ) | Floor | +| vec\_type **floor** ( vec\_type ) | Floor | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *round* ( vec\_type ) | Round | +| vec\_type **round** ( vec\_type ) | Round | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *trunc* ( vec\_type ) | Trunc | +| vec\_type **trunc** ( vec\_type ) | Trunc | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *ceil* ( vec\_type ) | Ceiling | +| vec\_type **ceil** ( vec\_type ) | Ceiling | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *fract* ( vec\_type ) | Fractional | +| vec\_type **fract** ( vec\_type ) | Fractional | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *mod* ( vec\_type,vec\_type ) | Remainder | +| vec\_type **mod** ( vec\_type,vec\_type ) | Remainder | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *modf* ( vec\_type x,out vec\_type i) | Fractional of x, with i has integer part | +| vec\_type **modf** ( vec\_type x,out vec\_type i) | Fractional of x, with i has integer part | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *min* ( vec\_type,vec\_type ) | Minimum | +| vec\_type **min** ( vec\_type,vec\_type ) | Minimum | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *min* ( vec\_type,vec\_type ) | Maximum | +| vec\_type **min** ( vec\_type,vec\_type ) | Maximum | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *clamp* ( vec\_type value,vec\_type min, vec\_type max ) | Clamp to Min-Max | +| vec\_type **clamp** ( vec\_type value,vec\_type min, vec\_type max ) | Clamp to Min-Max | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *mix* ( vec\_type a,vec\_type b, float c ) | Linear Interpolate | +| vec\_type **mix** ( vec\_type a,vec\_type b, float c ) | Linear Interpolate | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *mix* ( vec\_type a,vec\_type b, vec\_type c ) | Linear Interpolate (Vector Coef.) | +| vec\_type **mix** ( vec\_type a,vec\_type b, vec\_type c ) | Linear Interpolate (Vector Coef.) | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *step* ( vec\_type a,vec\_type b) | \` a[i] < b[i] ? 0.0 : 1.0\` | +| vec\_type **step** ( vec\_type a,vec\_type b) | \` a[i] < b[i] ? 0.0 : 1.0\` | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *smoothstep* ( vec\_type a,vec\_type b,vec\_type c) | | +| vec\_type **smoothstep** ( vec\_type a,vec\_type b,vec\_type c) | | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec_bool_type *isnan* ( vec\_type ) | scalar, or vector component being nan | +| vec_bool_type **isnan** ( vec\_type ) | scalar, or vector component being nan | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec_bool_type *isinf* ( vec\_type ) | scalar, or vector component being inf | +| vec_bool_type **isinf** ( vec\_type ) | scalar, or vector component being inf | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec_int_type *floatBitsToInt* ( vec_type ) | Float->Int bit copying, no conversion | +| vec_int_type **floatBitsToInt** ( vec_type ) | Float->Int bit copying, no conversion | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec_uint_type *floatBitsToUInt* ( vec_type ) | Float->UInt bit copying, no conversion | +| vec_uint_type **floatBitsToUInt** ( vec_type ) | Float->UInt bit copying, no conversion | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec_type *intBitsToFloat* ( vec_int_type ) | Int->Float bit copying, no conversion | +| vec_type **intBitsToFloat** ( vec_int_type ) | Int->Float bit copying, no conversion | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec_type *uintBitsToFloat* ( vec_uint_type ) | UInt->Float bit copying, no conversion | +| vec_type **uintBitsToFloat** ( vec_uint_type ) | UInt->Float bit copying, no conversion | +-----------------------------------------------------------------------+---------------------------------------------+ -| float *length* ( vec\_type ) | Vector Length | +| float **length** ( vec\_type ) | Vector Length | +-----------------------------------------------------------------------+---------------------------------------------+ -| float *distance* ( vec\_type, vec\_type ) | Distance between vector. | +| float **distance** ( vec\_type, vec\_type ) | Distance between vector. | +-----------------------------------------------------------------------+---------------------------------------------+ -| float *dot* ( vec\_type, vec\_type ) | Dot Product | +| float **dot** ( vec\_type, vec\_type ) | Dot Product | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec3 *cross* ( vec3, vec3 ) | Cross Product | +| vec3 **cross** ( vec3, vec3 ) | Cross Product | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_type *normalize* ( vec\_type ) | Normalize to unit length | +| vec\_type **normalize** ( vec\_type ) | Normalize to unit length | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec3 *reflect* ( vec3, vec3 ) | Reflect | +| vec3 **reflect** ( vec3, vec3 ) | Reflect | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec3 *refract* ( vec3, vec3 ) | Refract | +| vec3 **refract** ( vec3, vec3 ) | Refract | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec_type *faceforward* ( vec_type N, vec_type I, vec_type NRef) | If dot(Nref, I) < 0 return N, otherwise –N | +| vec_type **faceforward** ( vec_type N, vec_type I, vec_type NRef) | If dot(Nref, I) < 0 return N, otherwise –N | +-----------------------------------------------------------------------+---------------------------------------------+ -| mat_type *matrixCompMult* ( mat_type, mat_type ) | Matrix Component Multiplication | +| mat_type **matrixCompMult** ( mat_type, mat_type ) | Matrix Component Multiplication | +-----------------------------------------------------------------------+---------------------------------------------+ -| mat_type *outerProduct* ( vec_type, vec_type ) | Matrix Outer Product | +| mat_type **outerProduct** ( vec_type, vec_type ) | Matrix Outer Product | +-----------------------------------------------------------------------+---------------------------------------------+ -| mat_type *transpose* ( mat_type ) | Transpose Matrix | +| mat_type **transpose** ( mat_type ) | Transpose Matrix | +-----------------------------------------------------------------------+---------------------------------------------+ -| float *determinant* ( mat_type ) | Matrix Determinant | +| float **determinant** ( mat_type ) | Matrix Determinant | +-----------------------------------------------------------------------+---------------------------------------------+ -| mat_type *inverse* ( mat_type ) | Inverse Matrix | +| mat_type **inverse** ( mat_type ) | Inverse Matrix | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_bool_type *lessThan* ( vec_scalar_type ) | Bool vector cmp on < int/uint/float vectors | +| vec\_bool_type **lessThan** ( vec_scalar_type ) | Bool vector cmp on < int/uint/float vectors | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_bool_type *greaterThan* ( vec_scalar_type ) | Bool vector cmp on > int/uint/float vectors | +| vec\_bool_type **greaterThan** ( vec_scalar_type ) | Bool vector cmp on > int/uint/float vectors | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_bool_type *lessThanEqual* ( vec_scalar_type ) | Bool vector cmp on <=int/uint/float vectors | +| vec\_bool_type **lessThanEqual** ( vec_scalar_type ) | Bool vector cmp on <=int/uint/float vectors | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_bool_type *greaterThanEqual* ( vec_scalar_type ) | Bool vector cmp on >=int/uint/float vectors | +| vec\_bool_type **greaterThanEqual** ( vec_scalar_type ) | Bool vector cmp on >=int/uint/float vectors | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_bool_type *equal* ( vec_scalar_type ) | Bool vector cmp on ==int/uint/float vectors | +| vec\_bool_type **equal** ( vec_scalar_type ) | Bool vector cmp on ==int/uint/float vectors | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec\_bool_type *notEqual* ( vec_scalar_type ) | Bool vector cmp on !=int/uint/float vectors | +| vec\_bool_type **notEqual** ( vec_scalar_type ) | Bool vector cmp on !=int/uint/float vectors | +-----------------------------------------------------------------------+---------------------------------------------+ -| bool *any* ( vec_bool_type ) | Any component is true | +| bool **any** ( vec_bool_type ) | Any component is true | +-----------------------------------------------------------------------+---------------------------------------------+ -| bool *all* ( vec_bool_type ) | All components are true | +| bool **all** ( vec_bool_type ) | All components are true | +-----------------------------------------------------------------------+---------------------------------------------+ -| bool *not* ( vec_bool_type ) | No components are true | +| bool **not** ( vec_bool_type ) | No components are true | +-----------------------------------------------------------------------+---------------------------------------------+ -| ivec2 *textureSize* ( sampler2D_type s, int lod ) | Get the size of a texture | +| ivec2 **textureSize** ( sampler2D_type s, int lod ) | Get the size of a texture | +-----------------------------------------------------------------------+---------------------------------------------+ -| ivec2 *textureSize* ( samplerCube s, int lod ) | Get the size of a cubemap | +| ivec2 **textureSize** ( samplerCube s, int lod ) | Get the size of a cubemap | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec4_type *texture* ( sampler2D_type s, vec2 uv [, float bias]) | Perform a 2D texture read | +| vec4_type **texture** ( sampler2D_type s, vec2 uv [, float bias]) | Perform a 2D texture read | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec4 *texture* ( samplerCube s, vec3 uv [, float bias]) | Perform a Cube texture read | +| vec4 **texture** ( samplerCube s, vec3 uv [, float bias]) | Perform a Cube texture read | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec4_type *textureProj* ( sampler2d_type s, vec3 uv [, float bias]) | Perform a texture read with projection | +| vec4_type **textureProj** ( sampler2d_type s, vec3 uv [, float bias]) | Perform a texture read with projection | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec4_type *textureProj* ( sampler2d_type s, vec4 uv [, float bias]) | Perform a texture read with projection | +| vec4_type **textureProj** ( sampler2d_type s, vec4 uv [, float bias]) | Perform a texture read with projection | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec4_type *textureLod* ( sampler2D_type s, vec2 uv , float lod) | Perform a 2D texture read at custom mipmap | +| vec4_type **textureLod** ( sampler2D_type s, vec2 uv , float lod) | Perform a 2D texture read at custom mipmap | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec4_type *textureProjLod* ( sampler2d_type s, vec3 uv , float lod) | Perform a texture read with projection/lod | +| vec4_type **textureProjLod** ( sampler2d_type s, vec3 uv , float lod) | Perform a texture read with projection/lod | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec4_type *textureProjLod* ( sampler2d_type s, vec4 uv , float lod) | Perform a texture read with projection/lod | +| vec4_type **textureProjLod** ( sampler2d_type s, vec4 uv , float lod) | Perform a texture read with projection/lod | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec_type *texelFetch* ( samplerCube s, ivec2 uv, int lod ) | Fetch a single texel using integer coords | +| vec_type **texelFetch** ( samplerCube s, ivec2 uv, int lod ) | Fetch a single texel using integer coords | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec_type *dFdx* ( vec_type ) | Derivative in x using local differencing | +| vec_type **dFdx** ( vec_type ) | Derivative in x using local differencing | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec_type *dFdy* ( vec_type ) | Derivative in y using local differencing | +| vec_type **dFdy** ( vec_type ) | Derivative in y using local differencing | +-----------------------------------------------------------------------+---------------------------------------------+ -| vec_type *fwidth* ( vec_type ) | Sum of absolute derivative in x and y | +| vec_type **fwidth** ( vec_type ) | Sum of absolute derivative in x and y | +-----------------------------------------------------------------------+---------------------------------------------+ + Shader Types In-Depth ------------------ @@ -846,7 +853,7 @@ Light Built-Ins +----------------------------------+------------------------------------------+ | in vec3 **TRANSMISSION** | Transmission mask. | +----------------------------------+------------------------------------------+ -| in float **roughness** | Roughness. | +| in float **ROUGHNESS** | Roughness. | +----------------------------------+------------------------------------------+ | out vec3 **DIFFUSE_LIGHT** | Diffuse light result. | +----------------------------------+------------------------------------------+