Client API. The Codename One framework your app is built on: this runs on the device, not in a backend.

public final class ShaderNode

Object
ShaderNode

One value in a portable shader: a constant, a uniform, a built-in input such as the world position, a texture sample, or an operation on other nodes. Nodes are immutable and can be shared; a node used twice is computed once in the generated program.

A graph is plain Java, so it is checked by the compiler, needs no parser on the device and prints as GLSL, Metal or HLSL depending on the backend. The types follow the shading languages’ own rules: two operands of an arithmetic operation have the same type, or one of them is a FLOAT that is applied to every component of the other.

ShaderNode uv = ShaderNode.uv().mul(4f).add(ShaderNode.time().mul(0.05f));
ShaderNode wave = ShaderNode.sin(uv.x().mul(6.2831f)).mul(0.5f).add(0.5f);
ShaderNode color = ShaderNode.mix(ShaderNode.vec3(0.1f, 0.3f, 0.5f),
        ShaderNode.vec3(0.6f, 0.8f, 0.9f), wave);

The built-in inputs that a stage can read are listed on each factory. Reading a fragment input from the VERTEX_OFFSET hook, or the reverse, fails when the material is compiled.

Methods

`public static` `ShaderNode f(float v)`	A float constant.
`public static` `ShaderNode vec2(float x, float y)`	A two component constant.
`public static` `ShaderNode vec3(float x, float y, float z)`	A three component constant.
`public static` `ShaderNode vec4(float x, float y, float z, float w)`	A four component constant.
`public static` `ShaderNode color(int rgb)`	An RGB colour constant from a packed `0xRRGGBB` (the alpha byte is ignored), in the 0 to 1 range.
`public static` `ShaderNode vec(ShaderNode... parts)`	Builds a vector from nodes whose components add up to 2, 3 or 4, as `vec3(v.xy, 1.0)` does in GLSL.
`public static` `ShaderNode uniform(String name, ShaderType type)`	A value the application sets per draw with `ShaderMaterial.setUniform`.
`public static` `ShaderNode sample(String textureName, ShaderNode uv)`	Samples a texture declared on the material with `ShaderMaterial.declareTexture`.
`public static` `ShaderNode sceneColor(ShaderNode uv)`	Reads the frame in a custom full screen pass (`com.codename1.gpu.PostProcess.addPass`): the scene, or the output of the pass before.
`public static` `ShaderNode screenUv()`	The place of the pixel on screen in a custom full screen pass, from 0,0 top left to 1,1 bottom right.
`public static` `ShaderNode position()`	The vertex position in model space.
`public static` `ShaderNode normal()`	The vertex normal in model space, or up when the mesh has none.
`public static` `ShaderNode uv()`	The first texture coordinate, or zero when the mesh has none.
`public static` `ShaderNode worldPos()`	The position in world space: in the vertex stage before the `VERTEX_OFFSET` hook moves it, in the fragment stage after.
`public static` `ShaderNode worldNormal()`	The interpolated surface normal in world space, normalized, before the `NORMAL` hook replaces it.
`public static` `ShaderNode viewDir()`	The unit direction from the surface toward the camera.
`public static` `ShaderNode cameraPos()`	The camera position in world space.
`public static` `ShaderNode sunDir()`	The unit direction toward the light (the sun).
`public static` `ShaderNode sunColor()`	The light colour.
`public static` `ShaderNode instanceId()`	The index of the copy `GraphicsDevice.drawInstanced` is drawing, 0 for an ordinary draw.
`public static` `ShaderNode instanceRandom()`	A random number in 0 to 1 that stays the same for each copy drawn by `GraphicsDevice.drawInstanced` (and 0 otherwise): vary the size, tint or sway phase of a field of grass or a crowd with it.
`public static` `ShaderNode instanceColor()`	The colour `GraphicsDevice.drawInstanced` gives the copy being drawn, white when it gives none.
`public static` `ShaderNode time()`	The clock in seconds that `GraphicsDevice.setTime` sets; the scene renderer advances it every frame.
`public static` `ShaderNode baseColor()`	The material colour times its texture, before the `BASE_COLOR` hook replaces it.
`public` `ShaderNode add(ShaderNode o)`	Returns this plus `o`.
`public` `ShaderNode add(float o)`	Returns this plus a constant.
`public` `ShaderNode sub(ShaderNode o)`	Returns this minus `o`.
`public` `ShaderNode sub(float o)`	Returns this minus a constant.
`public` `ShaderNode mul(ShaderNode o)`	Returns this times `o`, component by component.
`public` `ShaderNode mul(float o)`	Returns this times a constant.
`public` `ShaderNode div(ShaderNode o)`	Returns this divided by `o`, component by component.
`public` `ShaderNode div(float o)`	Returns this divided by a constant.
`public` `ShaderNode negate()`	Returns minus this.
`public` `ShaderNode oneMinus()`	Returns `1 - this`, the usual way to invert a mask.
`public` `ShaderNode swizzle(String components)`	Picks components by name, as GLSL’s `v.xz` does: one to four of `x`, `y`, `z`, `w` (or `r`, `g`, `b`, `a`).
`public` `ShaderNode x()`	Returns the first component.
`public` `ShaderNode y()`	Returns the second component.
`public` `ShaderNode z()`	Returns the third component.
`public` `ShaderNode w()`	Returns the fourth component.
`public` `ShaderNode rgb()`	Returns the first three components, the colour of a texel.
`public` `ShaderNode xy()`	Returns the first two components.
`public` `ShaderNode xz()`	Returns the first and third components, the ground plane of a world position.
`public static` `ShaderNode sin(ShaderNode a)`	Returns `sin(a)`, per component.
`public static` `ShaderNode cos(ShaderNode a)`	Returns `cos(a)`, per component.
`public static` `ShaderNode abs(ShaderNode a)`	Returns the absolute value, per component.
`public static` `ShaderNode floor(ShaderNode a)`	Returns the largest integer not greater than `a`, per component.
`public static` `ShaderNode fract(ShaderNode a)`	Returns `a - floor(a)`, per component.
`public static` `ShaderNode sqrt(ShaderNode a)`	Returns the square root, per component.
`public static` `ShaderNode exp(ShaderNode a)`	Returns `e` raised to `a`, per component.
`public static` `ShaderNode normalize(ShaderNode a)`	Returns the unit vector in the direction of `a`.
`public static` `ShaderNode saturate(ShaderNode a)`	Returns `a` clamped to 0 to 1, per component.
`public static` `ShaderNode length(ShaderNode a)`	Returns the length of a vector.
`public static` `ShaderNode distance(ShaderNode a, ShaderNode b)`	Returns the distance between two points.
`public static` `ShaderNode dot(ShaderNode a, ShaderNode b)`	Returns the dot product.
`public static` `ShaderNode cross(ShaderNode a, ShaderNode b)`	Returns the cross product of two `VEC3` nodes.
`public static` `ShaderNode reflect(ShaderNode i, ShaderNode n)`	Returns the reflection of incident direction `i` about normal `n`.
`public static` `ShaderNode min(ShaderNode a, ShaderNode b)`	Returns the smaller of two values, per component.
`public static` `ShaderNode max(ShaderNode a, ShaderNode b)`	Returns the larger of two values, per component.
`public static` `ShaderNode pow(ShaderNode a, ShaderNode b)`	Returns `a` raised to `b`, per component.
`public static` `ShaderNode pow(ShaderNode a, float b)`	Returns `a` raised to a constant.
`public static` `ShaderNode mod(ShaderNode a, ShaderNode b)`	Returns `a` modulo `b` with the sign of `b`, as GLSL’s `mod` does (HLSL’s `fmod` differs for negative values, so this is printed as `a - b * floor(a / b)` everywhere).
`public static` `ShaderNode atan2(ShaderNode y, ShaderNode x)`	Returns the angle of the vector (x, y) in radians, -pi to pi.
`public static` `ShaderNode clamp(ShaderNode a, float lo, float hi)`	Returns `a` clamped between `lo` and `hi`, per component.
`public static` `ShaderNode mix(ShaderNode a, ShaderNode b, ShaderNode t)`	Linear interpolation from `a` to `b` by `t`.
`public static` `ShaderNode smoothstep(float e0, float e1, ShaderNode x)`	Hermite step from 0 at `e0` to 1 at `e1`.
`public static` `ShaderNode smoothstep(ShaderNode e0, ShaderNode e1, ShaderNode x)`	Hermite step from 0 at `e0` to 1 at `e1`, with node edges.
`public static` `ShaderNode step(ShaderNode edge, ShaderNode x)`	Returns 0 where `x` is below `edge` and 1 elsewhere.
`public static` `ShaderNode select(ShaderNode condition, ShaderNode a, ShaderNode b)`	Returns `a` where `condition` is above 0.5, otherwise `b`.
`public static` `ShaderNode unpackNormal(ShaderNode texel, float strength)`	Decodes a texel of a tangent space normal map (the usual blue-ish image) into a direction, scaling its slope by `strength`.
`public static` `ShaderNode perturbNormal(ShaderNode tangentNormal)`	Bends the world space surface normal by a tangent space normal, for the `NORMAL` hook.
`public static` `ShaderNode blendNormals(ShaderNode base, ShaderNode detail)`	Blends two tangent space normals so the detail rides on the base rather than averaging it flat (“whiteout” blend).
`public static` `ShaderNode widen(ShaderNode n, ShaderType t)`	Repeats a `FLOAT` into a vector of `t`, or returns the node itself when it already has that type.
`public` `ShaderType getType()`	Returns the type of the value.

Inherited methods

From Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait, clone, finalize

Method details

f

public static ShaderNode f(float v)

A float constant.

Parameters

v float: the value

Returns

a FLOAT node

vec2

public static ShaderNode vec2(float x, float y)

A two component constant.

Parameters

x float: the first component
y float: the second component

Returns

a VEC2 node

vec3

public static ShaderNode vec3(float x, float y, float z)

A three component constant.

Parameters

x float: the first component
y float: the second component
z float: the third component

Returns

a VEC3 node

vec4

public static ShaderNode vec4(float x, float y, float z, float w)

A four component constant.

Parameters

x float: the first component
y float: the second component
z float: the third component
w float: the fourth component

Returns

a VEC4 node

color

public static ShaderNode color(int rgb)

An RGB colour constant from a packed 0xRRGGBB (the alpha byte is ignored), in the 0 to 1 range.

Parameters

rgb int: the colour

Returns

a VEC3 node

vec

public static ShaderNode vec(ShaderNode... parts)

Builds a vector from nodes whose components add up to 2, 3 or 4, as vec3(v.xy, 1.0) does in GLSL.

Parameters

parts ShaderNode...: the nodes, in order

Returns

a vector node

uniform

public static ShaderNode uniform(String name, ShaderType type)

A value the application sets per draw with ShaderMaterial.setUniform. It must be declared on the material with ShaderMaterial.declareUniform (the library shaders do that for you).

Parameters

name String: a name made of letters, digits and underscores
type ShaderType: its type

Returns

a node of that type

sample

public static ShaderNode sample(String textureName, ShaderNode uv)

Samples a texture declared on the material with ShaderMaterial.declareTexture. Works in the fragment stage only.

Parameters

textureName String: the declared name
uv ShaderNode: the VEC2 coordinate

Returns

a VEC4 texel

sceneColor

public static ShaderNode sceneColor(ShaderNode uv)

Reads the frame in a custom full screen pass (com.codename1.gpu.PostProcess.addPass): the scene, or the output of the pass before. Means nothing on an ordinary material.

Parameters

uv ShaderNode: the VEC2 place on screen, 0,0 top left; usually screenUv() or an offset from it

Returns

a VEC4 colour

screenUv

public static ShaderNode screenUv()

The place of the pixel on screen in a custom full screen pass, from 0,0 top left to 1,1 bottom right. In a pass it is the same as uv().

Returns

a VEC2 node

position

public static ShaderNode position()

The vertex position in model space. Vertex stage.

Returns

a VEC3 node

normal

public static ShaderNode normal()

The vertex normal in model space, or up when the mesh has none. Vertex stage.

Returns

a VEC3 node

uv

public static ShaderNode uv()

The first texture coordinate, or zero when the mesh has none. Both stages.

Returns

a VEC2 node

worldPos

public static ShaderNode worldPos()

The position in world space: in the vertex stage before the VERTEX_OFFSET hook moves it, in the fragment stage after. Both stages.

Returns

a VEC3 node

worldNormal

public static ShaderNode worldNormal()

The interpolated surface normal in world space, normalized, before the NORMAL hook replaces it. Fragment stage.

Returns

a VEC3 node

viewDir

public static ShaderNode viewDir()

The unit direction from the surface toward the camera. Fragment stage.

Returns

a VEC3 node

cameraPos

public static ShaderNode cameraPos()

The camera position in world space. Both stages.

Returns

a VEC3 node

sunDir

public static ShaderNode sunDir()

The unit direction toward the light (the sun). Both stages.

Returns

a VEC3 node

sunColor

public static ShaderNode sunColor()

The light colour. Both stages.

Returns

a VEC3 node

instanceId

public static ShaderNode instanceId()

The index of the copy GraphicsDevice.drawInstanced is drawing, 0 for an ordinary draw. Both stages. Reading it (or instanceRandom, instanceColor) declares the uniform it needs on the material.

Returns

a FLOAT node

instanceRandom

public static ShaderNode instanceRandom()

A random number in 0 to 1 that stays the same for each copy drawn by GraphicsDevice.drawInstanced (and 0 otherwise): vary the size, tint or sway phase of a field of grass or a crowd with it. Both stages.

Returns

a FLOAT node

instanceColor

public static ShaderNode instanceColor()

The colour GraphicsDevice.drawInstanced gives the copy being drawn, white when it gives none. Both stages.

Returns

a VEC4 node

time

public static ShaderNode time()

The clock in seconds that GraphicsDevice.setTime sets; the scene renderer advances it every frame. Both stages.

Returns

a FLOAT node

baseColor

public static ShaderNode baseColor()

The material colour times its texture, before the BASE_COLOR hook replaces it. Fragment stage.

Returns

a VEC4 node

add

public ShaderNode add(ShaderNode o)

Returns this plus o.

Parameters

o ShaderNode: the other operand

Returns

the sum

add

public ShaderNode add(float o)

Returns this plus a constant.

Parameters

o float: the constant

Returns

the sum

sub

public ShaderNode sub(ShaderNode o)

Returns this minus o.

Parameters

o ShaderNode: the other operand

Returns

the difference

sub

public ShaderNode sub(float o)

Returns this minus a constant.

Parameters

o float: the constant

Returns

the difference

mul

public ShaderNode mul(ShaderNode o)

Returns this times o, component by component.

Parameters

o ShaderNode: the other operand

Returns

the product

mul

public ShaderNode mul(float o)

Returns this times a constant.

Parameters

o float: the constant

Returns

the product

div

public ShaderNode div(ShaderNode o)

Returns this divided by o, component by component.

Parameters

o ShaderNode: the divisor

Returns

the quotient

div

public ShaderNode div(float o)

Returns this divided by a constant.

Parameters

o float: the divisor

Returns

the quotient

negate

public ShaderNode negate()

Returns minus this.

Returns

the negation

oneMinus

public ShaderNode oneMinus()

Returns 1 - this, the usual way to invert a mask.

Returns

the complement

swizzle

public ShaderNode swizzle(String components)

Picks components by name, as GLSL’s v.xz does: one to four of x, y, z, w (or r, g, b, a).

Parameters

components String: the component names

Returns

a node with as many components as named

x

public ShaderNode x()

Returns the first component.

Returns

a FLOAT node

y

public ShaderNode y()

Returns the second component.

Returns

a FLOAT node

z

public ShaderNode z()

Returns the third component.

Returns

a FLOAT node

w

public ShaderNode w()

Returns the fourth component.

Returns

a FLOAT node

rgb

public ShaderNode rgb()

Returns the first three components, the colour of a texel.

Returns

a VEC3 node

xy

public ShaderNode xy()

Returns the first two components.

Returns

a VEC2 node

xz

public ShaderNode xz()

Returns the first and third components, the ground plane of a world position.

Returns

a VEC2 node

sin

public static ShaderNode sin(ShaderNode a)

Returns sin(a), per component.

Parameters

a ShaderNode: radians

Returns

the sine

cos

public static ShaderNode cos(ShaderNode a)

Returns cos(a), per component.

Parameters

a ShaderNode: radians

Returns

the cosine

abs

public static ShaderNode abs(ShaderNode a)

Returns the absolute value, per component.

Parameters

a ShaderNode: the value

Returns

the absolute value

floor

public static ShaderNode floor(ShaderNode a)

Returns the largest integer not greater than a, per component.

Parameters

a ShaderNode: the value

Returns

the floor

fract

public static ShaderNode fract(ShaderNode a)

Returns a - floor(a), per component.

Parameters

a ShaderNode: the value

Returns

the fractional part

sqrt

public static ShaderNode sqrt(ShaderNode a)

Returns the square root, per component.

Parameters

a ShaderNode: a non negative value

Returns

the square root

exp

public static ShaderNode exp(ShaderNode a)

Returns e raised to a, per component.

Parameters

a ShaderNode: the exponent

Returns

the exponential

normalize

public static ShaderNode normalize(ShaderNode a)

Returns the unit vector in the direction of a.

Parameters

a ShaderNode: a non zero vector

Returns

the normalized vector

saturate

public static ShaderNode saturate(ShaderNode a)

Returns a clamped to 0 to 1, per component.

Parameters

a ShaderNode: the value

Returns

the saturated value

length

public static ShaderNode length(ShaderNode a)

Returns the length of a vector.

Parameters

a ShaderNode: the vector

Returns

a FLOAT node

distance

public static ShaderNode distance(ShaderNode a, ShaderNode b)

Returns the distance between two points.

Parameters

a ShaderNode: a point
b ShaderNode: another point of the same type

Returns

a FLOAT node

dot

public static ShaderNode dot(ShaderNode a, ShaderNode b)

Returns the dot product.

Parameters

a ShaderNode: a vector
b ShaderNode: another vector of the same type

Returns

a FLOAT node

cross

public static ShaderNode cross(ShaderNode a, ShaderNode b)

Returns the cross product of two VEC3 nodes.

Parameters

a ShaderNode: a vector
b ShaderNode: another vector

Returns

a VEC3 node

reflect

public static ShaderNode reflect(ShaderNode i, ShaderNode n)

Returns the reflection of incident direction i about normal n.

Parameters

i ShaderNode: the incident direction
n ShaderNode: the unit normal

Returns

a node of the type of i

min

public static ShaderNode min(ShaderNode a, ShaderNode b)

Returns the smaller of two values, per component.

Parameters

a ShaderNode: a value
b ShaderNode: another value

Returns

the minimum

max

public static ShaderNode max(ShaderNode a, ShaderNode b)

Returns the larger of two values, per component.

Parameters

a ShaderNode: a value
b ShaderNode: another value

Returns

the maximum

pow

public static ShaderNode pow(ShaderNode a, ShaderNode b)

Returns a raised to b, per component. a must not be negative.

Parameters

a ShaderNode: the base
b ShaderNode: the exponent, of the type of a or a FLOAT

Returns

the power

pow

public static ShaderNode pow(ShaderNode a, float b)

Returns a raised to a constant.

Parameters

a ShaderNode: the base, not negative
b float: the exponent

Returns

the power

mod

public static ShaderNode mod(ShaderNode a, ShaderNode b)

Returns a modulo b with the sign of b, as GLSL’s mod does (HLSL’s fmod differs for negative values, so this is printed as a - b * floor(a / b) everywhere).

Parameters

a ShaderNode: the dividend
b ShaderNode: the divisor

Returns

the remainder

atan2

public static ShaderNode atan2(ShaderNode y, ShaderNode x)

Returns the angle of the vector (x, y) in radians, -pi to pi.

Parameters

y ShaderNode: the second coordinate
x ShaderNode: the first coordinate

Returns

the angle

clamp

public static ShaderNode clamp(ShaderNode a, float lo, float hi)

Returns a clamped between lo and hi, per component.

Parameters

a ShaderNode: the value
lo float: the lower bound
hi float: the upper bound

Returns

the clamped value

mix

public static ShaderNode mix(ShaderNode a, ShaderNode b, ShaderNode t)

Linear interpolation from a to b by t.

Parameters

a ShaderNode: the value at 0
b ShaderNode: the value at 1, of the type of a
t ShaderNode: the weight, of the type of a or a FLOAT

Returns

the blend

smoothstep

public static ShaderNode smoothstep(float e0, float e1, ShaderNode x)

Hermite step from 0 at e0 to 1 at e1.

Parameters

e0 float: the lower edge
e1 float: the upper edge
x ShaderNode: the value

Returns

a node of the type of x

smoothstep

public static ShaderNode smoothstep(ShaderNode e0, ShaderNode e1, ShaderNode x)

Hermite step from 0 at e0 to 1 at e1, with node edges.

Parameters

e0 ShaderNode: the lower edge
e1 ShaderNode: the upper edge
x ShaderNode: the value

Returns

a node of the type of x

step

public static ShaderNode step(ShaderNode edge, ShaderNode x)

Returns 0 where x is below edge and 1 elsewhere.

Parameters

edge ShaderNode: the edge
x ShaderNode: the value

Returns

a node of the type of x

select

public static ShaderNode select(ShaderNode condition, ShaderNode a, ShaderNode b)

Returns a where condition is above 0.5, otherwise b. Both branches are computed; this is a select, not a branch.

Parameters

condition ShaderNode: a FLOAT, usually a step
a ShaderNode: the value when true
b ShaderNode: the value when false, of the type of a

Returns

the selected value

unpackNormal

public static ShaderNode unpackNormal(ShaderNode texel, float strength)

Decodes a texel of a tangent space normal map (the usual blue-ish image) into a direction, scaling its slope by strength.

Parameters

texel ShaderNode: a VEC4 read with sample
strength float: 1 for the map as authored, 0 for flat

Returns

a VEC3 tangent space normal, not normalized

perturbNormal

public static ShaderNode perturbNormal(ShaderNode tangentNormal)

Bends the world space surface normal by a tangent space normal, for the NORMAL hook. The tangent frame is derived from the surface normal and the world axes, so it needs no tangents in the mesh and is the same on every backend: on ground and water, tangent x runs along world x and y along world z; on walls it runs around the vertical. That suits tiling detail, noise and terrain maps. A map painted for one model’s UV layout reads correctly where that layout follows the world axes.

Parameters

tangentNormal ShaderNode: a VEC3, such as unpackNormal’s

Returns

the unit world space normal

blendNormals

public static ShaderNode blendNormals(ShaderNode base, ShaderNode detail)

Blends two tangent space normals so the detail rides on the base rather than averaging it flat (“whiteout” blend).

Parameters

base ShaderNode: a VEC3 tangent space normal
detail ShaderNode: another

Returns

the combined VEC3, not normalized

widen

public static ShaderNode widen(ShaderNode n, ShaderType t)

Repeats a FLOAT into a vector of t, or returns the node itself when it already has that type.

Parameters

n ShaderNode: the node
t ShaderType: the target type

Returns

a node of type t

getType

public ShaderType getType()

Returns the type of the value.

Returns

the type