godotengine/godot-docs
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs.git synced 2026-01-04 14:11:02 +03:00
Code Issues Packages Projects Releases Wiki Activity

Update shader built-ins

Browse Source
This commit is contained in:
Chaosus
2019-07-11 19:34:06 +03:00
parent 305b71c999
commit 9bfd4c400c
1 changed files with 197 additions and 179 deletions
Download Patch File Download Diff File Expand all files Collapse all files

376
tutorials/shading/shading_reference/shading_language.rst
View File

@@ -448,182 +448,200 @@ When vec_type (float), vec_int_type, vec_uint_type, vec_bool_type nomenclature i
.. note:: For a list of the functions that are not available in the GLES2 backend, please see the
:ref:`Differences between GLES2 and GLES3 doc <doc_gles2_gles3_differences>`.
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| Function | Description |
+===============================================================================================+================================================+
| vec_type **radians** ( vec_type ) | Convert degrees to radians |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **degrees** ( vec_type ) | Convert radians to degrees |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **sin** ( vec_type ) | Sine |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **cos** ( vec_type ) | Cosine |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **tan** ( vec_type ) | Tangent |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **asin** ( vec_type ) | Arc-Sine |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **acos** ( vec_type ) | Arc-Cosine |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **atan** ( vec_type ) | Arc-Tangent |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **atan** ( vec_type x, vec_type y ) | Arc-Tangent to convert vector to angle |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **sinh** ( vec_type ) | Hyperbolic-Sine |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **cosh** ( vec_type ) | Hyperbolic-Cosine |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **tanh** ( vec_type ) | Hyperbolic-Tangent |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **asinh** ( vec_type ) | Inverse-Hyperbolic-Sine |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **acosh** ( vec_type ) | Inverse-Hyperbolic-Cosine |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **atanh** ( vec_type ) | Inverse-Hyperbolic-Tangent |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **pow** ( vec_type, vec_type ) | Power |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **exp** ( vec_type ) | Base-e Exponential |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **exp2** ( vec_type ) | Base-2 Exponential |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **log** ( vec_type ) | Natural Logarithm |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **log2** ( vec_type ) | Base-2 Logarithm |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **sqrt** ( vec_type ) | Square Root |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **inversesqrt** ( vec_type ) | Inverse Square Root |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **abs** ( vec_type ) | Absolute |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_int_type **abs** ( vec_int_type ) | Absolute |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **sign** ( vec_type ) | Sign |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_int_type **sign** ( vec_int_type ) | Sign |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **floor** ( vec_type ) | Floor |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **round** ( vec_type ) | Round |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **roundEven** ( vec_type ) | Round nearest even |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **trunc** ( vec_type ) | Truncation |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **ceil** ( vec_type ) | Ceiling |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **fract** ( vec_type ) | Fractional |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **mod** ( vec_type, vec_type ) | Remainder |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **mod** ( vec_type, float ) | Remainder |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **modf** ( vec_type x, out vec_type i ) | Fractional of x, with i has integer part |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_scalar_type **min** ( vec_scalar_type a, vec_scalar_type b ) | Minimum |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_scalar_type **max** ( vec_scalar_type a, vec_scalar_type b ) | Maximum |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_scalar_type **clamp** ( vec_scalar_type value, vec_scalar_type min, vec_scalar_type max ) | Clamp to Min-Max |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **mix** ( vec_type a, vec_type b, float c ) | Linear Interpolate (Scalar Coef.) |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| 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, bool c ) | Linear Interpolate (Bool Selection) |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **mix** ( vec_type a, vec_type b, vec_bool_type c ) | Linear Interpolate (Bool-Vector Selection) |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **step** ( vec_type a, vec_type b ) | ``b[i] < a[i] ? 0.0 : 1.0`` |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **step** ( float a, vec_type b ) | ``b[i] < a ? 0.0 : 1.0`` |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **smoothstep** ( vec_type a, vec_type b, vec_type c ) | Hermite Interpolate |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **smoothstep** ( float a, float b, vec_type c ) | Hermite Interpolate |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| 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_int_type **floatBitsToInt** ( vec_type ) | Float->Int 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 **uintBitsToFloat** ( vec_uint_type ) | UInt->Float bit copying, no conversion |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| float **length** ( vec_type ) | Vector Length |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| float **distance** ( vec_type, vec_type ) | Distance between vector |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| float **dot** ( vec_type, vec_type ) | Dot Product |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec3 **cross** ( vec3, vec3 ) | Cross Product |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **normalize** ( vec_type ) | Normalize to unit length |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec3 **reflect** ( vec3 I, vec3 N ) | Reflect |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec3 **refract** ( vec3 I, vec3 N, float eta ) | Refract |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| 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 **outerProduct** ( vec_type, vec_type ) | Matrix Outer Product |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| mat_type **transpose** ( mat_type ) | Transpose Matrix |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| float **determinant** ( mat_type ) | Matrix Determinant |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| mat_type **inverse** ( mat_type ) | Inverse Matrix |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_bool_type **lessThan** ( vec_scalar_type, vec_scalar_type ) | Bool vector cmp on < int/uint/float vectors |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_bool_type **greaterThan** ( vec_scalar_type, vec_scalar_type ) | Bool vector cmp on > int/uint/float vectors |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_bool_type **lessThanEqual** ( vec_scalar_type, vec_scalar_type ) | Bool vector cmp on <= int/uint/float vectors |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_bool_type **greaterThanEqual** ( vec_scalar_type, vec_scalar_type ) | Bool vector cmp on >= int/uint/float vectors |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_bool_type **equal** ( vec_scalar_type, vec_scalar_type ) | Bool vector cmp on == int/uint/float vectors |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_bool_type **notEqual** ( vec_scalar_type, vec_scalar_type ) | Bool vector cmp on != int/uint/float vectors |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| bool **any** ( vec_bool_type ) | Any component is true |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| bool **all** ( vec_bool_type ) | All 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** ( 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** ( 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, 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** ( samplerCube s, vec3 uv, float lod ) | Perform a Cube 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, vec4 uv, float lod ) | Perform a texture read with projection/lod |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec4_type **texelFetch** ( sampler2D_type 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 **dFdy** ( vec_type ) | Derivative in y using local differencing |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
| vec_type **fwidth** ( vec_type ) | Sum of absolute derivative in x and y |
+-----------------------------------------------------------------------------------------------+------------------------------------------------+
+----------------------------------------------------------------------------+--------------------------------------------------+
| Function | Description |
+============================================================================+==================================================+
| vec_type **radians** ( vec_type degrees ) | Convert degrees to radians |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **degrees** ( vec_type radians ) | Convert radians to degrees |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **sin** ( vec_type x ) | Sine |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **cos** ( vec_type x ) | Cosine |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **tan** ( vec_type x ) | Tangent |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **asin** ( vec_type x ) | Arc-Sine |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **acos** ( vec_type x ) | Arc-Cosine |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **atan** ( vec_type y_over_x ) | Arc-Tangent |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **atan** ( vec_type y, vec_type x ) | Arc-Tangent to convert vector to angle |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **sinh** ( vec_type x ) | Hyperbolic-Sine |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **cosh** ( vec_type x ) | Hyperbolic-Cosine |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **tanh** ( vec_type x ) | Hyperbolic-Tangent |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **asinh** ( vec_type x ) | Inverse-Hyperbolic-Sine |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **acosh** ( vec_type x ) | Inverse-Hyperbolic-Cosine |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **atanh** ( vec_type x ) | Inverse-Hyperbolic-Tangent |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **pow** ( vec_type x, vec_type y ) | Power |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **exp** ( vec_type x ) | Base-e Exponential |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **exp2** ( vec_type x ) | Base-2 Exponential |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **log** ( vec_type x ) | Natural Logarithm |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **log2** ( vec_type x ) | Base-2 Logarithm |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **sqrt** ( vec_type x ) | Square Root |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **inversesqrt** ( vec_type x ) | Inverse Square Root |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **abs** ( vec_type x ) | Absolute |
+----------------------------------------------------------------------------+--------------------------------------------------+
| ivec_type **abs** ( ivec_type x ) | Absolute |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **sign** ( vec_type x ) | Sign |
+----------------------------------------------------------------------------+--------------------------------------------------+
| ivec_type **sign** ( ivec_type x ) | Sign |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **floor** ( vec_type x ) | Floor |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **round** ( vec_type x ) | Round |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **roundEven** ( vec_type x ) | Round nearest even |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **trunc** ( vec_type x ) | Truncation |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **ceil** ( vec_type x ) | Ceil |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **fract** ( vec_type x ) | Fractional |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **mod** ( vec_type x, vec_type y ) | Remainder |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **mod** ( vec_type x , float y ) | Remainder |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **modf** ( vec_type x, out vec_type i ) | Fractional of x, with i has integer part |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **min** ( vec_type a, vec_type b ) | Minimum |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **max** ( vec_type a, vec_type b ) | Maximum |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **clamp** ( vec_type x, vec_type min, vec_type max ) | Clamp to Min-Max |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **mix** ( float a, float b, float c ) | Linear Interpolate |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **mix** ( vec_type a, vec_type b, float c ) | Linear Interpolate (Scalar Coef.) |
+----------------------------------------------------------------------------+--------------------------------------------------+
| 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, bvec_type c ) | Linear Interpolate (Boolean-Vector Selection) |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **step** ( vec_type a, vec_type b ) | ``b[i] < a[i] ? 0.0 : 1.0`` |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **step** ( float a, vec_type b) | ``b[i] < a ? 0.0 : 1.0`` |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **smoothstep** ( vec_type a, vec_type b, vec_type c ) | Hermite Interpolate |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **smoothstep** ( float a, float b, vec_type c ) | Hermite Interpolate |
+----------------------------------------------------------------------------+--------------------------------------------------+
| bvec_type **isnan** ( vec_type x ) | Scalar, or vector component being NaN |
+----------------------------------------------------------------------------+--------------------------------------------------+
| bvec_type **isinf** ( vec_type x ) | Scalar, or vector component being INF |
+----------------------------------------------------------------------------+--------------------------------------------------+
| ivec_type **floatBitsToInt** ( vec_type x ) | Float->Int bit copying, no conversion |
+----------------------------------------------------------------------------+--------------------------------------------------+
| uvec_type **floatBitsToUint** ( vec_type x ) | Float->UInt bit copying, no conversion |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **intBitsToFloat** ( ivec_type x ) | Int->Float bit copying, no conversion |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **uintBitsToFloat** ( uvec_type x ) | UInt->Float bit copying, no conversion |
+----------------------------------------------------------------------------+--------------------------------------------------+
| float **length** ( vec_type x ) | Vector Length |
+----------------------------------------------------------------------------+--------------------------------------------------+
| float **distance** ( vec_type a, vec_type b ) | Distance between vectors i.e ``length(a - b)`` |
+----------------------------------------------------------------------------+--------------------------------------------------+
| float **dot** ( vec_type a, vec_type b ) | Dot Product |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec3 **cross** ( vec3 a, vec3 b ) | Cross Product |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **normalize** ( vec_type x ) | Normalize to unit length |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec3 **reflect** ( vec3 I, vec3 N ) | Reflect |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec3 **refract** ( vec3 I, vec3 N, float eta ) | Refract |
+----------------------------------------------------------------------------+--------------------------------------------------+
| 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 x, mat_type y ) | Matrix Component Multiplication |
+----------------------------------------------------------------------------+--------------------------------------------------+
| mat_type **outerProduct** ( vec_type column, vec_type row ) | Matrix Outer Product |
+----------------------------------------------------------------------------+--------------------------------------------------+
| mat_type **transpose** ( mat_type m ) | Transpose Matrix |
+----------------------------------------------------------------------------+--------------------------------------------------+
| float **determinant** ( mat_type m ) | Matrix Determinant |
+----------------------------------------------------------------------------+--------------------------------------------------+
| mat_type **inverse** ( mat_type m ) | Inverse Matrix |
+----------------------------------------------------------------------------+--------------------------------------------------+
| bvec_type **lessThan** ( vec_type x, vec_type y ) | Bool vector cmp on < int/uint/float vectors |
+----------------------------------------------------------------------------+--------------------------------------------------+
| bvec_type **greaterThan** ( vec_type x, vec_type y ) | Bool vector cmp on > int/uint/float vectors |
+----------------------------------------------------------------------------+--------------------------------------------------+
| bvec_type **lessThanEqual** ( vec_type x, vec_type y ) | Bool vector cmp on <= int/uint/float vectors |
+----------------------------------------------------------------------------+--------------------------------------------------+
| bvec_type **greaterThanEqual** ( vec_type x, vec_type y ) | Bool vector cmp on >= int/uint/float vectors |
+----------------------------------------------------------------------------+--------------------------------------------------+
| bvec_type **equal** ( vec_type x, vec_type y ) | Bool vector cmp on == int/uint/float vectors |
+----------------------------------------------------------------------------+--------------------------------------------------+
| bvec_type **notEqual** ( vec_type x, vec_type y ) | Bool vector cmp on != int/uint/float vectors |
+----------------------------------------------------------------------------+--------------------------------------------------+
| bool **any** ( bvec_type x ) | Any component is true |
+----------------------------------------------------------------------------+--------------------------------------------------+
| bool **all** ( bvec_type x ) | All components are true |
+----------------------------------------------------------------------------+--------------------------------------------------+
| bvec_type **not** ( bvec_type x ) | Invert boolean vector |
+----------------------------------------------------------------------------+--------------------------------------------------+
| ivec2 **textureSize** ( sampler2D_type s, int lod ) | Get the size of a 2D texture |
+----------------------------------------------------------------------------+--------------------------------------------------+
| ivec3 **textureSize** ( sampler2DArray_type s, int lod ) | Get the size of a 2D texture array |
+----------------------------------------------------------------------------+--------------------------------------------------+
| ivec3 **textureSize** ( sampler3D s, int lod ) | Get the size of a 3D texture |
+----------------------------------------------------------------------------+--------------------------------------------------+
| ivec2 **textureSize** ( samplerCube s, int lod ) | Get the size of a Cube texture |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec4_type **texture** ( sampler2D_type s, vec2 uv [, float bias] ) | Perform a 2D texture read |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec4_type **texture** ( sampler2DArray_type s, vec3 uv [, float bias] ) | Perform a 2D texture array read |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec4_type **texture** ( sampler3D_type s, vec3 uv [, float bias] ) | Perform a 3D texture read |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec4 **texture** ( samplerCube s, vec3 uv [, float bias] ) | Perform an Cube texture read |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec4_type **textureProj** ( sampler2D_type s, vec3 uv [, float bias] ) | Perform a 2D texture read with projection |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec4_type **textureProj** ( sampler2D_type s, vec4 uv [, float bias] ) | Perform a 2D texture read with projection |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec4_type **textureProj** ( sampler3D_type s, vec4 uv [, float bias] ) | Perform a 3D 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** ( sampler2DArray_type s, vec3 uv, float lod ) | Perform a 2D texture array read at custom mipmap |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec4_type **textureLod** ( sampler3D_type s, vec3 uv, float lod ) | Perform a 3D texture read at custom mipmap |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec4 **textureLod** ( samplerCube s, vec3 uv, float lod ) | Perform a 3D texture read at custom mipmap |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec4_type **textureProjLod** ( sampler2D_type s, vec3 uv, float lod ) | Perform a 2D texture read with projection/lod |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec4_type **textureProjLod** ( sampler2D_type s, vec4 uv, float lod ) | Perform a 2D texture read with projection/lod |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec4_type **texelFetch** ( sampler2D_type s, ivec2 uv, int lod ) | Fetch a single texel using integer coords |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec4_type **texelFetch** ( sampler2DArray_type s, ivec3 uv, int lod ) | Fetch a single texel using integer coords |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec4_type **texelFetch** ( sampler3D_type s, ivec3 uv, int lod ) | Fetch a single texel using integer coords |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **dFdx** ( vec_type p ) | Derivative in x using local differencing |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **dFdy** ( vec_type p ) | Derivative in y using local differencing |
+----------------------------------------------------------------------------+--------------------------------------------------+
| vec_type **fwidth** ( vec_type p ) | Sum of absolute derivative in x and y |
+----------------------------------------------------------------------------+--------------------------------------------------+