Tiled Forward Rendering Demo

Creation Date: 2014
Programming Language: C++
Technology: Direct3D 11

This Tiled Forward Rendering Demo is my implementation of the technique based on AMDs Forward+ Rendering (link to the paper). Having implemented several deferred shading pipelines I wanted to try something new and the potential of Tiled Forward Rendering sounded promising.

Tiled Forward Rendering works by drawing many light sources and assigning each of them a 2d tile on the screen. This results a small number of associated light sources for each pixel and thus reduces rendering overhead. The following slider shows a visualization inside my application, tiles which have many light sources associated with them are rendered in red, while tiles which have no associated light sources are rendered in blue. You can drag the slider below for a comparison between the actually rendered scene and the debug view.

My implementation uses the CPU for assigning light sources to tiles and then sends them to the GPU which handles the rest of the lighting calculations. In comparison to Deferred Shading Tiled Forward Rendering provides simple access to hardware antialiasing and provides much more flexibility for designers and shader programmers to use many different materials inside a scene. This may especially be interesting when using physically based rendering approaches.

A zip archive with the executable file and all the required assets is included below. The archive also contains all the uncompiled shader code, so feel free to take a look.

Requirements:

DirectX 11 capable GPU
Visual Studio 2012 C++ Runtime
Windows 8/8.1/10

>> Download Demo <<

A flat view of the scene results in a bigger performance impact. Many light sources may be associated to the same tile!

This shows the screen space rectangle for a single light source, which is used for assigning every light source to the right tile.

The shader source code of the main material:

#include <ShaderInclude.fx>

cbuffer MaterialBuffer : register(b5) {
	float4 DiffuseColor;
	float4 SpecularColor;

	float SpecularPower;		
	float Bumpiness;
	float ShowTiles;
};

// The diffuse texture map which contains all the color information
Texture2D DiffuseMap : register(t0);
// The normal texture map which contains data for normal manipulation
Texture2D NormalMap : register(t1);
// The normal texture map which contains data for normal manipulation
Texture2D SpecularMap : register(t2);

struct VertexShaderInput {
	float3 Position : POSITION;
	float3 Normal	: NORMAL;
	float2 TexCoords : TEXCOORD0;
	float3 Tangent : TANGENT;
};

struct PixelShaderInput {
	float4 Position : SV_POSITION;
	float2 TexCoords : TEXCOORD0;
	float3 PosW : TEXCOORD1;
	float3x3 TTW : TEXCOORD2;		//Tangent To World
};

// Handles all the lighting and applies the influence of the sun light (and its specular light) to the material.
// @diffuseColor:		The diffuse color you want to use for the surface
// @normal:			The normal in world space, which gets used for the lighting calculation
// @posW:			The position of the vertex in world space (used for specular calculation)
// @specularPower:		The specularPower indicates how big the specular highlight is, the higher this value the smaller it will get.
// @specularIntensity:		Indicates how strong the specularHightlight is
float3 ApplyLighting(float3 diffuseColor, float3 normal, float3 posW, float specularPower, float specularIntensity, uint tileIndex) {
	// Debug Render?
	if(ShowTiles > 0) {
		uint startOffset = pointLightOffsets[tileIndex];
		uint endOffset = pointLightOffsets[tileIndex+1];
	
		uint elms = endOffset-startOffset;
		float factor = (float)elms/128;
		
		return lerp(float3(0, 0, 1), float3(1, 0, 0), factor) * diffuseColor;
	}
	
	float3 diffuse = float3(0, 0, 0);
	float3 spec = float3(0, 0, 0);

	// Go through all the point lights
	FOR_ALL_POINT_LIGHTS(light, tileIndex)
		float3 lightVec = light.position - posW;
		float d = length(lightVec);
		
		if(d > light.range)
			continue;
			
		lightVec /= d;
		
		float diffuseFactor = dot(lightVec, normal);
		
		float att = max(0, pow(1 - d / light.range, light.falloff + 1));
		
		[flatten]
		if(diffuseFactor > 0) {
			float3 v = reflect(-lightVec, normal);
			float3 toEye = -normalize(posW.xyz - CamPos.xyz);
			float specFactor = pow(max(dot(v, toEye), 0.0f), specularPower);
			
			diffuse += diffuseFactor * att * light.color;
			spec += specFactor * att * specularIntensity * SpecularColor;
		}

	END_FOR
	
	// Handle directional lights
	float3 lightVec = -DirectionalLight1.direction;
	float diffuseFactor = dot(lightVec, normal);
	[flatten]
	if(diffuseFactor > 0) {
		float3 v = reflect(-lightVec, normal);
		float3 toEye = -normalize(posW.xyz - CamPos.xyz);
		float specFactor = pow(max(dot(v, toEye), 0.0f), specularPower);
		
		diffuse += diffuseFactor * DirectionalLight1.color * DirectionalLight1.enabled;
		spec += specFactor * specularIntensity * SpecularColor * DirectionalLight1.enabled;
	}
	lightVec = -DirectionalLight2.direction;
	diffuseFactor = dot(lightVec, normal);
	[flatten]
	if(diffuseFactor > 0) {
		float3 v = reflect(-lightVec, normal);
		float3 toEye = -normalize(posW.xyz - CamPos.xyz);
		float specFactor = pow(max(dot(v, toEye), 0.0f), specularPower);
		
		diffuse += diffuseFactor * DirectionalLight2.color * DirectionalLight2.enabled;
		spec += specFactor * specularIntensity * SpecularColor * DirectionalLight2.enabled;
	}
	return (AmbientColor + diffuse) * diffuseColor + spec;
}

PixelShaderInput VS(VertexShaderInput input)
{
	PixelShaderInput output;

	float4 worldPos = mul(float4(input.Position.xyz, 1.0f), World);
	
	output.Position = mul(worldPos, mul(View, Projection));
	output.TexCoords = input.TexCoords;
	
	float3 worldNormal = mul(input.Normal, (float3x3)World);
	output.TTW = CalculateTangentToObject(mul(input.Tangent, (float3x3)World), worldNormal);
	
	output.PosW = worldPos.xyz;	
	
	return output;
}

float4 PS(PixelShaderInput input) : SV_TARGET
{
	uint tileIndex = GetTileIndex(input.PosW);
	
	float3 diffuseTexture = DiffuseMap.Sample(AnisotropicSampler, input.TexCoords).rgb;
	float specular = saturate(NormalMap.Sample(AnisotropicSampler, input.TexCoords).a);
	
	float3 normal = GetNormalFromNormalMap(input.TexCoords, input.TTW, Bumpiness, NormalMap);
	
	float3 final = ApplyLighting(diffuseTexture * DiffuseColor.rgb, normalize(normal), input.PosW, SpecularPower, specular, tileIndex);

	return float4(final.rgb, 1.0f);
}

technique StandardTechnique { 
	VertexShader = VS,
	PixelShader = PS
};

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

#include <ShaderInclude.fx>

cbuffer MaterialBuffer : register(b5) {

float4 DiffuseColor;

float4 SpecularColor;

float SpecularPower;

float Bumpiness;

float ShowTiles;

};

// The diffuse texture map which contains all the color information

Texture2D DiffuseMap : register(t0);

// The normal texture map which contains data for normal manipulation

Texture2D NormalMap : register(t1);

// The normal texture map which contains data for normal manipulation

Texture2D SpecularMap : register(t2);

struct VertexShaderInput {

float3 Position : POSITION;

float3 Normal : NORMAL;

float2 TexCoords : TEXCOORD0;

float3 Tangent : TANGENT;

};

struct PixelShaderInput {

float4 Position : SV_POSITION;

float2 TexCoords : TEXCOORD0;

float3 PosW : TEXCOORD1;

float3x3 TTW : TEXCOORD2; //Tangent To World

};

// Handles all the lighting and applies the influence of the sun light (and its specular light) to the material.

// @diffuseColor: The diffuse color you want to use for the surface

// @normal: The normal in world space, which gets used for the lighting calculation

// @posW: The position of the vertex in world space (used for specular calculation)

// @specularPower: The specularPower indicates how big the specular highlight is, the higher this value the smaller it will get.

// @specularIntensity: Indicates how strong the specularHightlight is

float3 ApplyLighting(float3 diffuseColor, float3 normal, float3 posW, float specularPower, float specularIntensity, uint tileIndex) {

// Debug Render?

if(ShowTiles > 0) {

uint startOffset = pointLightOffsets[tileIndex];

uint endOffset = pointLightOffsets[tileIndex+1];

uint elms = endOffset-startOffset;

float factor = (float)elms/128;

return lerp(float3(0, 0, 1), float3(1, 0, 0), factor) * diffuseColor;

}

float3 diffuse = float3(0, 0, 0);

float3 spec = float3(0, 0, 0);

// Go through all the point lights

FOR_ALL_POINT_LIGHTS(light, tileIndex)

float3 lightVec = light.position - posW;

float d = length(lightVec);

if(d > light.range)

continue;

lightVec /= d;

float diffuseFactor = dot(lightVec, normal);

float att = max(0, pow(1 - d / light.range, light.falloff + 1));

[flatten]

if(diffuseFactor > 0) {

float3 v = reflect(-lightVec, normal);

float3 toEye = -normalize(posW.xyz - CamPos.xyz);

float specFactor = pow(max(dot(v, toEye), 0.0f), specularPower);

diffuse += diffuseFactor * att * light.color;

spec += specFactor * att * specularIntensity * SpecularColor;

}

END_FOR

// Handle directional lights

float3 lightVec = -DirectionalLight1.direction;

float diffuseFactor = dot(lightVec, normal);

[flatten]

if(diffuseFactor > 0) {

float3 v = reflect(-lightVec, normal);

float3 toEye = -normalize(posW.xyz - CamPos.xyz);

float specFactor = pow(max(dot(v, toEye), 0.0f), specularPower);

diffuse += diffuseFactor * DirectionalLight1.color * DirectionalLight1.enabled;

spec += specFactor * specularIntensity * SpecularColor * DirectionalLight1.enabled;

}

lightVec = -DirectionalLight2.direction;

diffuseFactor = dot(lightVec, normal);

[flatten]

if(diffuseFactor > 0) {

float3 v = reflect(-lightVec, normal);

float3 toEye = -normalize(posW.xyz - CamPos.xyz);

float specFactor = pow(max(dot(v, toEye), 0.0f), specularPower);

diffuse += diffuseFactor * DirectionalLight2.color * DirectionalLight2.enabled;

spec += specFactor * specularIntensity * SpecularColor * DirectionalLight2.enabled;

}

return (AmbientColor + diffuse) * diffuseColor + spec;

}

PixelShaderInput VS(VertexShaderInput input)

{

PixelShaderInput output;

float4 worldPos = mul(float4(input.Position.xyz, 1.0f), World);

output.Position = mul(worldPos, mul(View, Projection));

output.TexCoords = input.TexCoords;

float3 worldNormal = mul(input.Normal, (float3x3)World);

output.TTW = CalculateTangentToObject(mul(input.Tangent, (float3x3)World), worldNormal);

output.PosW = worldPos.xyz;

return output;

}

float4 PS(PixelShaderInput input) : SV_TARGET

{

uint tileIndex = GetTileIndex(input.PosW);

float3 diffuseTexture = DiffuseMap.Sample(AnisotropicSampler, input.TexCoords).rgb;

float specular = saturate(NormalMap.Sample(AnisotropicSampler, input.TexCoords).a);

float3 normal = GetNormalFromNormalMap(input.TexCoords, input.TTW, Bumpiness, NormalMap);

float3 final = ApplyLighting(diffuseTexture * DiffuseColor.rgb, normalize(normal), input.PosW, SpecularPower, specular, tileIndex);

return float4(final.rgb, 1.0f);

}

technique StandardTechnique {

VertexShader = VS,

PixelShader = PS

};