Creating of Custom Shader for Deferred Rendering Pass

In Unigine all the opaque geometry is rendered in the deferred rendering pass. This article explains how to create your own material with shaders (both vertex and fragment) for the deferred rendering pass.

In this article, we create a material for static, dynamic and skinned meshes. We define a heightmap for a vertex shader and a albedo texture for fragment shader. Also, we calculate normals to make our mesh be lit properly.

See Also

The material is the essential thing for rendering: you specify shaders, states, bindings, textures in the material thus telling the engine how to render it.

Let's create our own material (for deferred pass only) and write the vertex and the fragment shaders for it. Perform the following steps to create the material:

1. In your project folder (which located in the data folder) open the materials folder.
2. Open the existing material library with .mat extension in any plain text editor.
3. Add the following material to the material library:
   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"/>
   	</material>
   	
   </materials>

   • We defined a new custom_mesh_material material with the deferred state.
   • Also we defined shaders (fragment and vertex) for the deferred pass and set the paths to them (we will create these shader files and folder in further steps).
   • Finally, we defined the bindings: types of meshes for which the material can be assigned.
4. Save the changes.

In this section we explain how to create the structure for shaders and how to create the custom vertex shader.

We assign two shaders in out material: vertex and fragment. To create the vertex shader, perform the following:

1. Create the shaders folder in your project's data folder.
2. Inside recently created folder, create another two folders: vertex for vertex shaders, fragment for fragment shaders.
3. Open a plain text editor and write the following:
   Source code (UUSL)

   // Include Unified Unigine Shader Language (UUSL) header
   #include <core/shaders/common/common.h>
   
   // 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)
   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];
   	
   	// Get 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;
   	
   	// 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).

   The code is pretty simple and clear. In the code above we

   • Include the UUSL header.
   • Define the input vertex data structure.
   • Define the output vertex data structure.
   • Start the main program of the shader:
     • Translate the object-space coordinates to clipping space coordinates.
     • Set the output UV.
     • Set the vertex position.
4. Save the shader file with the deferred.vert name and extension inside the shaders/vertex folder.

This section contains instructions on how to create a fragment shader (also known as pixel shader).

To create the fragment shader, perform the following:

1. Open a plain text editor, and write the following:
   Source code (UUSL)

   // Include the UUSL language header
   #include <core/shaders/common/fragment.h>
   
   // Input data struct
   STRUCT(FRAGMENT_IN)
   	INIT_POSITION				// Projected position
   	INIT_IN(float4,0)			// Texcoord (uv)
   END
   
   MAIN_BEGIN_DEFERRED(FRAGMENT_IN)
   	
   	// Create the G-Buffer and set it
   	GBuffer gbuffer = GBufferDefault();
   	
   	setGBuffer(gbuffer);
   	
   MAIN_END
   
   // end

   Warning

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

   Explanations on fragment shader:

   • We include the UUSL header for fragment shaders.
   • Define the input fragment data struct (where we receive the data from output structure of the vertex shader).
   • Start the main program of the shader, where we create a GBuffer instance for metalness workflow and set it.
2. Save the shader file with the deferred.frag name and extension to the shaders/fragment folder.

After performing all these steps, you can see recently created shaders in use. These shaders are primitive, and they don't provide a nice final image. Anyway, to see their work perform the following steps:

1. Launch your project in editor mode (or open your world by using UnigineEditor).
2. Open the Materials settings window. You will see the recently created material in your project's material library.
3. Assign your custom material to the material ball or create a primitive, for example, a sphere.

After that you'll get the following result:

It doesn't look good, but it works.

Let's go further and calculate the tangent basis for the mesh and assign textures to it.

Let's add textures to the both shaders: vertex and fragment. In vertex shader we will use texture as a heightmap and in the fragment as a albedo map.

Editting the Material

Editing the Vertex Shader

// Define the name of the texture
#define TEX_COLOR 0

// Initialize the texture slot
INIT_TEXTURE(TEX_COLOR)

Editting the Fragment Shader

Editing the Material