TSL

TSL function for creating a Break() expression.

TSL function for creating a const node.

TSL function for creating a Continue() expression.

Represents a discard shader operation in TSL.

Represent a conditional node using if/else statements.

If( condition, function )
	.ElseIf( condition, function )
	.Else( function )

TSL function for creating a loop node.

Represents a return shader operation in TSL.

Represent a conditional node using switch/case statements.

Switch( value )
	.Case( 1, function )
	.Case( 2, 3, 4, function )
	.Default( function )

TSL function for creating a var node.

TSL function for creating a var intent node.

Returns the absolute value of the parameter.

ACESFilmic tone mapping.

Reference: https://github.com/selfshadow/ltc_code/blob/master/webgl/shaders/ltc/ltc_blit.fs

Returns the arccosine of the parameter.

Returns the addition of two or more value.

TSL function for creating an after image node for post processing.

AgX tone mapping.

Returns true if all components of x are true.

TSL function for creating an anaglyph pass node.

TSL function for creating an anamorphic flare effect.

Performs a logical AND operation on multiple nodes.

Returns true if any components of x are true.

TSL function for creating a Ground Truth Ambient Occlusion (GTAO) effect.

TSL function for creating an array node.

Returns the arcsine of the parameter.

TSL function for creating an assign node.

Returns the arc-tangent of the parameter. If two parameters are provided, the result is atan2(y/x).

Returns the arc-tangent of the quotient of its parameters.

Increments the value stored in the atomic variable.

Stores in an atomic variable the bitwise AND of its value with a parameter.

TSL function for appending an atomic function call into the programmatic flow of a compute shader.

Loads the value stored in the atomic variable.

Stores in an atomic variable the maximum between its current value and a parameter.

Stores in an atomic variable the minimum between its current value and a parameter.

TSL function for creating an atomic function node.

Stores in an atomic variable the bitwise OR of its value with a parameter.

Stores a value in the atomic variable.

Decrements the value stored in the atomic variable.

Stores in an atomic variable the bitwise XOR of its value with a parameter.

TSL function for creating an attribute node.

TSL function for creating a storage buffer node with a configured StorageBufferAttribute.

TSL function for creating a barrier node.

TSL function for creating a batch node.

TSL function for computing bent normals.

This can be used to achieve a billboarding behavior for flat meshes. That means they are oriented always towards the camera.

material.vertexNode = billboarding();

Performs bitwise AND on two nodes.

Performs bitwise NOT on a node.

Performs bitwise OR on two nodes.

Performs bitwise XOR on two nodes.

Reinterpret the bit representation of a value in one type as a value in another type.

Applies a bleach bypass effect to the given color node.

Represents a "Color Burn" blend mode.

It's designed to darken the base layer's colors based on the color of the blend layer. It significantly increases the contrast of the base layer, making the colors more vibrant and saturated. The darker the color in the blend layer, the stronger the darkening and contrast effect on the base layer.

This function blends two color based on their alpha values by replicating the behavior of THREE.NormalBlending. It assumes both input colors have non-premultiplied alpha.

Represents a "Color Dodge" blend mode.

It's designed to lighten the base layer's colors based on the color of the blend layer. It significantly increases the brightness of the base layer, making the colors lighter and more vibrant. The brighter the color in the blend layer, the stronger the lightening and contrast effect on the base layer.

Represents a "Overlay" blend mode.

It's designed to increase the contrast of the base layer based on the color of the blend layer. It amplifies the existing colors and contrast in the base layer, making lighter areas lighter and darker areas darker. The color of the blend layer significantly influences the resulting contrast and color shift in the base layer.

Represents a "Screen" blend mode.

Similar to blendDodge(), this mode also lightens the base layer's colors based on the color of the blend layer. The "Screen" blend mode is better for general brightening whereas the "Dodge" results in more subtle and nuanced effects.

TSL function for creating a bloom effect.

Applies a box blur effect to the given texture node.

Compared to Gaussian blur, box blur produces a more blocky result but with better performance when correctly configured. It is intended for mobile devices or performance restricted use cases where Gaussian is too heavy.

The (kernel) size parameter should be small (1, 2 or 3) since it determines the number of samples based on (size * 2 + 1)^2. This implementation uses a single pass approach so the kernel is not applied as a separable filter. That means larger kernels won't perform well. Use Gaussian instead if you need a more high-quality blur.

To produce wider blurs, increase the separation parameter instead which has no influence on the performance.

Reference: https://github.com/lettier/3d-game-shaders-for-beginners/blob/master/demonstration/shaders/fragment/box-blur.frag.

TSL function for creating a buffer node.

TSL function for creating a buffer attribute node.

TSL function for creating a builtin node.

TSL function for defining a built-in ambient occlusion context for a given node.

TSL function for defining a built-in shadow context for a given node.

TSL function for creating a bump map node.

TSL function for creating a bypass node.

TSL function for creating a cache node.

Returns the cube root of a number.

Color Decision List (CDL) v1.2

Compact representation of color grading information, defined by slope, offset, power, and saturation. The CDL should be typically be given input in a log space (such as LogC, ACEScc, or AgX Log), and will return output in the same space. Output may require clamping >=0.

Finds the nearest integer that is greater than or equal to the parameter.

Creates a 2x2 checkerboard pattern that can be used as procedural texture data.

TSL function for creating a chromatic aberration node for post processing.

Cineon tone mapping.

Reference: http://filmicworlds.com/blog/filmic-tonemapping-operators/

TSL function that checks if a circle intersects with an axis-aligned bounding box (AABB).

Constrains a value to lie between two further values.

TSL function for setting up the default clipping logic.

TSL function for setting up alpha to coverage.

TSL function for creating a code node.

TSL function for converting a given color node from the given color space to the current working color space.

Unpacks a color value into a direction vector.

TSL function for creating a compute node.

TSL function for creating a compute builtin node.

TSL function for creating a compute kernel node.

TSL function for computing skinning.

TSL function for creating a context node.

TSL function for converting a given color node from one color space to another one.

TSL function for converting nodes to textures nodes.

Returns the cosine of the parameter.

Finds the number of consecutive 0 bits starting from the most significant bit of the input value.

Can only be used with WebGPURenderer and a WebGPU backend.

Finds the number of '1' bits set in the input value

Can only be used with WebGPURenderer and a WebGPU backend.

Finds the number of consecutive 0 bits from the least significant bit of the input value, which is also the index of the least significant bit of the input value.

Can only be used with WebGPURenderer and a WebGPU backend.

TSL function for creating a var node.

Calculates the cross product of two vectors.

TSL function for creating a cube map node.

TSL function for creating a cube texture uniform node.

TSL function for creating a cube texture node.

Returns the partial derivative of the parameter with respect to x.

Returns the partial derivative of the parameter with respect to y.

TSL function for creating a debug node.

Decrements a node by 1 and returns the previous value.

Decrements a node by 1.

Convert a quantity in radians to degrees.

TSL function for creating a denoise effect.

Represents an exponential squared fog. This type of fog gives a clear view near the camera and a faster than exponentially densening fog farther from the camera.

TSL function for defining a value for the current fragment's depth.

TSL function for creating a depth pass node.

Returns the determinant of a matrix.

Calculates the absolute difference between two values.

Packs a direction vector into a color value.

Calculates the distance between two points.

Returns the division of two or more value.

TSL function for creating a depth-of-field effect (DOF) for post processing.

Calculates the dot product of two vectors.

TSL function for creating a dot-screen node for post processing.

TSL function for creating a buffer attribute node but with dynamic draw usage. Use this function if attribute data are updated per frame.

Checks if two nodes are equal.

Returns true if x equals y.

TSL function for creating an equirect uv node.

Can be used to compute texture coordinates for projecting an equirectangular texture onto a mesh for using it as the scene's background.

scene.backgroundNode = texture( equirectTexture, equirectUV() );

Returns the natural exponentiation of the parameter.

Returns 2 raised to the power of the parameter.

TSL function for creating an expression node.

Returns a vector pointing in the same direction as another.

TSL function for creating a film node for post processing.

Bitcasts a float or a vector of floats to a corresponding integer type with the same element size.

Bitcasts a float or a vector of floats to a corresponding unsigned integer type with the same element size.

Finds the nearest integer less than or equal to the parameter.

This class can be used to configure a fog for the scene. Nodes of this type are assigned to Scene.fogNode.

Computes the fractional part of the parameter.

Returns the sum of the absolute derivatives in x and y.

TSL function for creating a FXAA node for anti-aliasing via post processing.

A function that remaps the [0,1] interval into the [0,1] interval. Expands the sides and compresses the center, and keeps 0.5 mapped to 0.5. Reference: https://iquilezles.org/articles/functions/.

TSL function for creating a gaussian blur node for post processing.

Computes a normal vector based on depth data. Can be used as a fallback when no normal render target is available or if flat surface normals are required.

This computes a parallax corrected normal which is used for box-projected cube mapping (BPCEM).

Reference: https://devlog-martinsh.blogspot.com/2011/09/box-projected-cube-environment-mapping.html

const uvNode = getParallaxCorrectNormal( reflectVector, vec3( 200, 100, 100 ), vec3( 0, - 50, 0 ) );
material.envNode = pmremTexture( renderTarget.texture, uvNode );

Computes a screen position expressed as uv coordinates based on a fragment's position in view space and the camera's projection matrix

Retrieves or creates a shadow material for the given light source.

This function checks if a shadow material already exists for the provided light. If not, it creates a new NodeMaterial configured for shadow rendering and stores it in the shadowMaterialLib for future use.

Creates a function to render shadow objects in a scene.

Computes a position in view space based on a fragment's screen position expressed as uv coordinates, the fragments depth value and the camera's inverse projection matrix.

TSL function for creating a GLSL code node.

Computes a grayscale value for the given RGB color value.

Checks if the first node is greater than the second.

Checks if the first node is greater than or equal to the second.

TSL function for setting up hardware-based clipping.

Generates a hash value in the range [0, 1] from the given seed.

Applies a hash blur effect to the given texture node.

The approach of this blur is different compared to Gaussian and box blur since it does not rely on a kernel to apply a convolution. Instead, it reads the base texture multiple times in a random pattern and then averages the samples. A typical artifact of this technique is a slightly noisy appearance of the blur which can be mitigated by increasing the number of iterations (see repeats parameter). Compared to Gaussian blur, hash blur requires just a single pass.

Reference: https://www.shadertoy.com/view/4lXXWn.

Updates the hue component of the given RGB color while preserving its luminance and saturation.

Increments a node by 1 and returns the previous value.

Increments a node by 1.

Creates an inspector node to wrap around a given node for inspection purposes.

TSL function for creating an instance node.

TSL function for creating a storage buffer node with a configured StorageInstancedBufferAttribute.

TSL function for creating a buffer attribute node but with enabled instancing

TSL function for creating a buffer attribute node but with dynamic draw usage and enabled instancing

TSL function for creating an instanced mesh node.

Bitcasts an integer or a vector of integers to a corresponding float type with the same element size.

Interleaved Gradient Noise (IGN) from Jimenez 2014.

IGN has "low discrepancy" resulting in evenly distributed samples. It's superior compared to default white noise, blue noise or Bayer.

References:

• https://www.iryoku.com/next-generation-post-processing-in-call-of-duty-advanced-warfare/
• https://blog.demofox.org/2022/01/01/interleaved-gradient-noise-a-different-kind-of-low-discrepancy-sequence/

Returns the inverse of a matrix.

Returns the inverse of the square root of the parameter.

TSL function for creating a cache node.

TSL function for creating a JS code node.

TSL function for defining a label context value for a given node.

Calculates the length of a vector.

Calculate the squared length of a vector.

TSL function for creating a bloom-based lens flare effect.

Checks if the first node is less than the second.

Checks if the first node is less than or equal to the second.

TSL function for getting the position in world space for the given light.

TSL function for getting projected uv coordinates for the given light. Relevant when using maps with spot lights.

TSL function for getting a shadow matrix uniform node for the given light.

TSL function for getting the light target direction for the given light.

TSL function for getting the light target position in world space for the given light.

TSL function for getting the position in view space for the given light.

TSL function for creating an instance of LightsNode and configuring it with the given array of lights.

TSL function for converting a perspective depth value to linear depth.

Linear tone mapping, exposure only.

Returns the natural logarithm of the parameter.

Returns the base 2 logarithm of the parameter.

TSL function for converting a logarithmic depth value to a viewZ value.

Computes the luminance for the given RGB color value.

TSL function for creating a LUT node for color grading via post processing.

TSL function for creating a matcap uv node.

Can be used to compute texture coordinates for projecting a matcap onto a mesh. Used by MeshMatcapNodeMaterial.

TSL function for creating a material reference node.

Returns the greatest of the given values.

TSL function for creating a max mip level node.

Returns the least of the given values.

Linearly interpolates between two values.

Alias for mix() with a different parameter order.

Computes the remainder of dividing the first node by the second one.

TSL function for creating a morph node.

Applies a motion blur effect to the given input node.

TSL function for creating a MRT node.

Returns the multiplication of two or more value.

Negates the value of the parameter (-x).

Neutral tone mapping.

Reference: https://modelviewer.dev/examples/tone-mapping

TSL function for creating a normal map node.

Calculates the unit vector in the same direction as the original vector.

Performs logical NOT on a node.

Checks if two nodes are not equal.

TSL function for creating an object 3D node that represents the object's direction in world space.

TSL function for creating an object 3D node that represents the object's position in world space.

TSL function for creating an object 3D node that represents the object's radius.

TSL function for creating an object 3D node that represents the object's scale in world space.

TSL function for creating an object 3D node that represents the object's position in view/camera space.

TSL function for creating an object 3D node that represents the object's world matrix.

Return 1 minus the parameter.

Performs a logical OR operation on multiple nodes.

TSL function for converting an orthographic depth value to a viewZ value.

Generates a sawtooth wave oscillation based on a timer.

Generates a sine wave oscillation based on a timer.

Generates a square wave oscillation based on a timer.

Generates a triangle wave oscillation based on a timer.

TSL function for creating an outline effect around selected objects.

TSL function for creating an output struct node.

TSL function for creating a function overloading node.

Converts each component of the vec2 to 16-bit floating-point values. The results are packed into a single unsigned integer.

Converts each component of the normalized float to 16-bit integer values. The results are packed into a single unsigned integer. round(clamp(c, -1, +1) * 32767.0)

Converts each component of the normalized float to 16-bit integer values. The results are packed into a single unsigned integer. round(clamp(c, 0, +1) * 65535.0)

A function that remaps the [0,1] interval into the [0,1] interval. The corners are mapped to 0 and the center to 1. Reference: https://iquilezles.org/articles/functions/.

TSL function for creating an parallax barrier pass node.

TSL function for computing parallax uv coordinates.

TSL function for creating a parameter node.

TSL function for creating a pass node.

TSL function for creating a pass texture node.

A function that remaps the [0,1] interval into the [0,1] interval. A generalization of the parabola(). Keeps the corners mapped to 0 but allows the control of the shape one either side of the curve. Reference: https://iquilezles.org/articles/functions/.

TSL function for converting a perspective depth value to a viewZ value.

TSL function for creating a pixelation render pass node for post processing.

TSL function for creating a PMREM node.

TSL function for creating an instance of PointShadowNode.

TSL function for creating a posterize node.

Return the value of the first parameter raised to the power of the second one.

Returns the square of the parameter.

Returns the cube of the parameter.

Returns the fourth power of the parameter.

TSL function for creating a gaussian blur node for post processing with enabled premultiplied alpha.

Premultiplies the RGB channels of a color by its alpha channel.

This function is useful for converting a non-premultiplied alpha color into a premultiplied alpha format, where the RGB values are scaled by the alpha value. Premultiplied alpha is often used in graphics rendering for certain operations, such as compositing and image processing.

TSL function for creating a property node.

Broadcasts e from the quad invocation with id equal to id.

Swaps e between invocations in the quad diagonally.

Swaps e between invocations in the quad in the X direction.

Swaps e between invocations in the quad in the Y direction.

This TSL function blurs an image in a circular pattern, radiating from a configurable center point in screen space.

Radial blurs can be used for different kind of effects like producing simple faked lighting effects also known as "light shafts". The major limitation of this specific usage is the center point can only be defined in 2D so the effect does not honor the depth of 3D objects. Consequently, it is not intended for physically correct lit scenes.

Converts a quantity in degrees to radians.

Returns a random value for the given uv.

TSL function for creating a range node.

Constructs a new range factor node.

Returns the reciprocal of the parameter (1/x).

TSL function for creating a reference base node.

TSL function for creating a reference node.

TSL function for creating a reference base node. Use this function if you want need a reference to an array-like property that should be represented as a uniform buffer.

TSL function for creating a reference node. Use this function if you want need a reference to an array-like property that should be represented as a uniform buffer.

Calculates the reflection direction for an incident vector.

TSL function for creating a reflector node.

Calculates the refraction direction for an incident vector.