Creating a Custom Shader for Deferred Rendering Pass

• The article on Material Settings
• The article on Custom Materials

First, let's edit our custom base material and add two texture slots and a parameter to control displacement.

1. Open the custom_mesh_material.basemat file from the data/materials folder by using plain text editor.
2. Modify it as follows:
   Source Code (ULON)

   // describing the read-only custom mesh material to be used for static meshes, 
   // setting prefixes to be used in shaders to refer to textures and parameters 
   BaseMaterial custom_mesh_material <node=ObjectMeshStatic editable=false var_prefix=var texture_prefix=tex default=true>
   {
   	// enabling the deferred pass for our material and hiding it (will be invisible in the UnigineEditor)
   	State deferred=1	<internal=true>
   	
   	// describing textures and parameters
   	Group "Base"
   	{
   		Texture2D albedo="core/textures/common/grain.dds" <unit=0 pass=[deferred] tooltip="Albedo texture">
   		Texture2D displacement="core/textures/common/white.dds" <unit=1 pass=[deferred] tooltip="Displacement map">
   		Slider displacement_scale=0 <min=-0.5 max=0.5 tooltip="Displacement scale">
   	}
   
   	//////////////////////////////////////////////////////////////////////////
   	// Passes
   	//////////////////////////////////////////////////////////////////////////
   
   	// describing the deferred pass with links to shaders to be used
   	Pass deferred <defines="BASE_DEFERRED">
   	{
   		Vertex   = "shaders/vertex/deferred.vert"
   		Fragment = "shaders/fragment/deferred.frag"
   	}
   	
   	// describing bindings for node types to which the material is to be applicable
   	Bind ObjectMeshStatic=ObjectMeshDynamic
   	Bind ObjectMeshStatic=ObjectMeshSkinned
   }

Now the textures and the parameter will be available for the shaders. We specified the name of the texture, rendering pass, and the path to the default texture. Our parameter (displacement_scale) shall be controlled by a slider with the specified minimum, maximum, and default values.

Now we should edit the vertex shader code and add the texture to the shader.

The best way to add the texture in the shader (an example):

// Initialize the texture slot for a texture named TEX_COLOR
INIT_TEXTURE(0, TEX_COLOR)

It makes changing the number of textures slots easy without correction of the whole shader's code. Let's do it in the vertex shader:

1. Open the vertex shader deferred.vert file in the data/shaders/vertex folder by using plain text editor.
2. Edit the source code in the following way:
   Source code (UUSL)

   // Include Unified Unigine Shader Language (UUSL) header
   #include <core/shaders/common/common.h>
   
   // Create a texture sampler (slot 0 is used in the fragment shader for the color texture)
   INIT_TEXTURE(1,TEX_HEIGHT)
   
   // Input data struct
   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
   	INIT_INSTANCE
   END
   
   // Our output vertex data struct
   STRUCT(VERTEX_OUT)
   	INIT_POSITION						// Out projected position
   	INIT_OUT(float4,0)					// Texcoord (uv)
   	INIT_OUT(float3,1)					// Vertex TBN (X)
   	INIT_OUT(float3,2)					// Vertex TBN (Y)
   	INIT_OUT(float3,3)					// Vertex TBN (Z)
   END
   
   MAIN_BEGIN(VERTEX_OUT,VERTEX_IN)
   	
   	// Get transform with scale and rotation (without translation)
   	float4x4 transform = getObjectTransform(IN_INSTANCE);
   	float4 row_0 = transform[0];
   	float4 row_1 = transform[1];
   	float4 row_2 = transform[2];
   	
   	// Perform Modelview-space transform
   	float4 in_vertex = float4(IN_ATTRIBUTE(0).xyz,1.0f);
   	float4 position = mul4(row_0,row_1,row_2,in_vertex);
   	
   	// Set output UV
   	float4 texcoord = IN_ATTRIBUTE(1);
   	OUT_DATA(0) = texcoord;
   	
   	// Define tangent basis
   	float3 tangent,binormal,normal;
   	
   	// Get 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));
   	
   	// Set output TBN matrix
   	OUT_DATA(1) = float3(tangent.x,binormal.x,normal.x);
   	OUT_DATA(2) = float3(tangent.y,binormal.y,normal.y);
   	OUT_DATA(3) = float3(tangent.z,binormal.z,normal.z);
   	
   	// Set the texture
   	float4 displacement = TEXTURE_BIAS_ZERO(TEX_HEIGHT,texcoord.xy);
   	
   	// Perform the displacement mapping using the Displacement Scale parameter of the material (with the "var" prefix")
   	position.rgb += normal * (displacement.r * var_displacement_scale);
   	
   	// Set output position
   	OUT_POSITION = getPosition(position);
   
   MAIN_END
   
   // end

   Warning

   You should add a new line (press Enter) after closing the instruction (after the MAIN_END command).
3. Save the file.

That's it! Our vertex shader now calculates normals, gets a texture and performs displacement mapping taking into account the scale value. We've added three new output semantics and now we should receive them in our fragment shader.

Now we should edit the fragment shader code and add the albedo texture to the shader.

1. Open the fragment shader deferred.frag file in the data/shaders/fragment folder by using plain text editor.
2. Edit the source code in the following way:
   Source code

   // Include the UUSL language header
   #include <core/shaders/common/fragment.h>
   
   // Adds a texture sampler  (slot 0)
   INIT_TEXTURE(0, TEX_COLOR)
   
   STRUCT(FRAGMENT_IN)
   	INIT_POSITION				// Projected position
   	INIT_IN(float4,0)			// Texcoord (uv)
   	INIT_IN(float3,1)			// Vertex TBN (X)
   	INIT_IN(float3,2)			// Vertex TBN (Y)
   	INIT_IN(float3,3)			// Vertex TBN (Z)
   END
   
   MAIN_BEGIN_DEFERRED(FRAGMENT_IN)
   	
   	// Get the UV coords
   	float4 texcoord = IN_DATA(0);
   
   	// Get the texture data
   	float4 texture_data = TEXTURE(TEX_COLOR,texcoord.xy);
   	
   	// Define the normal of a fragment in tangent-space
   	STATICVAR float3 tangentspace_normal = float3(0.0f,0.0f,1.0f);
   	
   	// Calculate the view-space normal
   	float3 viewspace_normal;
   	viewspace_normal.x = dot(IN_DATA(1),tangentspace_normal);
   	viewspace_normal.y = dot(IN_DATA(2),tangentspace_normal);
   	viewspace_normal.z = dot(IN_DATA(3),tangentspace_normal);
   	viewspace_normal = normalize(viewspace_normal);
   
   	// Fill G-Buffer: set the calculated normal and albedo color of the texture
   	GBuffer gbuffer = GBufferDefault();
   	gbuffer.albedo = texture_data.rgb;
   	gbuffer.normal = viewspace_normal;
   
   	setGBuffer(gbuffer);
   	
   MAIN_END
   
   // end

   Warning

   You should add a new line (press Enter) after closing the instruction (after MAIN_END command).
3. Save the file.

Now our shaders are ready to work! Let's see them in action!

We've changed our materials and shaders, so we should reload them by using the relative console commands.

Open the console and execute the materials_reload command and then — the shaders_reload command (or use the corresponding hotkeys).

Now the result is different — we see the white lit sphere:

It looks much better! But let's go a bit further. Perform the following actions:

1. Inherit a material from your custom base material (a child material named custom_mesh_material_0 will be created).

   

2. Assign the created child material custom_mesh_material_0 to the sphere by dragging it to the object.
3. Go to the Parameters window.

   

4. Choose the Albedo and the Displacement textures for the material and adjust the Displacement Scale parameter.
   Notice

   You can also switch the parameter to the Expression mode and insert a script to animate the value, e.g.: sin(time)/2

Voila! We just created a new deferred material with own shaders which uses two textures for albedo and displacement mapping!