Creating a Custom Shader for Deferred Rendering Pass

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

First, let's edit the custom material and add texture slots.

1. Open the custom material .mat file by using plain text editor.
2. Edit it in the following way:
   Source code (XML)

   <?xml version="1.0" encoding="utf-8"?>
   <materials version="2.3">
   	
   	<!-- Other materials defined here -->
   
   	<!-- Custom mesh material -->
   	<material name="custom_mesh_material" editable="0">
   		
   		<!-- States -->
   		<state name="deferred">1</state>
   		
   		<!-- Deferred rendering shaders -->
   		<shader pass="deferred" object="mesh_static"
   			deferred="1"
   			defines="BASE_DEFERRED"
   			vertex="<your project folder>/data/shaders/vertex/deferred.vert"
   			fragment="<your project folder>/data/shaders/fragment/deferred.frag"/>
   		
   		<!-- Bindings -->
   		<bind object="mesh_dynamic" to="mesh_static"/>
   		<bind object="mesh_skinned" to="mesh_static"/>
   						
   		<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>
   
   	</material>
   	
   </materials>

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 better 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 whole shader's code. Let's do it in the vertex shader:

1. Open the vertex shader deferred.vert file 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 add 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 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 changed the material and shader, so we should reload materials and shader by using materials_reload and shaders_reload console commands.

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

It looks much better! So perform the following:

1. Create a new material by inheriting recently created.

   

2. Go to the textures tab of the material.

   

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

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