Jump to content

  • Log In with Google      Sign In   
  • Create Account

DX11 - Depth Mapping - How?


Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

  • You cannot reply to this topic
5 replies to this topic

#1 Migi0027   Crossbones+   -  Reputation: 2116

Like
0Likes
Like

Posted 23 May 2013 - 01:18 PM

Hi guys,

 

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

 

Screenshot:

ejdbog.png

 

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? huh.png


Hi! Cuboid Zone
The Rule: Be polite, be professional, but have a plan to steal all their shaders!

Sponsor:

#2 MJP   Moderators   -  Reputation: 11737

Like
2Likes
Like

Posted 23 May 2013 - 03:16 PM

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.



#3 Migi0027   Crossbones+   -  Reputation: 2116

Like
1Likes
Like

Posted 23 May 2013 - 03:30 PM

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?


Hi! Cuboid Zone
The Rule: Be polite, be professional, but have a plan to steal all their shaders!

#4 hdxpete   Members   -  Reputation: 488

Like
0Likes
Like

Posted 23 May 2013 - 03:42 PM

why not pass the depth of the vertex for the vertex shader in the color to the pixel shader?

 

vertex()

{

   out.color = posttransformvertex.z;

}

 

frag()

{

   return in.color;

}



#5 MJP   Moderators   -  Reputation: 11737

Like
1Likes
Like

Posted 23 May 2013 - 03:51 PM

You want the second one: depthPosition.w / 1000.0



#6 Migi0027   Crossbones+   -  Reputation: 2116

Like
0Likes
Like

Posted 24 May 2013 - 03:23 AM

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:

 

df82o9.png

 

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.


Edited by Migi0027, 24 May 2013 - 04:06 AM.

Hi! Cuboid Zone
The Rule: Be polite, be professional, but have a plan to steal all their shaders!




Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.



PARTNERS