UUSL Data Types and Common Intrinsic Functions

This documentation article contains information about data types, functions, pre-defined variables and other features of the UUSL. This information can be used as the reference document for writing shaders.

To start using UUSL functions, include the core/shaders/common/common.h file.

#include <core/shaders/common/common.h>

For fragment shader functions, use the core/shaders/common/fragment.h file.

Predefined Values

Void Main Function

MAIN_VOID_BEGIN(STRUCT_IN)
	<your code here>
MAIN_VOID_END

void main() {
	<your code here>
}

void main(STRUCT_IN IN) {
	<your code here>
}

Main Function with Return Value

MAIN_BEGIN(STRUCT_IN,STRUCT_OUT)
	<your code here>
MAIN_END

void main() {
	<your code here>
}

STRUCT_OUT main(STRUCT_IN IN) { 
	STRUCT_OUT OUT;
	<your code here>
return OUT; }

Geometry Shader Main Function

MAIN_GEOM_BEGIN(STRUCT_OUT,STRUCT_IN)
	<your code here>
END_GEOM

layout(TYPE_GEOM_IN) in;
layout(TYPE_GEOM_OUT,max_vertices = MAX_VERTICES_GEOM) out;
void main() {
	<your code here>
}

[maxvertexcount(MAX_VERTICES_GEOM)]
void main(TYPE_GEOM_IN STRUCT_IN IN[COUNT_GEOM_IN],inout TYPE_GEOM_OUT<STRUCT_OUT> stream) {
	STRUCT_OUT OUT;
	<your code here>
}

Static Variables

STATICVAR <your var>

const <your var>

static const <your var>

Static Arrays

STATICARRAY(TYPE,NAME,SIZE)
	<your array members>
ENDARRAY

TYPE NAME [SIZE] = TYPE[](<your array members>);

static const TYPE NAME [SIZE] = {<your array members>};

UUSL contains blending presets. When you specify the type of blending in material, the USSL wrapper automatically defines a new definition, that you can use in your shader:

HLSL Flow Control Attributes

Interpolation Modifiers

In USSL structures is the way to organize the bunch of input and output data.

To start using structures in your shader code, use the following instructions:

STRUCT(NAME)
	<your data>
END

• NAME - the name of the struct.

Here is an example of vertex shader input structure:

// Input vertex data
STRUCT(VERTEX_IN)
	INIT_ATTRIBUTE(float4,0,POSITION)	// Vertex position
	INIT_ATTRIBUTE(float4,1,TEXCOORD0)	// Vertex texcoord (uv)
	INIT_ATTRIBUTE(float4,2,TEXCOORD1)	// Vertex basis tangent
	INIT_ATTRIBUTE(float4,3,TEXCOORD2)	// Vertex color
END

After that, you should pass the VERTEX_IN structure to the main function of the vertex shader.

For using constant buffer in your shader code, use the following instructions:

CBUFFER(NAME)
	<your data>
END

• NAME - the name of the cbuffer.

Here is an example of using constant buffer:

CBUFFER(parameters)
	UNIFORM float grayscale_power;
END

If you defined this parameter in the material, you'll be able to specify this value.

See Also

To export shader, use the following command:

EXPORT_SHADER(FILE)

• FILE - The name of the file.

This command exports the shader program into a file: for Direct3D the file will have an .hlsl extension, for OpenGL the file will have an .glsl extension.

The command expands all of the predefined UUSL syntax and creates shader files in native languages for both graphic APIs.

fmod (X, Y)

Equivalents

mod(X,Y)

fmod(X,Y)

Arguments

• X - The dividend value.
• Y - The divisor value.

frac (value)

Equivalents

fract(value)

frac(value)

Arguments

• value - The specified value.

lerp (X, Y, value)

Equivalents

mix(X,Y,value)

lerp(X,Y,value)

Arguments

• X - The first value.
• Y - The second value.
• value - A value that linearly interpolates between the x parameter and the y parameter.

rsqrt (value)

Equivalents

inversesqrt(value)

rsqrt(value)

Arguments

• value - The specified value.

saturate (value)

Equivalents

clamp(value,0.0f,1.0f)

saturate(value)

Arguments

• value - The specified value.

ddx (value)

Equivalents

dFdx(value)

ddx(value)

Arguments

• value - The specified value.

ddy (value)

Equivalents

dFdy(value)

ddy(value)

Arguments

• value - The specified value.

rcp (value)

Equivalents

(1.0f / (value))

rcp(value)

Arguments

• value - The specified value.

equal (X, Y)

Equivalents

equal(X,Y)

(X == Y)

Arguments

• X - The first specified value.
• Y - The second specified value.

greaterThan (X, Y)

Equivalents

greaterThan(X,Y)

(X > Y)

Arguments

• X - The first specified value.
• Y - The second specified value.

atan2 (X, Y)

Equivalents

atan(X,Y)

atan2(X,Y)

Arguments

• X - The first specified value.
• Y - The second specified value.

any (value)

Equivalents

(value)

any(value)

Arguments

• value - The specified value.

float max2 (value)

Equivalents

max(value.r,value.g)

max(value.r,value.g)

Arguments

• value - The specified vector (can be float2, float3 or float4 vector).

Return value

float max3 (value)

Equivalents

max(max(value.r,value.g),value.b)

max(max(value.r,value.g),value.b)

Arguments

• value - The specified vector (can be float3 or float4).

Return value

float max4 (float4 value)

Equivalents

max(max(max(value.r,value.g),value.b),value.a)

max(max(max(value.r,value.g),value.b),value.a)

Arguments

• float4 value - The specified vector.

Return value

float min2 (value)

Equivalents

min(value.r,value.g)

min(value.r,value.g)

Arguments

• value - The specified vector (can be float2, float3 or float4 vector).

Return value

float min3 (value)

Equivalents

min(min(value.r,value.g),value.b)

min(min(value.r,value.g),value.b)

Arguments

• value - The specified vector (can be float3 or float4 vector).

Return value

float min4 (float4 value)

Equivalents

min(min(min(value.r,value.g),value.b),value.a)

min(min(min(value.r,value.g),value.b),value.a)

Arguments

• float4 value - The specified vector.

Return value

pow2 (value)

Equivalents

value * value

value * value

Arguments

• value - The specified value to be powered (can be float, float2, float3 or float4.

Return value

float nrand (float2 seed)

Equivalents

frac(sin(dot(seed,float2(12.9898f,78.233f))) * 43758.5453f)

frac(sin(dot(seed,float2(12.9898f,78.233f))) * 43758.5453f)

Arguments

• float2 seed - The random seed.

float2 nrand (float2 seed_0, float2 seed_1)

Arguments

• float2 seed_0 - The first random seed.
• float2 seed_1 - The second random seed.

float2 nrand2 (float2 seed)

Arguments

• float2 seed - The random seed.

float nrandTiled (float2 seed_0, flaot tiled)

Arguments

• float2 seed_0 - The first random seed.
• flaot tiled - The seed of tiling (the number should be the power of two).

float2 nrandTiled (float2 seed_0, float2 seed_1, float tiled)

Arguments

• float2 seed_0 - The first random seed.
• float2 seed_1 - The second random seed.
• float tiled - The seed of tiling (the number should be the power of two).

float2 nrand2Tiled (float2 seed, float tiled)

Arguments

• float2 seed - The random seed.
• float tiled - The seed of tiling (the number should be the power of two).

float nrandTemporal (float2 seed_0, flaot tiled)

Arguments

• float2 seed_0 - The first random seed.
• flaot tiled - The seed of tiling (the number should be the power of two).

float2 nrandTemporal (float2 seed_0, float2 seed_1, float tiled)

Arguments

• float2 seed_0 - The first random seed.
• float2 seed_1 - The second random seed.
• float tiled - The seed of tiling (the number should be the power of two).

float2 nrand2Temporal (float2 seed, float tiled)

Arguments

• float2 seed - The random seed.
• float tiled - The seed of tiling (the number should be the power of two).

float nrandTAA (float2 seed_0, flaot tiled)

Arguments

• float2 seed_0 - The first random seed.
• flaot tiled - The seed of tiling (the number should be the power of two).

float2 nrandTAA (float2 seed_0, float2 seed_1, float tiled)

Arguments

• float2 seed_0 - The first random seed.
• float2 seed_1 - The second random seed.
• float tiled - The seed of tiling (the number should be the power of two).

float2 nrand2TAA (float2 seed, float tiled)

Arguments

• float2 seed - The random seed.
• float tiled - The seed of tiling (the number should be the power of two).

dotFixed (X, Y)

Equivalents

saturate(dot(X,Y))

saturate(dot(X,Y)))

Arguments

• X - The first specified vector.
• Y - The second specified vector.

lerpFixed (X, Y, FACTOR)

Equivalents

lerp(X,Y,saturate(FACTOR))

lerp(X,Y,saturate(FACTOR))

Arguments

• X - The first specified vector.
• Y - The second specified vector.
• FACTOR - A value that linearly interpolates between the x parameter and the y parameter.

float4 getPosition (vertex)

Arguments

• vertex - The first specified vertex (float4 or float3 type).

Return value

float3 getViewDirection (screen_position)

float3((position + s_perspective.zw) / s_perspective.xy,-1.0f);

float3((position + s_perspective.zw) / s_perspective.xy,-1.0f);

Arguments

• screen_position - Position (float2, float3 or float3 type).

Return value

void getTangentBasis (float4 basis, float3 tangent, float3 binormal, float3 normal)

// Get normals
float3 tangent,binormal,normal;

// Getting normal in object-space
getTangentBasis(IN_ATTRIBUTE(2),tangent,binormal,normal);

// Transform object-space TBN into camera-space TBN
normal = normalize(mul3(row_0,row_1,row_2,normal));
tangent = normalize(mul3(row_0,row_1,row_2,tangent));
binormal = normalize(mul3(row_0,row_1,row_2,binormal));

Arguments

• float4 basis - The first specified vertex.
• float3 tangent - The first specified vertex.
• float3 binormal - The first specified vertex.
• float3 normal - The first specified vertex.

float3 mul3 (float4x4 matrix, float3 vector)

Arguments

• float4x4 matrix - The 4x4 matrix.
• float3 vector - The 3-component vector.

Return value

float3 mul3 (float3 vector, float4x4 matrix)

Arguments

• float3 vector - The 3-component vector.
• float4x4 matrix - The 4x4 matrix.

Return value

float3 mul3 (float4 row_0, float4 row_1, float4 row_2, float3 vector)

Arguments

• float4 row_0 - The first row of the matrix
• float4 row_1 - The second row of the matrix
• float4 row_2 - The third row of the matrix
• float3 vector - The 3-component vector.

Return value

float4 mul4 (float4x4 matrix, float3 vector)

(m * float4(v,1.0f)).xyz;

(m * float4(v,1.0f)).xyz;

Arguments

• float4x4 matrix - The 4x4 matrix.
• float3 vector - The 3-component vector.

Return value

float4 mul4 (float4x4 matrix, float4 vector)

Arguments

• float4x4 matrix - The 4x4 matrix.
• float4 vector - The 4-component vector.

Return value

float4 mul4 (float4 row_0, float4 row_1, float4 row_2, float3 vector)

float4(dot(row_0,v),dot(row_1,v),dot(row_2,v),v.w);

float4(dot(row_0,v),dot(row_1,v),dot(row_2,v),v.w);

Arguments

• float4 row_0 - The first row of the matrix
• float4 row_1 - The second row of the matrix
• float4 row_2 - The third row of the matrix
• float3 vector - The 4-component vector.

Return value

SET_DEPTH (value)

Arguments

• value - Depth value.

SET_VOLUMETRIC (volumetric)

Arguments

• volumetric - Volumetric value.

SET_DIFFUSE (value)

Arguments

• value - Diffuse value.

SET_MICROFIBER (value)

Arguments

• value - Microfiber value.

SET_NORMAL (value)

Arguments

• value - Normal value.

SET_GLOSS (value)

Arguments

• value - .

SET_SPECULAR (value)

Arguments

• value - .

SET_TRANSLUCENT (value)

Arguments

• value - Translucent value.

SET_OCCLUSION (value)

Arguments

• value - Occlusion value.

SET_LIGHT_MAP (value)

Arguments

• value - Lightmap value.

SET_DECAL_MASK (value)

Arguments

• value - Decal mask value.

SET_VELOCITY (value)

Arguments

• value - Velocity value.

SET_ALPHA (value)

Arguments

• value - Velocity value.

float GET_DEFERRED_DEPTH (TEX_DEPTH, COORD)

Arguments

• TEX_DEPTH - Depth texture slot.
• COORD - UV coordinates.

float FETCH_DEFERRED_DEPTH (TEX_DEPTH, COORD)

Arguments

• TEX_DEPTH - Depth texture slot.
• COORD - UV coordinates.

Here is an example of scattering functions usage:

#ifdef USE_HAZE
	#ifdef USE_HAZE_SCATTERING
		float4 haze = hazeScattering(depth,camera_dir,TEXTURE_OUT_3(TEX_BASE_LUT,TEX_MIE_SUN_LUT,TEX_MIE_MOON_LUT));
	#elif USE_HAZE_SOLID
		float4 haze = hazeSolid(depth);
	#endif
	
	OUT_COLOR.rgb = OUT_COLOR.rgb * haze.a + haze.rgb;
#endif

// forward
#ifdef USE_HAZE && !STAR_AMBIENT
	OUT_COLOR = hazeForward(OUT_COLOR,depth,camera_dir,TEXTURE_OUT_3(TEX_BASE_LUT,TEX_MIE_SUN_LUT,TEX_MIE_MOON_LUT));
#endif

float4 hazeScattering (float depth, float3 camera_dir, TEXTURE_IN_3 (base,mie_sun,mie_moon))

Arguments

• float depth - Depth value.
• float3 camera_dir - Camera direction vector.
• TEXTURE_IN_3 (base,mie_sun,mie_moon) - Set of 3 LUT textures: base, mie sun and mie moon.

Return value

float4 hazeForward (float4 color, float depth, float3 camera_dir, TEXTURE_IN_3 (base,mie_sun,mie_moon))

Arguments

• float4 color - Color
• float depth - Depth value.
• float3 camera_dir - Camera direction vector.
• TEXTURE_IN_3 (base,mie_sun,mie_moon) - Set of 3 LUT textures: base, mie sun and mie moon.

Return value

float hazeAlpha (float depth)

Arguments

• float depth - Depth value.

Return value

float hazeAlpha (float3 position)

Arguments

• float3 position - Position.

Return value

float hazeAlpha (float4 position)

Arguments

• float4 position - Position.

Return value

float4 hazeSolid (float depth)

Arguments

• float depth - Depth value.

Return value

float4 hazeSolid (float position)

Arguments

• float position - Position.

Return value

float4 hazeSolid (float position)

Arguments

• float position - Position.

Return value

float4 hazeForwardSimple (float4 color, float depth)

Arguments

• float4 color - Color vector.
• float depth - Depth value.

Return value

float4 hazeForwardSimple (float4 color, float3 position)

Arguments

• float4 color - Color vector.
• float3 position - Position.

Return value

float4 hazeForwardSimple (float4 color, float4 position)

Arguments

• float4 color - Color vector.
• float4 position - Position.

Return value