UUSL Common Intrinsic Functions

This documentation article contains information functions of the UUSL. This information can be used as the reference document for writing shaders.

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

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

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

Double Functions

overlay(value A, value B, value BLEND)

Equivalents

saturate(A * lerp(float4_one * 0.5f,B,BLEND) * 2);

saturate(A * lerp(float4_one * 0.5f,B,BLEND) * 2);

Arguments

• value A - First value
• value B - Value for overlay.
• value BLEND - Blending coefficient.

fmod(value X, value Y)

Equivalents

mod(X,Y);

fmod(X,Y);

Arguments

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

frac(value value)

Equivalents

fract(value);

frac(value);

Arguments

• value value - The specified value.

lerp(value X, value Y, value value)

Equivalents

mix(X,Y,value);

lerp(X,Y,value);

Arguments

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

float4 lerp3(float4 v0, float4 v1, float4 v2, float a)

Equivalents

if (a < 0.5)
{ 
	mix(v0, v1, a * 2.0f);
} 
else 
{ 
	mix(v1, v2, a * 2.0f - 1.0f);
}

if (a < 0.5)
{ 
	lerp(v0, v1, a * 2.0f);
} 
else 
{ 
	lerp(v1, v2, a * 2.0f - 1.0f);
}

Arguments

• float4 v0 - First vector.
• float4 v1 - Second vector.
• float4 v2 - Third vector.
• float a - Interpolation factor in the range [0.0f, 1.0f].

Return value

value lerpOne(value value, float factor)

Equivalents

value * (1.0f - factor) + factor;

value * (1.0f - factor) + factor;

Arguments

• value value - Value for interpolation. Can be one of the following types:
  • float
  • float2
  • float3
  • float4
• float factor - Interpolation factor.

Return value

• float
• float2
• float3
• float4

float length2(float3 vector)

Arguments

• float3 vector - Vector.

Return value

float smoothClamp(float value, float x, float y)

Equivalents

smoothstep(x, x + y, value);

smoothstep(x, x + y, value);

Arguments

• float value - Value to be clamped.
• float x - Lower bound of the clamping range.
• float y - Clamping range size.

Return value

float gradient4(float a, float4 gradient)

Equivalents

smoothstep(gradient.x, gradient.y, a) - smoothstep(gradient.z, gradient.w, a);

smoothstep(gradient.x, gradient.y, a) - smoothstep(gradient.z, gradient.w, a);

Arguments

• float a - Value to find the gradient value for.
• float4 gradient - Vector with four key components.

Return value

float calculate_dither_pattern(float2 uv)

Arguments

• float2 uv - UV value.

Return value

float getBasisX(float3x3 matrix)

Equivalents

m[0];

m._m00_m10_m20;

Arguments

• float3x3 matrix - 3x3 matrix.

Return value

float getBasisX(float4x4 matrix)

Equivalents

m[0].xyz;

m._m00_m10_m20;

Arguments

• float4x4 matrix - 3x3 matrix.

Return value

float getBasisY(float3x3 matrix)

Equivalents

m[1];

m._m01_m11_m21;

Arguments

• float3x3 matrix - 3x3 matrix.

Return value

float getBasisY(float4x4 matrix)

Equivalents

m[1].xyz;

m._m01_m11_m21;

Arguments

• float4x4 matrix - 3x3 matrix.

Return value

float getBasisZ(float3x3 matrix)

Equivalents

m[2];

m._m02_m12_m22;

Arguments

• float3x3 matrix - 3x3 matrix.

Return value

float getBasisZ(float4x4 matrix)

Equivalents

m[2].xyz;

m._m02_m12_m22;

Arguments

• float4x4 matrix - 3x3 matrix.

Return value

rsqrt(value value)

Equivalents

inversesqrt(value)

rsqrt(value)

Arguments

• value value - The specified value.

saturate(value value)

Equivalents

clamp(value,0.0f,1.0f)

saturate(value)

Arguments

• value value - The specified value.

ddx(value value)

Equivalents

dFdx(value)

ddx(value)

Arguments

• value value - The specified value.

ddy(value value)

Equivalents

dFdy(value)

ddy(value)

Arguments

• value value - The specified value.

rcp(value value)

Equivalents

(1.0f / (value))

rcp(value)

Arguments

• value value - The specified value.

equal(value X, value Y)

Equivalents

equal(X,Y)

(X == Y)

Arguments

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

greaterThan(value X, value Y)

Equivalents

greaterThan(X,Y)

(X > Y)

Arguments

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

atan2(value X, value Y)

Equivalents

atan(X,Y)

atan2(X,Y)

Arguments

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

any(value value)

Equivalents

(value)

any(value)

Arguments

• value value - The specified value.

float max2(value value)

Equivalents

max(value.r,value.g)

max(value.r,value.g)

Arguments

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

Return value

float max3(value value)

Equivalents

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

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

Arguments

• value 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 value)

Equivalents

min(value.r,value.g)

min(value.r,value.g)

Arguments

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

Return value

float min3(value value)

Equivalents

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

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

Arguments

• value 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

value pow2(value value)

Equivalents

value * value

value * value

Arguments

• value value - The specified value to be powered. Can be one of the following types:
  • float
  • float2
  • float3
  • float4

Return value

value powMirror(value value, value power)

Implementation

1.0f - pow(1.0f - value,power);

Arguments

• value value - The specified value to be powered. Can be one of the following types:
  • float
  • float2
  • float3
  • float4
• value power - Power. Can be one of the following types:
  • float
  • float2
  • float3
  • float4

Return value

float3 srgb(float3 color)

Arguments

• float3 color - RGB color to convert.

Return value

float srgbInv(float value)

Implementation

pow(value,float_isrgb);

Arguments

• float value - Value to convert.

Return value

float2 srgbInv(float2 value)

Implementation

pow(value,float2_isrgb);

Arguments

• float2 value - Value to convert.

Return value

float3 srgbInv(float3 value)

Implementation

pow(value,float3_isrgb);

Arguments

• float3 value - Value to convert.

Return value

float4 srgbInv(float4 value)

Implementation

pow(value,float4_isrgb);

Arguments

• float4 value - Value to convert.

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(value X, value Y)

Equivalents

saturate(dot(X,Y))

saturate(dot(X,Y)))

Arguments

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

lerpFixed(value X, value Y, value FACTOR)

Equivalents

lerp(X,Y,saturate(FACTOR))

lerp(X,Y,saturate(FACTOR))

Arguments

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

float4 getPosition(value vertex)

Arguments

• value vertex - The first specified vertex. Can be one of the following types:
  • float3
  • float4

Return value

float3 getDepthToPosition(float depth, float2 uv, float4x4 iprojection)

Arguments

• float depth - Depth value.
• float2 uv - UV position.
• float4x4 iprojection - Inversed projection matrix.

Return value

float3 getDepthToPosition(float depth, float2 uv)

Arguments

• float depth - Depth value.
• float2 uv - UV position.

Return value

float getLinearizedDepth(float native_depth, float2 uv)

Arguments

• float native_depth - Native depth value.
• float2 uv - UV position.

Return value

float getLinearizedDepth(TEXTURE_IN (depth_map), float2 uv)

Arguments

• TEXTURE_IN (depth_map) - Depth map texture.
• float2 uv - UV position.

Return value

float3 getViewDirection(value uv)

Implementation

mul4(s_camera_iprojection,float4(uv,0.0f,1.0f)).xyz

Arguments

• value uv - UV position. Can be one of the following types:
  • float2
  • float3
  • float4
  Notice

  In case of float3 or float4 vectors, vector.xy values will be taken.

Return value

float2 getPositionToUV(float4 position)

Arguments

• float4 position - Fragment position.

Return value

float2 getPositionToUV(float3 position)

Arguments

• float3 position - Fragment position.

Return value

float2 getAnimationOffset(float angle)

Arguments

• float angle - Angle

Return value

void getTangentBasis(float4 basis, float3 out tangent, float3 out binormal, float3 out 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 - Basis vector.
• float3 out tangent - Empty vector for tangent.
• float3 out binormal - Empty vector for binormal.
• float3 out normal - Empty vector for normal.

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

Arguments

• float4 basis - Basis vector.
• float3 out tangent - Empty vector for tangent.
• float3 out normal - Empty vector for normal.

float2 uvTransform(float2 uv, float2 tiling, float2 offset)

Implementation

uv * tiling + offset;

Arguments

• float2 uv - UV position value.
• float2 tiling - Tiling value.
• float2 offset - Offset value.

Return value

float2 uvTransform(float2 uv, float4 transform)

Implementation

uv * transform.xy + transform.zw;

Arguments

• float2 uv - UV position value.
• float4 transform - Transform vector value.

Return value

float4 uvTransform(float4 uv, float2 tiling, float2 offset)

Implementation

uv * tiling.xyxy + offset.xyxy;

Arguments

• float4 uv - UV position value.
• float2 tiling - Tiling value.
• float2 offset - Offset value.

Return value

float4 uvTransform(float4 uv, float4 transform)

Implementation

uv * transform.xyxy + transform.zwzw;

Arguments

• float4 uv - UV position value.
• float4 transform - Transform vector value.

Return value

bool checkUV(float2 uv)

Arguments

• float2 uv - UV position.

Return value

void normalizationTBN(inout float3 T, inout float3 B, inout float3 N, float sign_binormal, float front_face)

Arguments

• inout float3 T - Tangent vector.
• inout float3 B - Binormal vector.
• inout float3 N - Normal vector.
• float sign_binormal - Binormal vector sign (ATTRIBUTE_BASIS.w).
• float front_face - Flag indicated is the mesh two-sided or not. (1 is for front face, -1 for back face).

float3 mul(float3 vector, float3x3 matrix)

Arguments

• float3 vector - The 3-component vector.
• float3x3 matrix - The 3x3 matrix.

Return value

float3 mul(float3x3 matrix, float3 vector)

Arguments

• float3x3 matrix - The 3x3 matrix.
• float3 vector - The 3-component vector.

Return value

float4 mul(float4 vector, float4x4 matrix)

Arguments

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

Return value

float4 mul(float4x4 matrix, float4 vector)

Arguments

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

Return value

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

float3 mul3(float3x3 matrix, float3 vector)

Arguments

• float3x3 matrix - The 3x3 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

float floatPack88To16(float2 value)

Arguments

• float2 value - Value to pack.

float2 floatPack16To88(float value)

Arguments

• float value - Value to pack.

float2 floatPack8888To1616(float4 value)

Arguments

• float4 value - Value to pack.

float4 floatPack1616To8888(float2 value)

Arguments

• float2 value - Value to pack.

float3 floatPack1212To888(float2 value)

Arguments

• float2 value - Value to pack.

float2 floatPack888To1212(float3 value)

Arguments

• float3 value - Value to pack.

float floatPack44To8(float x, float y)

Arguments

• float x - Value to pack.
• float y - Value to pack.

float2 floatPack8To44(float value)

Arguments

• float value - Value to pack.

void loadEnvironmentCubeMap(inout float3 env, inout float3 ref, GBuffer gbuffer, Data data, TEXTURE_IN_CUBE (TEX_REFLECTION))

Arguments

• inout float3 env - ---
• inout float3 ref - ---
• GBuffer gbuffer - GBuffer struct.
• Data data - Data struct.
• TEXTURE_IN_CUBE (TEX_REFLECTION) - Environment cubemap texture.

float3 getEnvironmentReflectVector(GBuffer gbuffer, Data data)

Arguments

• GBuffer gbuffer - GBuffer struct.
• Data data - Data struct.

Return value

void environmentReflectionShading(inout float3 reflection, GBuffer gbuffer, Data data)

Arguments

• inout float3 reflection - Environment reflection.
• GBuffer gbuffer - GBuffer struct.
• Data data - Data struct

void gbufferSRGB(GBuffer gbuffer)

Arguments

• GBuffer gbuffer - GBuffer struct

float getFresnelSchlick(float3 F0, float dotLH)

Arguments

• float3 F0 - Reflectance for H·V = 1.
• float dotLH - Dot product of 2 vectors: vector to light source and normalized halfway vector (H = (V + L) / |V + L|).

float3 getFresnel(float3 specular_color, float3 dotLH)

Arguments

• float3 specular_color - Specular color vector.
• float3 dotLH - Dot product of 2 vectors: vector to light source and normalized halfway vector (H = (V + L) / |V + L|).

float getGGX(float roughness, float dotNV, float dotNL, float dotNH)

Arguments

• float roughness - Roughness value.
• float dotNV - Dot product of 2 vectors: normal vector and vector to camera.
• float dotNL - Dot product of 2 vectors: normal vector and vector to light source.
• float dotNH - Dot product of 2 vectors: normal vector and normalized halfway vector (H = (V + L) / |V + L|).

float getGGX(float roughness, float dotNV, float dotNL, float dotNH, float translucent_scale)

Arguments

• float roughness - Roughness value.
• float dotNV - Dot product of 2 vectors: normal vector and vector to camera.
• float dotNL - Dot product of 2 vectors: normal vector and vector to light source.
• float dotNH - Dot product of 2 vectors: normal vector and normalized halfway vector (H = (V + L) / |V + L|).
• float translucent_scale - Translucent scale value.

float getAreaLightGGX(float roughness, float dotNV, float dotNL, float dotLR, float size)

Arguments

• float roughness - Roughness value.
• float dotNV - Dot product of 2 vectors: normal vector and vector to camera.
• float dotNL - Dot product of 2 vectors: normal vector and vector to light source.
• float dotLR - Dot product of 2 vectors: normal vector and reflected vector.
• float size - The size of specular lighting.

float getAreaLightGGX(float roughness, float dotNV, float dotNL, float dotLR, float size, float translucent_scale)

Arguments

• float roughness - Roughness value.
• float dotNV - Dot product of 2 vectors: normal vector and vector to camera.
• float dotNL - Dot product of 2 vectors: normal vector and vector to light source.
• float dotLR - Dot product of 2 vectors: vector to light source and reflected vector.
• float size - The size of specular lighting.
• float translucent_scale - Translucent scale value.

float getPhong(float dotLR, float power)

Arguments

• float dotLR - Dot product of 2 vectors: normal vector and reflected vector.
• float power - The specular power value.

float getBlinn(float dotNH, float power)

Arguments

• float dotNH - Dot product of 2 vectors: normal vector and normalized halfway vector (H = (V + L) / |V + L|).
• float power - The specular power value.

float getBurley12(float roughness, float dotNV, float dotVH, float dotNL)

Arguments

• float roughness - Roughness value.
• float dotNV - Dot product of 2 vectors: normal vector and vector to camera.
• float dotVH - Dot product of 2 vectors: vector to camera and normalized halfway vector (H = (V + L) / |V + L|).
• float dotNL - Dot product of 2 vectors: normal vector and vector to light source.

float getWrapAround(float dotNL, float factor)

Arguments

• float dotNL - Dot product of 2 vectors: normal vector and vector to light source.
• float factor - Energy conservation factor.

float getTranslucent(float translucent_scale, float dotVL, float dotNL)

Arguments

• float translucent_scale - Translucent scale value.
• float dotVL - Dot product of 2 vectors: vector to camera and vector to light source.
• float dotNL - Dot product of 2 vectors: normal vector and vector to light source.

float3 getSpecularBRDF(Gbuffer gbuffer, float3 specular_color, float dotNV, float dotLH, float dotNL, float dotNH)

Arguments

• Gbuffer gbuffer - GBuffer struct.
• float3 specular_color - Specular color vector.
• float dotNV - Dot product of 2 vectors: normal vector and vector to camera.
• float dotLH - Dot product of 2 vectors: vector to light source and normalized halfway vector.
• float dotNL - Dot product of 2 vectors: normal vector and vector to light source.
• float dotNH - Dot product of 2 vectors: normal vector and normalized halfway vector (H = (V + L) / |V + L|).

float3 getAreaLightSpecularBRDF(Gbuffer gbuffer, float3 specular_color, float dotNV, float dotLH, float dotNL, float dotNH, float size)

Arguments

• Gbuffer gbuffer - GBuffer struct.
• float3 specular_color - Specular color vector.
• float dotNV - Dot product of 2 vectors: normal vector and vector to camera.
• float dotLH - Dot product of 2 vectors: vector to light source and normalized halfway vector.
• float dotNL - Dot product of 2 vectors: normal vector and vector to light source.
• float dotNH - Dot product of 2 vectors: normal vector and normalized halfway vector (H = (V + L) / |V + L|).
• float size - The size of specular lighting.

float2 getDiffuseBRDF(Gbuffer gbuffer, float dotNV, float dotLH, float dotNL, float dotVL)

Arguments

• Gbuffer gbuffer - GBuffer struct.
• float dotNV - Dot product of 2 vectors: normal vector and vector to camera.
• float dotLH - Dot product of 2 vectors: vector to light source and normalized halfway vector.
• float dotNL - Dot product of 2 vectors: normal vector and vector to light source.
• float dotVL - Dot product of 2 vectors: vector to camera and vector to light source.

void getBRDF(float3 diffuse, float specular, Gbuffer gbuffer, Data data, float3 light_direction)

Arguments

• float3 diffuse - Diffuse value.
• float specular - Specular value.
• Gbuffer gbuffer - GBuffer struct.
• Data data - Data struct.
• float3 light_direction - Light direction vector.

float getLightAttenuation(float distance, float light_attenuation)

Arguments

• float distance - Light distance value.
• float light_attenuation - Light attenuation value.

Return value

float getLightAttenuation(float3 position)

Arguments

• float3 position - Position value.

Return value

float getLightAttenuation(float light_distance)

Arguments

• float light_distance - Light Distance value.

Return value

float3 sphereLightToLight(float3 L, float3 direction)

Arguments

• float3 L - Vector to the light source.
• float3 direction - Shift direction vector.

float3 capsuleLightToLight(float3 L, float3 direction, float3 axis, float3 dotLA)

Arguments

• float3 L - Vector to the light source.
• float3 direction - Shift direction vector.
• float3 axis - Axis of shift.
• float3 dotLA - Dot product of 2 vectors: axis vector and vector to light source.

float3 getMicrofiber(color color, Data data, Gbuffer gbuffer)

Arguments

• color color - Color vector.
• Data data - Data struct.
• Gbuffer gbuffer - GBuffer struct.

Return value

float3 specularReflection(float4 specular, float dotVN, float exponent)

Arguments

• float4 specular - Specular value.
• float dotVN - Dot product of 2 vectors: normal vector and vector to camera.
• float exponent - Exponent value for pow(dotVN, exponent) operation.

Return value

float3 specularReflection(float4 specular, float dotVN)

Arguments

• float4 specular - Specular value.
• float dotVN - Dot product of 2 vectors: normal vector and vector to camera.

Return value

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