Available Node Material Blocks

List of Node Material Blocks

Here is the default list of Node Material Blocks available to use.

• Animation:

  • Bones: Provides a world matrix for each vertex, based on skeletal (bone/joint) animation.

    • Inputs:
      • matricesIndices: Vector4
      • matricesWeights: Vector4
      • matricesIndicesExtra: Vector4
      • matricesWeightsExtra: Vector4
      • world: Matrix
    • Outputs:
      • output: Matrix

  • MorphTargets: Provides the final positions, normals, tangents, and uvs based on morph targets in a mesh.

    • Inputs:
      • position: Vector3
      • normal: Vector3
      • tangent: Vector3
      • uv: Vector2
    • Outputs:
      • positionOutput: Vector3
      • normalOutput: Vector3
      • tangentOutput: Vetor3
      • uvOutput: Vector2

• Color Management:

  • Desaturate: Convert a color input into a grayscale representation.

    • Inputs:
      • color: Color3
      • level: Float
    • Outputs:
      • output: Color3

  • Gradient: Returns the color in the gradient represented by the target value of the input.

    • Inputs:
      • value: Float.
    • Outputs:
      • output: Color3.

  • Posterize: Reduces the number of values in each channel to the number in the corresponding channel of steps.

    • Inputs:
      • value: Float, Vector2, Vector3, Vector4, Color3, or Color4.
      • steps: Float, Vector2, Vector3, Vector4, Color3, or Color4.
    • Outputs:
      • output: Float, Vector2, Vector3, Vector4, Color3, or Color4. Output varies based on input types.

  • ReplaceColor: Outputs the replacement color if the distance between value and reference is less than distance, else outputs the value color.

    • Inputs:
      • value: Vector2, Vector3, Vector4, Color3, or Color4.
      • reference: Vector2, Vector3, Vector4, Color3, or Color4.
      • distance: Float
      • replacement: Vector2, Vector3, Vector4, Color3, or Color4.
    • Outputs:
      • output: Vector2, Vector3, Vector4, Color3, or Color4. Output varies based on input types.

  Example: Replace Color Block Example

• Conversion:

  • ColorMerger: Combines float input channels into a color.

    • Inputs:
      • r: Float
      • g: Float
      • b: Float
      • a: Float
    • Outputs:
      • rgba: Color4
      • rgb: Color3

  • ColorSplitter: Separates color input channels into individual floats.

    • Inputs:
      • rgba: Color4
      • rgb: Color3
    • Outputs:
      • rgb: Color3
      • r: Float
      • g: Float
      • b: Float
      • a: Float

  • VectorMerger: Combines up to four input floats into a vector.

    • Inputs:
      • x: Float
      • y: Float
      • z: Float
      • w: Float
    • Outputs:
      • xyzw: Vector4
      • xyz: Vector3
      • xy: Vector2

  • VectorSplitter: Separates vectors input channels into individual floats.

    • Inputs:
      • xyzw: Vector4
      • xyz: Vector3
      • xy: Vector2
    • Outputs:
      • xyz: Vector3
      • xy: Vector2
      • x: Float
      • y: Float
      • z: Float
      • w: Float

• Inputs:

  • Color3: A color made up of red, green, and blue channel values.

    • Output:
      • output: Color3

  • Color4: A color made up of red, green, blue, and alpha channel values.

    • Output:
      • output: Color4

  • DeltaTime: A float representing the time that has passed since the last frame was rendered.

    • Output:
      • output: Float

  • Float: A floating point number representing a value with a fractional component.

    • Output:
      • output: Float

  • FragCoord: The gl_FragCoord predefined variable (window relative coordinates (x,y,z,1/w))

    • Output:
      • xy: Vector2
      • xyz: Vector3
      • xyzw: Vector4
      • x: Float
      • y: Float
      • z: Float
      • w: Float

  • ImageSource: A node for reading an embedded or linked image that can be shared across several Texture nodes.

    • Output:
      • Source: Can only be used as an input on a Texture block

  • ReflectionTexture: Creates a reflection from the input texture.

    • Input:
      • position: Vector3
      • worldPosition: Vector4
      • worldNormal: Vector4
      • world: Matrix
      • cameraPosition: Vector3
      • view: Matrix
    • Output:
      • rgb: Color3
      • r: Float
      • g: Float
      • b: Float

  • SceneDepth: The scene depth buffer

    • Input:
      • uv: Vector2
    • Output:
      • depth: Float

  • ScreenSize: The size of the screen window

    • Output:
      • xy: Vector2
      • x: Float
      • y: Float

  • Texture: A node for reading a linked or embedded texture file.

    • Inputs:
      • uv: Vector2 (mesh.uv automatically attached).
    • Outputs:
      • rgba: Vector4
      • rgb: Vector3
      • r: Float
      • g: Float
      • b: Float
      • a: Float

  • Time: A float value that represents the time that has passed since the scene was loaded.

    • Output:
      • output: Float

  • Vector2: a vector composed of X and Y channels.

    • Output:
      • output: Vector2

  • Vector3: a vector composed of X, Y, and Z channels.

    • Output:
      • output: Vector3

  • Vector4: a vector composed of X, Y, Z, and W channels.

    • Output:
      • output: Vector4

• Interpolation:

  • Lerp: Outputs a value that is a mix of the left and right inputs based on the target value.

    • Inputs:
      • left: Float, Vector2, Vector3, Vector4, Color3, or Color4.
      • right: Float, Vector2, Vector3, Vector4, Color3, or Color4
      • gradient: Float
    • Output:
      • output: Float, Vector2, Vector3, Vector4, Color3, or Color4. Output varies based on left and right input types.

  • NLerp: Outputs a value that is a mix of the left and right inputs based on the target's normalized value.

    • Inputs:
      • left: Float, Vector2, Vector3, Vector4, Color3, or Color4.
      • right: Float, Vector2, Vector3, Vector4, Color3, or Color4
      • gradient: Float
    • Output:
      • output: Float, Vector2, Vector3, Vector4, Color3, or Color4. Output varies based on left and right input types.

  • SmoothStep: Outputs a value based on a the input value's position on a curve between the two edge values.

    • Inputs:
      • value: Float
      • edge0: Float
      • edge1: Float
    • Output:
      • output: Float

  • Step: Outputs 1 for any input value above the edge input, outputs 0 for any input value below the edge input.

    • Input:
      • value: Float
      • edge: Float
    • Output:
      • output: Float

• Logical:

  • And: If both inputs are non-zero values the block evaluates true, otherwise it evaluates false.

    • Inputs:
      • a: Float
      • b: Float
      • true: Float, Vector2, Vector3, Vector4, Color3, Color4
    • Outputs:
      • output: Float

  • Equal: If both inputs are equal the block evaluates true, otherwise it evaluates false.

    • Inputs:
      • a: Float
      • b: Float
      • true: Float, Vector2, Vector3, Vector4, Color3, Color4
    • Outputs:
      • output: Float

  • GreaterOrEqual: If input a is greater or equal to input b the block evaluates true, otherwise it evaluates false.

    • Inputs:
      • a: Float
      • b: Float
      • true: Float, Vector2, Vector3, Vector4, Color3, Color4
    • Outputs:
      • output: Float

  • GreaterThan: If input a is greater than input b the block evaluates true, otherwise it evaluates false.

    • Inputs:
      • a: Float
      • b: Float
      • true: Float, Vector2, Vector3, Vector4, Color3, Color4
    • Outputs:
      • output: Float

  • LessOrEqual: If input a is less than or equal to input b the block evaluates true, otherwise it evaluates false.

    • Inputs:
      • a: Float
      • b: Float
      • true: Float, Vector2, Vector3, Vector4, Color3, Color4
    • Outputs:
      • output: Float

  • LessThan: If input a is less than input b the block evaluates true, otherwise it evaluates false.

    • Inputs:
      • a: Float
      • b: Float
      • true: Float, Vector2, Vector3, Vector4, Color3, Color4
    • Outputs:
      • output: Float

  • NotEqual: If input a not equal to input b the block evaluates true, otherwise it evaluates false.

    • Inputs:
      • a: Float
      • b: Float
      • true: Float, Vector2, Vector3, Vector4, Color3, Color4
    • Outputs:
      • output: Float

  • Or: If either input is a non-zero value the block evaluates true, otherwise it evaluates false.

    • Inputs:
      • a: Float
      • b: Float
      • true: Float, Vector2, Vector3, Vector4, Color3, Color4
    • Outputs:
      • output: Float

  • Xor: if input a and input b are both a value of zero the block evaluates false, otherwise it evaluates true.

    • Inputs:
      • a: Float
      • b: Float
      • true: Float, Vector2, Vector3, Vector4, Color3, Color4
    • Outputs:
      • output: Float

• Math: Standard:

  • Add: Adds the left and right inputs of the same type together.

    • Inputs:
      • left: Float, Vector2, Vector3, Vector4, Color3, or Color4.
      • right: Float, Vector2, Vector3, Vector4, Color3, or Color4.
    • Outputs:
      • output: Float, Vector2, Vector3, Vector4, Color3, or Color4. Output varies based on input types.

  • Divide: Divides the left input by the right input of the same type.

    • Inputs:
      • left: Float, Vector2, Vector3, Vector4, Color3, or Color4.
      • right: Float, Vector2, Vector3, Vector4, Color3, or Color4.
    • Outputs:
      • output: Float, Vector2, Vector3, Vector4, Color3, or Color4. Output varies based on input types.

  • Max: Outputs the largest value between the left and right inputs of the same type.

    • Inputs:
      • left: Float, Vector2, Vector3, Vector4, Color3, or Color4.
      • right: Float, Vector2, Vector3, Vector4, Color3, or Color4.
    • Outputs:
      • output: Float, Vector2, Vector3, Vector4, Color3, or Color4. Output varies based on input types.

  • Min: Outputs the smallest value between the left and right inputs of the same type.

    • Inputs:
      • left: Float, Vector2, Vector3, Vector4, Color3, or Color4.
      • right: Float, Vector2, Vector3, Vector4, Color3, or Color4.
    • Outputs:
      • output: Float, Vector2, Vector3, Vector4, Color3, or Color4. Output varies based on input types.

  • Mod: Outputs the value of the left input modulo the right input

    • Inputs:
      • left: Float, Vector2, Vector3, Vector4, Color3, or Color4.
      • right: Float, Vector2, Vector3, Vector4, Color3, or Color4.
    • Outputs:
      • output: Float, Vector2, Vector3, Vector4, Color3, or Color4. Output varies based on input types.

  • Multiply: Multiplies the left and right inputs of the same type together.

    • Inputs:
      • left: Float, Vector2, Vector3, Vector4, Color3, or Color4.
      • right: Float, Vector2, Vector3, Vector4, Color3, or Color4.
    • Outputs:
      • output: Float, Vector2, Vector3, Vector4, Color3, or Color4. Output varies based on input types.

  • Negate: Multiplies the input by -1.

    • Inputs:
      • left: Float, Vector2, Vector3, Vector4, Color3, or Color4.
      • right: Float, Vector2, Vector3, Vector4, Color3, or Color4.
    • Outputs:
      • output: Float, Vector2, Vector3, Vector4, Color3, or Color4. Output varies based on input types.

  • OneMinus: Subtracts each channel of the input value from 1 (1 - input).

    • Inputs:
      • left: Float, Vector2, Vector3, Vector4, Color3, or Color4.
      • right: Float, Vector2, Vector3, Vector4, Color3, or Color4.
    • Outputs:
      • output: Float, Vector2, Vector3, Vector4, Color3, or Color4. Output varies based on input types.

  • Reciprocal: Quotient of 1 divided by the input.

    • Inputs:
      • left: Float, Vector2, Vector3, Vector4, Color3, or Color4.
      • right: Float, Vector2, Vector3, Vector4, Color3, or Color4.
    • Outputs:
      • output: Float, Vector2, Vector3, Vector4, Color3, or Color4. Output varies based on input types.

  • Scale: Multiplies the input channels by a float factor.

    • Inputs:
      • Input: Float, Vector2, Vector3, Vector4, Color3, or Color4.
      • Factor: Float
    • Output:
      • output: Float, Vector2, Vector3, Vector4, Color3, or Color4. Output varies based on input types.

  • Sign: Returns 1 if the input is positive, 0 if input is equal to 0, or -1 if the input is negative.

    • Input:
      • input: Float
    • Output:
      • output: Float

  • Sqrt: Outputs the the square root of the input value.

    • Input:
      • input: Float
    • Output:
      • output: Float

  • Subtract: Subtracts the right input from the left input of the same type.

    • Inputs:
      • left: Float, Vector2, Vector3, Vector4, Color3, or Color4.
      • right: Float, Vector2, Vector3, Vector4, Color3, or Color4.
    • Outputs:
      • output: Float, Vector2, Vector3, Vector4, Color3, or Color4. Output varies based on input types.

• Math: Scientific:

  • Abs: Outputs the absolute value of the input value.

    • Input:
      • input: Float
    • Output:
      • output: Float

  • ArcCos: Outputs the inverse of the cosine value based on the input value.

    • Input:
      • input: Float
    • Output:
      • output: Float

  • ArcSin: Outputs the inverse of the sine value based on the input value.

    • Input:
      • input: Float
    • Output:
      • output: Float

  • ArcTan: Outputs the inverse of the tangent value based on the input value.

    • Input:
      • input: Float
    • Output:
      • output: Float

  • ArcTan2: Outputs the inverse of the tangent value based on the input value.

    • Input:
      • input: Float
    • Output:
      • output: Float

  • Cos: Outputs the cosine value based on the input value.

    • Input:
      • input: Float
    • Output:
      • output: Float

  • DegreesToRadians: Converts the input degrees value to radians.

    • Input:
      • input: Float
    • Output:
      • output: Float

  • Exp: Outputs the input value multiplied by itself 9 time. (Exponent of 10)

    • Input:
      • input: Float
    • Output:
      • output: Float

  • Exp2: Outputs the input value multiplied by itself 1 time. (Exponent of 2)

    • Input:
      • input: Float
    • Output:
      • output: Float

  • Fract: Outputs only the fractional value of a floating point number.

    • Input:
      • input: Float
    • Output:
      • output: Float

  • Log: The logarithmic value based on the input value.

    • Input:
      • input: Float
    • Output:
      • output: Float

  • Pow: Outputs the input value multiplied by itself the number of times equal to the power input (Exponent of power)

    • Input:
      • value: Float
      • power: Float
    • Output:
      • output: Float

  • RadiansToDegrees: Converts the input radians value to degrees.

    • Input:
      • input: Float
    • Output:
      • output: Float

  • SawToothWave: Outputs a sawtooth pattern value between -1 and 1 based on the input value.

    • Input:
      • input: Float
    • Output:
      • output: Float

  • Sin: Outputs the the sine value based on the input value.

    • Input:
      • input: Float
    • Output:
      • output: Float

  • SquareWave: Outputs a stepped pattern value between -1 and 1 based on the input value.

    • Input:
      • input: Float
    • Output:
      • output: Float

  • Tan: Outputs the the tangent value based on the input value.

    • Input:
      • input: Float
    • Output:
      • output: Float

  • TriangleWave: Outputs a sawtooth pattern value between 0 and 1 based on the input value.

    • Input:
      • input: Float
    • Output:
      • output: Float

• Math: Vector:

  • Cross: Outputs a vector that is perpendicular to two input vectors.

    • Inputs:
      • left: Vector2, Vector3, Vector4, Color3, or Color4.
      • right: Vector2, Vector3, Vector4, Color3, or Color4.
    • Output:
      • output: Vector2, Vector3, Vector4, Color3, or Color4. Output varies based on left and right input types.

  • Derivative: FRAGMENT SHADER ONLY. Provides the rate of change for an input on a given axis (x,y).

    • Inputs:
      • input: Float, Vector2, Vector3, Vector4, Color3, or Color4.
    • Output:
      • dx: Float, Vector2, Vector3, Vector4, Color3, or Color4. Output varies based on left and right input types.
      • dy: Float, Vector2, Vector3, Vector4, Color3, or Color4. Output varies based on left and right input types.

  • Distance: Provides a distance vector based on the left and right input vectors.

    • Inputs:
      • left: Vector2, Vector3, Vector4, Color3, or Color4.
      • right: Vector2, Vector3, Vector4, Color3, or Color4.
    • Outputs:
      • output: Vector2, Vector3, Vector4, Color3, or Color4. Output varies based on input types.

  • Dot: Outputs the cos of the angle between two vectors.

    • Inputs:
      • left: Vector2, Vector3, Vector4, Color3, or Color4.
      • right: Vector2, Vector3, Vector4, Color3, or Color4.
    • Output:
      • output: Float

  • Fresnel: Outputs the grazing angle of the surface of the mesh, relative to a camera influenced by the bias and power inputs.

    • Input:
      • worldNormal: Vector4
      • viewDirection: Vector3
      • bias: Float
      • power: Float
    • Output:
      • fresnel: Float

  • Length: Outputs the length of an input vector.

    • Inputs:
      • left: Vector2, Vector3, Vector4, Color3, or Color4.
      • right: Vector2, Vector3, Vector4, Color3, or Color4.
    • Outputs:
      • output: Vector2, Vector3, Vector4, Color3, or Color4. Output varies based on input types.

  • Reflect: Outputs the direction of the input vector reflected across the surface normal.

    • Inputs:
      • incident: Vector3
      • normal: Vector3
    • Outputs:
      • output: Vector3

  • Refract: Outputs a direction simulating a deflection of the input vector.

    • Inputs:
      • incident: Vector3
      • normal: Vector3
      • ior: Float
    • Outputs:
      • output: Vector3

  • Rotate2D: Rotates UV coordinates around the W axis.

    • Inputs:
      • input: Vector2
      • angle: Float
    • Outputs:
      • output: Vector2

  • ScreenSpace: Converts a world space position into the corresponding XY screen coordinates in a range of -1 to 1.

    • Inputs:
      • vector: Vector3, Vector4
      • worldViewProjection: Matrix
    • Outputs:
      • output: Vector2
      • X: Float
      • Y: Float

  • Transform: Transforms a input vector based on the input matrix.

    • Inputs:
      • vector: Vector2, Vector3, Vector4, Color3, or Color4
      • transform: Matrix
    • Output:
      • output: Vector4

  • Twirl: Twirls UV coordinates around the W axis

    • Inputs:
      • input: Vector2
      • strength: Float
      • center: Vector2
      • offset: Vector2
    • Outputs:
      • output: Vector2
      • X: Float
      • Y: Float

• Matrices:

  • Matrix: A 4x4 table of related values.

    • Output:
      • output: Matrix

  • MatrixBuilder: Creates a custom matrix from four Vector4 inputs.

    • Inputs:
      • row0: Vector4
      • row1: Vector4
      • row2: Vector4
      • row3: Vector4
    • Outputs:
      • output: Matrix

  • ProjectionMatrix: A matrix to remap points in 3D space to 2D plane relative to the screen.

    • Output:
      • output: Matrix

  • ViewMatrix: A matrix to remap points in 3D space to 2D plane relative to the view of the scene camera.

    • Output:
      • output: Matrix

  • ViewProjectionMatrix: A matrix to remap points in 3D space to 2D view space before remapping to 2D screen space.

    • Output:
      • output: Matrix

  • WorldMatrix: A matrix to remap points in 3D local space to 3D world space.

    • Output:
      • output: Matrix

  • WorldViewMatrix: A matrix to remap points in 3D local space to 3D world space, and ending in 2D camera space.

    • Output:
      • output: Matrix

  • WorldViewProjectionMatrix: A matrix to remap points in 3D local space to 3D world space, then to 2D camera space, and ending in 2D screen space.

    • Output:
      • output: Matrix

• Mesh:

  • Color: Outputs the RGBA color of each vertex in the mesh.

    • Output:
      • output: Color4

  • FrontFacing: Returns 1 if a mesh triangle faces the normal direction and 0 if it does not.

    • Outputs:
      • output: Float

  • Instances: Provides the world matrix for each instance to apply this material to all instances.

    • Inputs:
      • world0: Vector4
      • world1: Vector4
      • world2: Vector4
      • world3: Vector4
      • world: worldMatrix
    • Output:
      • output: Matrix

  • MatricesIndices: A Vector4 representing the vertex to bone skinning assignments.

    • Output:
      • output: Vector4

  • MatricesWeights: A Vector4 representing the vertex to bone skinning weights.

    • Output:
      • output: Vector4

  • Normal: A Vector3 representing the normal of each vertex of the attached mesh.

    • Output:
      • output: Vector3

  • NormalBlend: Outputs the result of blending two normal maps together using a per-channel screen.

    • Input:
      • normalMap0: Vector3
      • normalMap1: Vector3
    • Output:
      • output: Vector3

  • PerturbNormal: Creates high-frequency detail normal vectors based on a normal map, the world position, and world normal.

    • Input:
      • worldPosition: Vector4
      • worldNormal: Vector4
      • uv: Vector2
      • normalMap: Color3
      • strength: Float
    • Output:
      • output: Vector4

  • Position: A Vector3 representing the position of each vertex of the attached mesh.

    • Output:
      • output: Vector3

  • Tangent: A Vector3 representing the tangent of each vertex of the attached mesh.

    • Output:
      • output: Vector3

  • UV: A Vector2 representing the UV coordinates of each vertex of the attached mesh.

    • Output:
      • output: Vector2

  • WorldNormal: A Vector4 representing the normal of each vertex of the attached mesh transformed into world space.

    • Input:
      • vector: Vector3
      • transform: Matrix
    • Output:
      • output: Vector4

  • WorldPosition: A Vector4 representing the position of each vertex of the attached mesh transformed into world space.

    • Input:
      • vector: Vector3
      • transform: Matrix
    • Output:
      • output: Vector4

  • WorldTangent: A Vector4 representing the tangent of each vertex of the attached mesh transformed into world space.

    • Inputs:
      • vector: Vector3
      • transform: Matrix
    • Outputs:
      • output: Vector4
      • xyz: Vector3

• Noises:

  • Cloud: Creates a random pattern resembling clouds.

    • Inputs:
      • seed: Vector2 or Vector3
      • chaos: Normalized Vector3
      • offsetX: Float
      • offsetY: Float
      • offsetZ: Float
    • Output:
      • output: Float

  • RandomNumber: Provides a random number based on an input seed.

    • Inputs:
      • seed: Vector2
    • Output:
      • output: Float

  • SimplexPerlin3D: Creates a type of gradient noise with few directional artifacts.

    • Inputs:
      • seed: Vector3
    • Output:
      • output: Float

  • VoronoiNoise: Creates a random pattern of cells in 2D.

    • Inputs:
      • seed: Vector2
      • offset: Float
      • density: Float
    • Outputs:
      • output: Float
      • cells: Float

  • WorleyNoise3D: Creates a random pattern resembling cells.

    • Inputs:
      • seed: Vector3
      • jitter: Float
    • Output:
      • output: Vector2

• Outputs:

  • Discard: A final node that will not output a pixel below the cutoff value.

    • Inputs:
      • value: Float
      • cutoff: Float

  • FragmentOutput: A mandatory final node for outputing the color of each pixel.

    • Inputs:
      • rgba: Vector4
      • rgb: Vector3
      • a: Float

  • VertexOutput: A mandatory final node for outputing the position of each vertex.

    • Inputs:
      • vector: Vector4

• Particle:

  • ParticleBlendMultiply: The "blend/multiply" module of the particle shader

    • Inputs:
      • color: Color4
      • alphaTexture: Float
      • alphaColor: Float
    • Outputs:
      • blendColor: Color4

  • ParticleColor: The color of the particle

    • Outputs:
      • output: Color4

  • ParticlePositionWorld: The world position of the particle

    • Outputs:
      • output: Vector3

  • ParticleRampGradient: The "ramp gradient" module of the particle shader

    • Inputs:
      • color: Color4
    • Outputs:
      • rampColor: Color4

  • ParticleTexture: The texture of the particle

    • Inputs:
      • uv: Vector2
    • Outputs:
      • rgba: Color4
      • rgb: Color3
      • r: Float
      • g: Float
      • b: Float
      • a: Float

  • ParticleTextureMask: The textureMask property of the particle

    • Outputs:
      • output: Color4

  • ParticleUV: the uv coordinates of the particle

    • Outputs:
      • output: Vector2

• PBR: (since 4.2)

  • Anisotropy: The anisotropy module of the PBR material

  • Inputs:

    • intensity: Float
    • direction: Vector2 - note that if you read the direction from a texture, you will probably want to apply the transformation texture.xy * 2 - 1 to get coordinates between -1 and 1!
    • uv: Vector2
    • worldTangent: Vector4

  • Outputs:

    • anisotropy: can only be used as input of the PBRMetallicRoughness block

  • ClearCoat: The clear coat module of the PBR material

    • Inputs:
      • intensity: Float
      • roughness: Float
      • indexOfRefraction: Float
      • normalMapColor: Color3
      • uv: Vector2
      • tintColor: Color3
      • tintAtDistance: Float
      • tintThickness: Float
      • worldTangent: Vector4
    • Outputs:
      • clearcoat: can only be used as input of the PBRMetallicRoughness block

  • PBRMetallicRoughness: The PBR material implementing the metallic/roughness model

    • Inputs:
      • worldPosition: Vector4
      • worldNormal: Vector4
      • view: Matrix
      • cameraPosition: Vector3
      • perturbedNormal: Vector4
      • baseColor: Color3
      • metallic: Float
      • roughness: Float
      • ambientOcc: Float
      • opacity: Float
      • indexOfRefraction: Float
      • ambientColor: Color3
      • reflection: output of the Reflection block
      • clearcoat: output of the ClearCoat block
      • sheen: output of the Sheen block
      • subsurface: output of the SubSurface block
      • anisotropy: output of the Anisotropy block
    • Outputs:
      • ambientClr: Color3
      • diffuseDir: Color3
      • specularDir: Color3
      • clearcoatDir: Color3
      • sheenDir: Color3
      • diffuseInd: Color3
      • specularInd: Color3
      • clearcoatInd: Color3
      • sheenInd: Color3
      • refraction: Color3
      • lighting: Color3
      • shadow: Float
      • alpha: Float

    Notes:

    • The Dir suffix in the name of the outputs means Direct and are components from direct lighting (spot, point light, directional, ...).
    • The Ind suffix in the name of the outputs means Indirect and are components from indirect lighting (IBL, ...).
    • The lighting output is the combination (sum) of all the other outputs (except for shadow and alpha) and is the one to use if you want to deal with the final output color. This color is in gamma space.
    • All the XXXClr, XXXDir and XXXInd outputs are individual lighting components and can be used if you need to perform further processing with them. These components are in linear space.
    • The shadow output is the shadow component when this material is used for shadow rendering (0 means completely in shadow from all lights and 1 means fully visible by all lights). You can use it for additional special effects (see Tinted Shadows Example ) for tinted shadows for eg - it's for the standard material but it would work the same for PBR too) but note that you don't need to do anything with it by default to have shadows rendered correctly for your material

  • Reflection: The reflection module of the PBR material

    • Inputs:
      • position: Vector3
      • world: Matrix
      • color: Color3
    • Outputs:
      • reflection: can only be used as input of the PBRMetallicRoughness block

• Refraction: The refraction module of the PBR material (used by the SubSurface block)

  • Inputs:
    • intensity: Float
    • tintAtDistance: Float
  • Outputs:
    • refraction: can only be used as input of the SubSurface block

• Sheen: The sheen module of the PBR material

  • Inputs:
    • intensity: Float
    • color: Color3
    • roughness: Float
  • Outputs:
    • sheen: can only be used as input of the PBRMetallicRoughness block

• SubSurface: The sub surface module of the PBR material

  • Inputs:
    • thickness: Float
    • tintColor: Color3
    • translucencyIntensity: Float
    • translucencyDiffusionDist: Color3
    • refraction: output of the Refraction block
  • Outputs:
    • subsurface: can only be used as input of the PBRMetallicRoughness block

• PostProcess:

  • CurrentScreen: The current screen (texture) used to render the post process

    • Inputs:
      • uv: Vector2
    • Outputs:
      • rgba: Color4
      • rgb: Color3
      • r: Float
      • g: Float
      • b: Float
      • a: Float

  • Position2D: The 2D clip coordinates (values between -1 and 1 for both x and y)

    • Outputs:
      • output: Vector2

• Range:

  • Clamp: Outputs values above the maximum or below minimum as maximum or minimum values respectively.

    • Input:
      • input: Float
    • Output:
      • input: Float

  • Normalize: Remaps the length of a vector or color to 1.

    • Inputs:
      • input: Vector2, Vector3, Vector4, Color3, or Color4.
    • Outputs:
      • output: Vector2, Vector3, Vector4, Color3, or Color4. Output varies based on input types.

  • Remap: Remaps input value between sourceMin and sourceMax to a new range between targetMin and targetMax.

    • Inputs:
      • input: Float, Vector2, Vector3, Vector4, Color3, Color4.
      • sourceMin: Float
      • sourceMax: Float
      • targetMin: Float
      • targetMax: Float
    • Outputs:
      • output: Float, Vector2, Vector3, Vector4, Color3, Color4. Output varies based on input type.

• Round:

  • Ceiling: Outputs fractional values as the next higher whole number.

    • Input:
      • input: Float
    • Output:
      • output: Float

  • Floor: Outputs fractional values as the next lower whole number.

    • Input:
      • input: Float
    • Output:
      • output: Float

  • Round: Outputs fractional values rounded to the nearest whole number.

    • Input:
      • input: Float
    • Output:
      • output: Float

• Scene Attributes:

  • CameraPosition: Outputs a Vector3 position of the active scene camera.

    • Output:
      • output: Vector3

  • CameraParameters: Outputs a Vector4 containing parameters associated with the camera (x: -1 for webGL and 1 for webGPU, y: minZ, z: maxZ, w: 1 / maxZ).

    • Output:
      • output: Vector4

  • Fog: Applies fog to the scene with an increasing opacity based on distance from the camera.

    • Input:
      • worldPosition: Vector4
      • view: viewMatrix (Matrix)
      • input: Vector3
      • fogColor: Color3
    • Output:
      • output: Color3

  • FogColor: The system value for fog color pulled from the scene.

    • Output:
      • output: Color3

  • ImageProcessing: Provides access to all of the Babylon image processing properties. Input is expected in Gamma color space. Post Processes

    • Input:
      • color: Color4
    • Output:
      • output: Color4

  • Light: Outputs diffuse and specular contributions from one or more scene lights.

    • Input:
      • worldPosition: Vector4
      • worldNormal: Vector4
      • cameraPosition: Vector3
      • glossiness: Float
      • glossPower: Float
      • diffuseColor: Color3
      • specularColor: Color3
    • Output:
      • diffuseOutput: Color3
      • specularOutput: Color3

  • LightInformation: Provides the direction, color and intensity of a selected light based on its world position.

    • Input:
      • worldPosition: Vector4
    • Output:
      • direction: Vector3
      • color: Color3
      • intensity: Float

  • ViewDirection: Outputs the direction vector of where the camera is aimed.

    • Input:
      • worldPosition: Vector4
      • cameraPosition: Vector3
    • Output:
      • output: Vector3