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.

1. Open the custom_mesh_material.basemat file from the assets/Materials folder by using plain text editor.
2. Modify it as follows:
   Source code (XML)

   <!-- Custom mesh material -->
   <?xml version="1.0" encoding="utf-8"?>
   <base_material version="2.0" name="custom_mesh_material" editable="0" parameters_prefix="m">
   
   	<!-- States -->
   	<state name="deferred">1</state>
   	
   	<!-- Deferred rendering shaders -->
   	<shader pass="deferred" node="object_mesh_static"
   		deferred="1"
   		defines="BASE_DEFERRED"
   		vertex="shaders/vertex/deferred.vert"
   		fragment="shaders/fragment/deferred.frag"/>
   	
   	<!-- Bindings -->
   	<bind node="object_mesh_dynamic" to="object_mesh_static"/>
   	<bind node="object_mesh_skinned" to="object_mesh_static"/>
   
   	<!-- Textures -->
   	<texture unit="0" name="albedo" anisotropy="1" shader="fragment" pass="deferred">core/textures/common/white.dds</texture>
   	<texture unit="1" name="height" shader="all" pass="deferred">core/textures/common/white.dds</texture>
   </base_material>

Now the textures will be available for the shaders. We specified the name of the texture, rendering pass, and the path to the default texture.

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 assets/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
   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
   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)
   	float4 row_0 = s_transform[0];
   	float4 row_1 = s_transform[1];
   	float4 row_2 = s_transform[2];
   	
   	// Perfrom 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 height = TEXTURE_BIAS_ZERO(TEX_HEIGHT,texcoord.xy);
   	
   	// Perform the displacement mapping
   	position.rgb += normal * (height.r) * 0.2f;
   	
   	// Set output position
   	OUT_POSITION = getPosition(position);
   
   MAIN_END
   
   // end

   Warning

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

That's it! Our vertex shader now calculates the normals, gets the texture and performs the displacement mapping. 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 assets/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
   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 shaders, so we should reload them by using the shaders_reload console command.

Open the console and execute the shaders_reload command.

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 textures tab of the material in the Parameters window.

   

4. Choose the albedo and the displacement maps for the material.

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