Hi,

I render each object to G-Buffer after that I should render each light in the scene to the lightbuffer, and the result should be blended so the lightbuffer is a blended combination of all lights in the scene correct.

So how do I blend the lightbuffers renderpass? Is this something that i should program in the shaderworld or in the cpu world? And how would a typical very simple lightbuffer look like should that just be a pixel shader?

Also currently my setup works fine for 1 light (:-P) and it goes something like this.

1) Render all object to the G-Buffer one by one, each object has the G-Buffer as there primary shader

2) Render a Quad with the light buffer as a shader and a light as input. If i would start render 1000 lights I cant render

the Quad 1000 times, so I should just run the "light shader" a 10000s without any geometry somehow and then as a third final step render the a Quad and then apply the blend result from the light shader to that quad, how would I do that?

// Lightbuffer
//--------------------------------------------------------------------------------
Texture2D txDiffuse : register(t0);
Texture2D txNormal : register(t1);
Texture2D txDepth : register(t2);
Texture2D txSpecular : register(t3);
//--------------------------------------------------------------------------------
SamplerState samLinear0 : register( s0 );
SamplerState samLinear1 : register( s1 );
SamplerState samLinear2 : register( s2 );
SamplerState samLinear3 : register( s3 );
//--------------------------------------------------------------------------------
cbuffer cbLight : register(b0)
{
	float4 lightDirection;
	float4 lightColor;
	float4 lightRange;	
}
//--------------------------------------------------------------------------------
struct PS_INPUT
{
  float4 position	 : SV_POSITION;
  float2 texcoord	 : TEXCOORD0;	
	};
//--------------------------------------------------------------------------------
float4 main(PS_INPUT input) : SV_Target
{
	float4 diffuse = txDiffuse.Sample(samLinear0, input.texcoord);
	float4 normal = txNormal.Sample(samLinear1, input.texcoord);
	float4 depth = txDepth.Sample(samLinear2, input.texcoord);
	float4 specular = txDepth.Sample(samLinear3, input.texcoord);
	float irradiance = saturate(dot(normal, -lightDirection));
	return lightColor*irradiance*diffuse;
}

// G-BUFFER
Texture2D txDiffuse : register( t0 );
SamplerState samLinear : register( s0 );

cbuffer cbPerObject : register(b0)
{
	float4 diffuse;
	float4 specular;
	bool isTextured;	
}

//--------------------------------------------------------------------------------------
struct PS_INPUT
{
  float4 position	 : SV_POSITION;
  float2 texcoord	 : TEXCOORD0;	
	float4 normal	: NORMAL;
};
//--------------------------------------------------------------------------------------
struct PSOutput
{
	float4 Color : SV_Target0;
  float4 Normal : SV_Target1;	
	float4 Depth : SV_Target2;
	float4 Specular : SV_Target3;
	
};
//--------------------------------------------------------------------------------------
// Pixel Shader
//--------------------------------------------------------------------------------------
PSOutput main(PS_INPUT input)  
{
	PSOutput output;
	output.Color = diffuse*txDiffuse.Sample(samLinear, input.texcoord);
	output.Normal = normalize(input.normal);
	output.Specular = specular;
	output.Depth =  input.position.z / input.position.w;
	return output;
}

any help is much appreciated.

Hi,

But how do I render x-number of light with a pixelshader without without any geomery and then merge the result from the lightshaders and then display it on a quad.

I found al ot of tutorials and articles that discause the gbuffer but I havent found much on the final merging part?

Will have a look at your link btw thx.

ou render the geometry first with out the lights. Only with color and texture. You THEN take that information you just gathered in the three buffers Color,Depth,and Normals and pass it to your differed lighting shader.

Im already doing that.. My problem is:

Lets say i have 100 lights, as i has understood it i need to excute the lightshader 100 times for each light correct and how do I do this in practice, how do I execute a pixelshader (which the lightshader is) without having any geometry bound to it? I'm a bit lost here. I understand how it should work in principle but not in practice..

Check this tutorial - part 1, part 2 and part 3.

Let's say you are doing basic diffuse lighting. For that you need to know:

- World normal.

- The diffuse color.

Forward renderer will do it like this:

- VS will calculate the normal.

- PS get normal and tex-coord as input.

- PS samples the diffuse texture for the diffuse color.

- output = saturate(dot(normal, lightvec))*diffuse.

In contrast, in deferred shading you will have 2 passes:

Geometry pass:

- VS calculates normal

- PS gets normal

- PS samples for diffuse color

- PS outputs both values to the MRT

Lighting pass:

- Draw full screen quad. VS is pass-through, only output SV_Position and TexC.

Pixel shader psuedo-code:

Normal = GBuffer.Normal.sample(TexC)
Diffuse = GBuffer.diffuse.sample(TexC)

float3 color = 0;
for each light l
{
    color += saturate(dot(Normal, l.direction))*Diffuse;
}

return color;

You don't need to invoke the PS 1000 times. You call it once, and loop over the lights inside the PS.

This is a very basic example, check the tutorials I mentioned above for better explanation.

[EDIT] also consider using a Z pre-pass before the geometry pass (basically initialize the depth buffer without invoking the PS), it will optimize the geometry pass in case your depth complexity is high.

Excellent, thx so much for you help guys!