Creating of Custom Shader for Deferred Rendering Pass

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

In this article, we create a material for static, dynamic and skinned meshes. We define a heightmap for a vertex shader and a diffuse 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) create the materials folder.
2. Create the empty <your material name>.xml file.
3. Open the material file in any plain text editor and create the following document structure:
   Source code (XML)

   <?xml version="1.0" encoding="utf-8"?>
   
   <materials version="2.0" editable="0">
   	<!-- 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>/shaders/vertex/deferred.vert"
   			fragment="<your project folder>/shaders/fragment/deferred.frag"/>
   		
   		<!-- bindings -->
   		<bind object="mesh_dynamic" to="mesh_static"/>
   		<bind object="mesh_skinned" to="mesh_static"/>
   		
   	</material>
   	
   </materials>

   • In the code above, we defined a new custom material with the deferred state.
   • Also we defined shaders for the deferred state 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 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)
   	INIT_OUT(float3,1)				// Vertex direction
   	INIT_CUSTOM_DEPTH_VERTEX_OUT	// For custom depth
   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 vertex direction
   	OUT_DATA(1) = position.xyz * s_depth_range.w;
   	
   	// Set output position
   	OUT_POSITION = getPosition(position);
   	// For custom depth
   	PERFORM_DEPTH_VERTEX_OUT
   MAIN_END

   Warning

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

   The code is pretty simple and clear:

   • Includes the UUSL header.
   • Defines the input vertex data structure.
   • Defines the output vertex data structure.
   • Starts the main program of the shader:
     • Translates the object-space coordinates to clipping space coordinates.
     • Sets the output UV.
     • Sets the vertex direction.
     • Sets the vertex position.
4. Save the shader file with the deferred.vert extension inside the shaders/vertex folder.

This sections 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>
   
   STRUCT(FRAGMENT_IN)
   	INIT_POSITION				// Projected position
   	INIT_IN(float4,0)			// Texcoord (uv)
   	INIT_IN(float3,1)			// Vertex direction
   	INIT_CUSTOM_DEPTH_VERTEX_IN // For custom depth
   END
   
   MAIN_BEGIN(FRAGMENT_OUT,FRAGMENT_IN)
   	
   	// Fill G-Buffer
   	SET_DEPTH(length(IN_DATA(1)))
   	SET_NORMAL(float3(0.0f,0.0f,1.0f))
   	SET_DIFFUSE(float3_one)
   	SET_ALPHA(01.0f)
   	SET_SPECULAR(float3(0.0f,0.0f,0.0f))
   	SET_GLOSS(0.0f)
   	SET_DECAL_MASK(0)
   	SET_TRANSLUCENT(0.0f)
   	SET_VELOCITY(float3(0.0f,0.0f,1.0f),float3(0.0f,0.0f,1.0f))
   	SET_MICROFIBER(0.0f)
   	SET_OCCLUSION(1.0f)
   	SET_LIGHT_MAP(float3_zero)
   
   	// For custom depth
   	CUSTOM_DEPTH_FRAGMENT_OUT 
   	
   MAIN_END

   Warning

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

   Some explanations:

   • We include the UUSL header.
   • Define the input fragment data struct.
   • Start the main program of the shader:
     • Fill the G-Buffer:
       • SET_DEPTH command calculates the depth to the fragment.
       • SET_NORMAL command sets the normal vector.
       • SET_DIFFUSE command sets the diffuse value.
       • SET_ALPHA command sets the alpha value
       • SET_SPECULAR command sets the specular value.
       • SET_GLOSS command sets the gloss value.
       • SET_DECAL_MASK command sets the decal mask value.
       • SET_TRANSLUCENT command sets the translucent value.
       • SET_VELOCITY command fills the velocity buffer.
       • SET_MICROFIBER command sets the microfiber value.
       • SET_OCCLUSION command sets the occlusion value.
       • SET_LIGHT_MAP command sets the light map value.
2. Save the shader file with the deferred.frag 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. Open UnigineEditor and launch your project.
2. Go the Materials settings and add a new material, which you recently created.
3. Create a primitive, for example, a sphere.
4. Assign the custom material.

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 diffuse map.

Editting the Material

Editting 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

Editting the Material