Hi guys,

right now I'm having a small issue, the issue might be small, but it's blocking my development , which is about depth mapping:

Screenshot:

As you can see, there are some problems...

The shader(This shader is not optimized in any way as that is not my current goal, depth mapping occurs in this statement: "if (state == 5 || state == 2)" ):

cbuffer ConstantObjectBuffer : register (b0)
{
	matrix worldMatrix;
	matrix viewMatrix;
	matrix projectionMatrix;

	float state;
	float _instance;
	float _alphamap;
	float _diffusealpha;
};

struct VOut
{
	float4 position : SV_POSITION;
	float4 normal : NORMAL;
	float2 texcoord : TEXCOORD;
    float4 depthPosition : TEXTURE0;
};

Texture2D t_alphamap;
Texture2D t_dffalpha;
SamplerState ss;

VOut VShader(float4 position : POSITION, float4 normal : NORMAL, float2 texcoord : TEXCOORD, float3 instancePosition : INSTANCEPOS)
{
	VOut output;

	if (_instance == 1)
	{
		position.x += instancePosition.x;
		position.y += instancePosition.y;
		position.z += instancePosition.z;
	}

	position.w = 1.0f;
	output.texcoord = texcoord;

	// Calculate the position of the vertex against the world, view, and projection matrices.
	output.position = mul(position, worldMatrix);
	output.position = mul(output.position, viewMatrix);
	output.position = mul(output.position, projectionMatrix);

	output.normal = normal;
	output.depthPosition = output.position;

	return output;
}

float4 PShader(VOut input) : SV_TARGET
{
	float4 color = float4(1,1,1,1);

	if (state == 5 || state == 2)
	{
		float depthValue;
		depthValue = input.depthPosition.z / 25.0f;
		color = float4(depthValue, depthValue, depthValue, 1.0f);
	}
	else if (state == 6)
	{
		float3 viewSpaceNormalizedNormals = input.normal; //0.5 * normalize (input.normal) + 0.5
		color = float4(viewSpaceNormalizedNormals, 1);
	}

	if (_alphamap == 1)
	{
		color.a *= t_alphamap.Sample(ss, input.texcoord).a;
	}

	if (_diffusealpha == 1)
	{
		color.a *= t_dffalpha.Sample(ss, input.texcoord).a;
	}

	return color;
}

Now what on earth did I do wrong?

I'm not really sure what your exact problem is or what you're trying to accomplish here. However I can tell you that dividing post-perspective z by 25.0 is not going to give you anything meaningful. Normally you would divide by w in order to get the same [0, 1] depth value that's stored in the depth buffer. However this value isn't typically useful for visualizing, since it's non-linear. Instead you usually want to use your view-space z value (which is the w component of mul(position, projectionMatrix), AKA depthPosition.w) and divide it by your far-clip distance. This gives you a linear [0, 1] value.

Objective: To visualize depth in a texture

___

So instead I should do the following:

depthValue = input.depthPosition.z / (input.depthPosition.w / 1000.0f);

or

depthValue = (input.depthPosition.w / 1000.0f);

Is this correct?

You want the second one: depthPosition.w / 1000.0

Thank you, the depth buffer now works perfectly.

Sorry for bringing in an old topic, about ssao. The depth problem initially lied in SSAO, and I believe that the normals are being outputted correctly as well.

SSAO Extraction shader:

Texture2D t_depthmap : register(t0);
Texture2D t_normalmap : register(t1);
Texture2D t_random : register(t2);
SamplerState ss;

cbuffer SSAOBuffer : register(c0)
{
	float g_scale;
	float g_bias;
	float g_sample_rad;
	float g_intensity;
	float ssaoIterations;
	float3 pppspace;

	matrix view;
};

struct VS_Output
{  
	float4 Pos : SV_POSITION;              
	float2 Tex : TEXCOORD0;
};
 
VS_Output VShader(uint id : SV_VertexID)
{
	VS_Output Output;
	Output.Tex = float2((id << 1) & 2, id & 2);
	Output.Pos = float4(Output.Tex * float2(2,-2) + float2(-1,1), 0, 1);
	return Output;
}

// Helper for modifying the saturation of a color.
float4 AdjustSaturation(float4 color, float saturation)
{
	// The constants 0.3, 0.59, and 0.11 are chosen because the
	// human eye is more sensitive to green light, and less to blue.
	float grey = dot(color, float3(0.3, 0.59, 0.11));

	return lerp(grey, color, saturation);
}

// Ambient Occlusion Stuff --------------------------------------------------

float3 getPosition(in float2 uv)
{
	return mul(t_depthmap.Sample(ss, uv).xyz, view);
}

float3 getNormal(in float2 uv)
{
	return normalize(mul(t_normalmap.Sample(ss, uv).xyz * 2.0f - 1.0f, view));
}

float2 getRandom(in float2 uv)
{
	//return normalize(t_random.Sample(ss, uv ).xy * 2.0f - 1.0f); // ~100FPS
	return normalize(t_random.Sample(ss, float2(600, 800) * uv / float2(60, 60)).xy * 2.0f - 1.0f);
}

float doAmbientOcclusion(in float2 tcoord,in float2 uv, in float3 p, in float3 cnorm)
{
	float3 diff = getPosition(tcoord + uv) - p;
	const float3 v = normalize(diff);
	const float d = length(diff)*g_scale;
	return max(0.0,dot(cnorm,v)-g_bias)*(1.0/(1.0+d))*g_intensity;
}

// End

float4 PShader(VS_Output input) : SV_TARGET
{
	// ADD SSAO ---------------------------------------------------------------
	const float2 vec[4] = {float2(1,0),float2(-1,0),
				float2(0,1),float2(0,-1)};

	float3 p = getPosition(input.Tex);
	float3 n = getNormal(input.Tex);
	float2 rand = getRandom(input.Tex);

	float ao = 0.0f;
	float rad = g_sample_rad/p.z; // g_s_r

	//**SSAO Calculation**//
	int iterations = 4;
	for (int j = 0; j < iterations; ++j)
	{
	  float2 coord1 = reflect(vec[j], rand)*rad;
	  float2 coord2 = float2(coord1.x*0.707 - coord1.y*0.707,
				  coord1.x*0.707 + coord1.y*0.707);
	  
	  ao += doAmbientOcclusion(input.Tex, coord1*0.25, p, n);
	  ao += doAmbientOcclusion(input.Tex, coord2*0.5, p, n);
	  ao += doAmbientOcclusion(input.Tex, coord1*0.75, p, n);
	  ao += doAmbientOcclusion(input.Tex, coord2, p, n);
	}
	ao/=(float)iterations*4.0;

	return ao;
}

The ssao looks as the following:

But on the bottom there is a plane, which is being rendered, but the SSAO seems to be affected by depth somehow, but why? And I have no idea if those values I used are correct, please say if their not.