• Advertisement
Sign in to follow this  

DX11 DX11 - Terrain Tessellation repeating

This topic is 1615 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

Hi guys.

 

I've been trying to implement tessellation, and got it implemented, thanks to you.

 

My next goal is to implement terrain tessellation with displacement mapping

 

Questions: (Some I have attempted, shown in the shader code below)

  • The vertices generated on the cpu, do they just represent a plane, or a pre generated grid?
  • How do I decide the height of the displacement mapping, just a constant?
  • How are the normals generated?

My attempt: (If you want to see...)

cbuffer ConstantObjectBuffer : register (b0)
{
	matrix worldMatrix;
};

cbuffer ConstantFrameBuffer : register (b1)
{
	matrix viewMatrix;
	matrix projectionMatrix;

	float3 eyepos;
	float cppad;

	float4 lightvec;
	float4 lightcol;

	float FogStart;
	float FogEnd;
	float2 __space;

	float3 FogColor;
	float shadows;

	float SpecularIntensity;
	float3 pad3;
	float4 SpecularColor;
}


//***************************************************//
//                 VERTEX SHADER                     //
//***************************************************//

struct VOut
{
    float4 position : POSITION;
	float2 texcoord : TEXCOORD;
	float access : ACCESS;

	float tessAmount : TSSAM;
	
	float3 NormalW : NORMWORLD;
	float3 normal : NORM;
	float4 depthPosition : TEXTURE0;
};

struct GlobalIn
{
	float4 position : POSITION;
	float4 normal : NORMAL;
	float2 texcoord : TEXCOORD;
};

Texture2D t_map : register(t0);
SamplerState ss;

VOut VShader(GlobalIn input)
{
    VOut output;

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

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

	output.position = mul(input.position, viewMatrix);

	// Get Tesselation amount
	output.tessAmount = (1.0f / output.position.z) * 6.0f;

	output.position = input.position;

    output.NormalW = mul(float4(input.normal.xyz,0), mul(worldMatrix, viewMatrix));

	// Store the position value in a second input value for depth value calculations.
	output.depthPosition.xyz = mul(float4(input.position.xyz,1), mul(worldMatrix, viewMatrix)).xyz;

	// Per Vertex lighting
	float4 norm = normalize(input.normal);
	output.access = saturate(dot(norm, lightvec));

	output.normal = input.normal;
	
    return output;
}

//***************************************************//
//                 HULL SHADER                       //
//***************************************************//

struct HOutput
{
    float edges[3] : SV_TessFactor;
    float inside : SV_InsideTessFactor;
};

#define tessellationAmount 12.0f

HOutput ColorPatchConstantFunction(InputPatch<VOut, 3> inputPatch, uint patchId : SV_PrimitiveID)
{    
    HOutput output;

	float tA = inputPatch[0].tessAmount;
	tA = 12.0f;

    // Set the tessellation factors for the three edges of the triangle.
    output.edges[0] = tA;
    output.edges[1] = tA;
    output.edges[2] = tA;

    // Set the tessellation factor for tessallating inside the triangle.
    output.inside = tA;

    return output;
}

[domain("tri")]
[partitioning("integer")]
[outputtopology("triangle_cw")]
[outputcontrolpoints(3)]
[patchconstantfunc("ColorPatchConstantFunction")]

VOut HShader(InputPatch<VOut, 3> patch, uint pointId : SV_OutputControlPointID, uint patchId : SV_PrimitiveID)
{
    VOut output;

    // Set the x for this control point as the output x.
    output.position = patch[pointId].position;

    output.texcoord = patch[pointId].texcoord;
    output.access = patch[pointId].access;
    output.NormalW = patch[pointId].NormalW;
    output.normal = patch[pointId].normal;
    output.depthPosition = patch[pointId].depthPosition;

    return output;
}

//***************************************************//
//                 DOMAIN SHADER                     //
//***************************************************//

struct DOut
{
    float4 position : SV_Position;
	float2 texcoord : TEXCOORD;
	float access : ACCESS;
	
	float3 NormalW : NORMWORLD;
	float4 depthPosition : TEXTURE0;
};

[domain("tri")]

DOut DShader(HOutput input, float3 uvwCoord : SV_DomainLocation, const OutputPatch<VOut, 3> patch)
{
    DOut output;

	float3 vertexPosition;
    float2 texCoords;
    float3 normal;
    float4 worldPosition;

	vertexPosition = uvwCoord.x * patch[0].position + uvwCoord.y * patch[1].position + uvwCoord.z * patch[2].position;

    texCoords = uvwCoord.x * patch[0].texcoord + uvwCoord.y * patch[1].texcoord + uvwCoord.z * patch[2].texcoord;

    normal =  uvwCoord.x * float3(0, 1, 0) + uvwCoord.y * float3(0, 1, 0) + uvwCoord.z * float3(0, 1, 0);
    normal = normalize(normal);

    float vHeight = t_map.SampleLevel(ss, texCoords, 0);
    vertexPosition += float3(0, 1, 0) * (vHeight * 2.0f);

    output.position = mul(float4(vertexPosition, 1.0f), worldMatrix);
    output.position = mul(output.position, viewMatrix);
    output.position = mul(output.position, projectionMatrix);

    output.texcoord = texCoords;

    output.NormalW = mul(normal,(float3x3)worldMatrix);
    output.NormalW = normalize(output.NormalW);

    return output;
}

//***************************************************//
//                 PIXEL SHADER                      //
//***************************************************//

struct POut
{
	float4 Diffuse  : SV_Target0;
	float4 Depth    : SV_Target1;
	float4 Normals  : SV_Target2;
	float4 Lighting : SV_Target3;
};

POut PShader(VOut input)
{
	POut output;

	// Depth
	output.Depth = float4(input.depthPosition.xyz, 1.0f);

	// Normals
	output.Normals = float4(normalize(input.NormalW), 1);

	output.Diffuse = float4(1, 1, 1, 1);
	output.Lighting = float4(lightcol.rgb * input.access, 1.0f);

	output.Lighting = float4(1, 1, 1, 1);

	return output;
}

I've attempted with the pre generated grid, but this came: (The terrain is repeated over and over again, why?)

 

kcxu6f.png

 

Thank you, as always GameDev.

Edited by Migi0027

Share this post


Link to post
Share on other sites
Advertisement

Seems no one replied, so I'll try my best.

 

 

The vertices generated on the cpu, do they just represent a plane, or a pre generated grid?

Generate quad on CPU, tesellator stage will create extra triangles, which will result in your terrain.

 

 

How do I decide the height of the displacement mapping, just a constant?

If you're using UNORM or NORM texture, then you need to decide on min/max height. For example 1.0f in texture could mean 255.0f in world space.

If you're using FLOAT texture then just store height directly in the texture.

 

 

How are the normals generated?

It should be possible to calculate them based on data in displacement map, however I haven't done this, so I am unable to help more than this.

 

 

The terrain is repeated over and over again, why?

All your meshes have UV 0.0f to 1.0f, so every terrain ended up reading same texture coordinates.

You need to do do several Draw() calls and use different displacement map for each of them.

Share this post


Link to post
Share on other sites

Seems no one replied, so I'll try my best.

 

 

The vertices generated on the cpu, do they just represent a plane, or a pre generated grid?

Generate quad on CPU, tesellator stage will create extra triangles, which will result in your terrain.

 

 

How do I decide the height of the displacement mapping, just a constant?

If you're using UNORM or NORM texture, then you need to decide on min/max height. For example 1.0f in texture could mean 255.0f in world space.

If you're using FLOAT texture then just store height directly in the texture.

 

 

How are the normals generated?

It should be possible to calculate them based on data in displacement map, however I haven't done this, so I am unable to help more than this.

 

 

The terrain is repeated over and over again, why?

All your meshes have UV 0.0f to 1.0f, so every terrain ended up reading same texture coordinates.

You need to do do several Draw() calls and use different displacement map for each of them.

This is most likely the issue.  However, you don't need separate draw calls if you just want to stretch that single displacement map across all of your tiles.  Then you would just use 1.0 / gridsX and 1.0 / gridsY sized pieces for each grid.  Does that make sense?

Share this post


Link to post
Share on other sites

Well, a bit closer.

 

Right now I send a quad to the gpu, and then tessellate/displace it from there, but another problem comes, it looks like only half on the quad is being rendered:

 

ao13cm.png

 

The shader practically hasn't changed, only the buffer creation:

Plane_VI plane;

// create the vertex buffer
D3D11_BUFFER_DESC bd;
ZeroMemory(&bd, sizeof(bd));

bd.Usage = D3D11_USAGE_DYNAMIC;
bd.ByteWidth = sizeof(MESH_STRUCT::Dummy) * 4;
bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
	
dev->CreateBuffer(&bd, NULL, &m_vertexBuffer);

D3D11_MAPPED_SUBRESOURCE ms;
// copy the vertices into the buffer
devcon->Map(m_vertexBuffer, NULL, D3D11_MAP_WRITE_DISCARD, NULL, &ms);    // map the buffer
memcpy(ms.pData, plane.Vertices, sizeof( plane.Vertices	));                 // copy the data
devcon->Unmap(m_vertexBuffer, NULL);

// create the index buffer
bd.Usage = D3D11_USAGE_DYNAMIC;
bd.ByteWidth = sizeof(DWORD) * 6;
bd.BindFlags = D3D11_BIND_INDEX_BUFFER;
bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
bd.MiscFlags = 0;

dev->CreateBuffer(&bd, NULL, &m_indexBuffer);

devcon->Map(m_indexBuffer, NULL, D3D11_MAP_WRITE_DISCARD, NULL, &ms);    // map the buffer
memcpy(ms.pData, plane.Indices, sizeof(plane.Indices));                   // copy the data
devcon->Unmap(m_indexBuffer, NULL);

IndexCount = 6;
m_indexCount = 6;
m_vertexCount = 4;

Definition of Plane_VI:

----HEADER-----
class BASEAPI Plane_VI
{
public:MESH_STRUCT Vertices[4];
public:DWORD Indices[6];

public:
	Plane_VI();
};

----SOURCE-----
Plane_VI::Plane_VI()
{
	Vertices[0] = MESH_STRUCT(-1.0f, 0.0f, -1.0f, D3DXVECTOR3(0.0f, 1.0f, 0.0f), 0.0f, 1.0f, 0, 0, 0);
	Vertices[1] = MESH_STRUCT(1.0f, 0.0f, -1.0f, D3DXVECTOR3(0.0f, 1.0f, 0.0f), 1.0f, 1.0f, 0, 0, 0);
	Vertices[2] = MESH_STRUCT(-1.0f, 0.0f, 1.0f, D3DXVECTOR3(0.0f, 1.0f, 0.0f), 0.0f, 0.0f, 0, 0, 0);
	Vertices[3] = MESH_STRUCT(1.0f, 0.0f, 1.0f, D3DXVECTOR3(0.0f, 1.0f, 0.0f), 1.0f, 0.0f, 0, 0, 0);

	Indices[0] = 3;
	Indices[1] = 1;
	Indices[2] = 2;
	Indices[3] = 2;
	Indices[4] = 1;
	Indices[5] = 0;
};

The primitive topology I'm using (Could this be part of the problem?):

devcon->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST); // devcon -> Device Context

Now what have I done wrong? happy.png  

Share this post


Link to post
Share on other sites
I already suggested a pass-through geometry shader for inspecting values in PIX. If you can't use PIX or something, visualizing manually helps as an alternative. Currently I suspect something wrong with the tex-coords. Pass them along and output them in the pixel-shader as colors ([tt]return float4(texcoord.xy, 0, 1);[/tt]). You should see some red-green-yellow color gradient.

Or bind the displacement map to your pixel shader instead and sample (and output) there, to see if the sampling is the culprit (solid instead of wireframe and without displacement).

Also, show your domain shader.

Share this post


Link to post
Share on other sites

PS. The domain shader is at the top of this page, in the shader file smile.png

 

Though I am going to do as suggested, I'm pretty sure that the UV's are fine, as I've used them before, but I might be wrong.

 

Something I forgot to add:

class BASEAPI MESH_STRUCT {
public: 
	FLOAT X, Y, Z; D3DXVECTOR3 Normal; FLOAT U, V; FLOAT tx; FLOAT ty; FLOAT tz; float accessability; D3DXVECTOR4 bWeight; // XYZ:Position, UV: Texture, txtytz: Tangent
//... Not nessesary
};

This should tell you the UV coords.

Share this post


Link to post
Share on other sites

Hmmm, tangents, accessability and weights ? Don't see them in your vertex shader input at all. Also: make sure your input layout is ok.

Share this post


Link to post
Share on other sites

About that, some of the are used, some are not, but the input layout is correct, and in the correct order, but if you want to see:

 

D3D11_INPUT_ELEMENT_DESC ied[] =
{
{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0},
{"NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0},
{"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0},
};

if (dev->CreateInputLayout(ied, 3, VS->GetBufferPointer(), VS->GetBufferSize(), &pLayout) != S_OK)
...

Share this post


Link to post
Share on other sites
Yeah, looks fine (though I for one wouldn't use a float4 for the normal in the shader). I assume the stride when binding the buffer is ok, too.

Try the other approaches.

You wouldn't mind posting that displacement texture, please ?

Share this post


Link to post
Share on other sites

Well, that white grid was confusing from the start. There should be no white at all, so I assume this is a different draw call (and shader). I don't see that grid in PIX either.

 

For the tesselated one: I miss the red color. And the displacement should go in one direction only (normal is always the same). How does the PreVS tab look ?

Share this post


Link to post
Share on other sites

Looks fine.

 

Hmmm, if I try to compile that shader using an effect I get A LOT of warnings about missing output values. The compilation even fails since there are these inconsistencies between shader stages (e.g. your domain shader outputs DOut, your pixelshader wants VOut).

 

I'm surprised that something gets drawn at all. Don't you get any warnings from the debug layer ?

 

Anyway, remove those compiler warnings and make sure the input-output signatures match.

Share this post


Link to post
Share on other sites

What warnings do you get when you compile it?

 

I think the signatures are better now:

cbuffer ConstantObjectBuffer : register (b0)
{
	matrix worldMatrix;
};

cbuffer ConstantFrameBuffer : register (b1)
{
	matrix viewMatrix;
	matrix projectionMatrix;

	float3 eyepos;
	float cppad;

	float4 lightvec;
	float4 lightcol;

	float FogStart;
	float FogEnd;
	float2 __space;

	float3 FogColor;
	float shadows;

	float SpecularIntensity;
	float3 pad3;
	float4 SpecularColor;
}


//***************************************************//
//                 VERTEX SHADER                     //
//***************************************************//

struct VOut
{
    float4 position : POSITION;
	float2 texcoord : TEXCOORD;
	float access : ACCESS;

	float tessAmount : TSSAM;
	
	float3 NormalW : NORMWORLD;
	float3 normal : NORM;
	float4 depthPosition : TEXTURE0;
};

struct GlobalIn
{
	float4 position : POSITION;
	float4 normal : NORMAL;
	float2 texcoord : TEXCOORD;
};

Texture2D t_map : register(t0);
SamplerState ss;

VOut VShader(GlobalIn input)
{
    VOut output;

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

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

	output.position = mul(input.position, viewMatrix);

	// Get Tesselation amount
	output.tessAmount = (1.0f / output.position.z) * 6.0f;

	output.position = input.position;

    output.NormalW = mul(float4(input.normal.xyz,0), mul(worldMatrix, viewMatrix));

	// Store the position value in a second input value for depth value calculations.
	output.depthPosition.xyz = mul(float4(input.position.xyz,1), mul(worldMatrix, viewMatrix)).xyz;

	// Per Vertex lighting
	float4 norm = normalize(input.normal);
	output.access = saturate(dot(norm, lightvec));

	output.normal = input.normal;
	
    return output;
}

//***************************************************//
//                 HULL SHADER                       //
//***************************************************//

struct HOutput
{
    float edges[3] : SV_TessFactor;
    float inside : SV_InsideTessFactor;
};

HOutput ColorPatchConstantFunction(InputPatch<VOut, 3> inputPatch, uint patchId : SV_PrimitiveID)
{    
    HOutput output;

	float tA = inputPatch[0].tessAmount;
	tA = 36.0f;

    // Set the tessellation factors for the three edges of the triangle.
    output.edges[0] = tA;
    output.edges[1] = tA;
    output.edges[2] = tA;

    // Set the tessellation factor for tessallating inside the triangle.
    output.inside = tA;

    return output;
}

[domain("tri")]
[partitioning("integer")]
[outputtopology("triangle_cw")]
[outputcontrolpoints(3)]
[patchconstantfunc("ColorPatchConstantFunction")]

VOut HShader(InputPatch<VOut, 3> patch, uint pointId : SV_OutputControlPointID, uint patchId : SV_PrimitiveID)
{
    VOut output;

    // Set the x for this control point as the output x.
    output.position = patch[pointId].position;

    output.texcoord = patch[pointId].texcoord;
    output.access = patch[pointId].access;
    output.NormalW = patch[pointId].NormalW;
    output.normal = patch[pointId].normal;
    output.depthPosition = patch[pointId].depthPosition;

    return output;
}

//***************************************************//
//                 DOMAIN SHADER                     //
//***************************************************//

struct DOut
{
    float4 position : SV_Position;
	float2 texcoord : TEXCOORD;
	float access : ACCESS;
	
	float3 NormalW : NORMWORLD;
	float4 depthPosition : TEXTURE0;
};

[domain("tri")]

DOut DShader(HOutput input, float3 uvwCoord : SV_DomainLocation, const OutputPatch<VOut, 3> patch)
{
    DOut output;

	float3 vertexPosition;
    float2 texCoords;
    float3 normal;
    float4 worldPosition;

	vertexPosition = uvwCoord.x * patch[0].position + uvwCoord.y * patch[1].position + uvwCoord.z * patch[2].position;

    texCoords = uvwCoord.x * patch[0].texcoord + uvwCoord.y * patch[1].texcoord + uvwCoord.z * patch[2].texcoord;

    normal =  uvwCoord.x * float3(0, 1, 0) + uvwCoord.y * float3(0, 1, 0) + uvwCoord.z * float3(0, 1, 0);
    normal = normalize(normal);

    float vHeight = t_map.SampleLevel(ss, texCoords, 0);
    vertexPosition += float3(0, 1, 0) * (vHeight * 2.0f);

    output.position = mul(float4(vertexPosition, 1.0f), worldMatrix);
    output.position = mul(output.position, viewMatrix);
    output.position = mul(output.position, projectionMatrix);

    output.texcoord = texCoords;

    output.NormalW = mul(normal,(float3x3)worldMatrix);
    output.NormalW = normalize(output.NormalW);

    return output;
}

//***************************************************//
//                 PIXEL SHADER                      //
//***************************************************//

[maxvertexcount(3)]   // produce a maximum of 3 output vertices
void GShader( triangle DOut input[3], inout TriangleStream<DOut> triStream )
{
  DOut psInput;
  
  for( uint i = 0; i < 3; i++ )
  {
    psInput.position = input[i].position;
    psInput.texcoord = input[i].texcoord;
    psInput.access = input[i].access;
    psInput.NormalW = input[i].NormalW;
    psInput.depthPosition = input[i].depthPosition;

    triStream.Append(psInput);
  }

  triStream.RestartStrip();
}

//***************************************************//
//                 PIXEL SHADER                      //
//***************************************************//

struct POut
{
	float4 Diffuse  : SV_Target0;
	float4 Depth    : SV_Target1;
	float4 Normals  : SV_Target2;
	float4 Lighting : SV_Target3;
};

POut PShader(DOut input)
{
	POut output;

	// Depth
	output.Depth = float4(input.depthPosition.xyz, 1.0f);

	// Normals
	output.Normals = float4(normalize(input.NormalW), 1);

	output.Diffuse = float4(t_map.Sample(ss, input.texcoord).rgb, 1);
	output.Lighting = float4(lightcol.rgb * input.access, 1.0f);

	output.Lighting = float4(1, 1, 1, 1);

	return output;
}

The only warning I get are the: implicit truncation of vector type

Share this post


Link to post
Share on other sites

Whoops, enabled debug creation flag, got various errors, fixed them all but one:

D3D11: ERROR: ID3D11DeviceContext::DrawIndexed: Vertex Shader - Hull Shader linkage error: Stages are incompatible with each other. Semantic 'TEXTURE' is always read by the downstream shader, but never written by the upstream shader (even though the semantic is present in its output signature). [ EXECUTION ERROR #347: DEVICE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS ]

Shader:

cbuffer ConstantObjectBuffer : register (b0)
{
	matrix worldMatrix;
};

cbuffer ConstantFrameBuffer : register (b1)
{
	matrix viewMatrix;
	matrix projectionMatrix;

	float3 eyepos;
	float cppad;

	float4 lightvec;
	float4 lightcol;

	float FogStart;
	float FogEnd;
	float2 __space;

	float3 FogColor;
	float shadows;

	float SpecularIntensity;
	float3 pad3;
	float4 SpecularColor;
}


//***************************************************//
//                 VERTEX SHADER                     //
//***************************************************//

struct VOut
{
    float4 position : POSITION;
	float2 texcoord : TEXCOORD;
	float access : ACCESS;

	float tessAmount : TSSAM;
	
	float3 NormalW : NORMWORLD;
	float3 normal : NORM;
	float4 depthPosition : TEXTURE0;
};

struct GlobalIn
{
	float4 position : POSITION;
	float4 normal : NORMAL;
	float2 texcoord : TEXCOORD;
};

Texture2D t_map : register(t0);
SamplerState ss;

VOut VShader(GlobalIn input)
{
    VOut output;

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

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

	output.position = mul(input.position, viewMatrix);

	// Get Tesselation amount
	output.tessAmount = (1.0f / output.position.z) * 6.0f;

	output.position = input.position;

    output.NormalW = mul(float4(input.normal.xyz,0), mul(worldMatrix, viewMatrix));

	// Store the position value in a second input value for depth value calculations.
	output.depthPosition.xyz = mul(float4(input.position.xyz,1), mul(worldMatrix, viewMatrix)).xyz;

	// Per Vertex lighting
	float4 norm = normalize(input.normal);
	output.access = saturate(dot(norm, lightvec));

	output.normal = input.normal;
	
    return output;
}

//***************************************************//
//                 HULL SHADER                       //
//***************************************************//

struct HOutput
{
    float edges[3] : SV_TessFactor;
    float inside : SV_InsideTessFactor;
};

HOutput ColorPatchConstantFunction(InputPatch<VOut, 3> inputPatch, uint patchId : SV_PrimitiveID)
{    
    HOutput output;

	float tA = inputPatch[0].tessAmount;
	tA = 36.0f;

    // Set the tessellation factors for the three edges of the triangle.
    output.edges[0] = tA;
    output.edges[1] = tA;
    output.edges[2] = tA;

    // Set the tessellation factor for tessallating inside the triangle.
    output.inside = tA;

    return output;
}

[domain("tri")]
[partitioning("integer")]
[outputtopology("triangle_cw")]
[outputcontrolpoints(3)]
[patchconstantfunc("ColorPatchConstantFunction")]

VOut HShader(InputPatch<VOut, 3> patch, uint pointId : SV_OutputControlPointID, uint patchId : SV_PrimitiveID)
{
    VOut output;

    // Set the x for this control point as the output x.
    output.position =      patch[pointId].position;
    output.texcoord =      patch[pointId].texcoord;
    output.depthPosition = patch[pointId].depthPosition;
    output.access =        patch[pointId].access;
    output.tessAmount =    patch[pointId].tessAmount;
    output.NormalW =       patch[pointId].NormalW;
    output.normal =        patch[pointId].normal;

    return output;
}

//***************************************************//
//                 DOMAIN SHADER                     //
//***************************************************//

struct DOut
{
    float4 position : SV_Position;
	float2 texcoord : TEXCOORD;
	float access : ACCESS;

	float tessAmount : TSSAM;
	
	float3 NormalW : NORMWORLD;
	float4 depthPosition : TEXTURE0;
};

[domain("tri")]

DOut DShader(HOutput input, float3 uvwCoord : SV_DomainLocation, const OutputPatch<VOut, 3> patch)
{
    DOut output;

	float3 vertexPosition;
    float2 texCoords;
    float3 normal;
    float4 worldPosition;

	output.access = patch[0].access;
	output.texcoord = patch[0].texcoord;
	output.depthPosition = patch[0].depthPosition;

	vertexPosition = uvwCoord.x * patch[0].position + uvwCoord.y * patch[1].position + uvwCoord.z * patch[2].position;

    texCoords = uvwCoord.x * patch[0].texcoord + uvwCoord.y * patch[1].texcoord + uvwCoord.z * patch[2].texcoord;

    normal =  uvwCoord.x * float3(0, 1, 0) + uvwCoord.y * float3(0, 1, 0) + uvwCoord.z * float3(0, 1, 0);
    normal = normalize(normal);

    float vHeight = t_map.SampleLevel(ss, texCoords, 0);
    vertexPosition += float3(0, 1, 0) * (vHeight * 2.0f);

    output.position = mul(float4(vertexPosition, 1.0f), worldMatrix);
    output.position = mul(output.position, viewMatrix);
    output.position = mul(output.position, projectionMatrix);

    output.texcoord = texCoords;

    output.NormalW = mul(normal,(float3x3)worldMatrix);
    output.NormalW = normalize(output.NormalW);

	output.tessAmount = patch[0].tessAmount;

    return output;
}

//***************************************************//
//                 PIXEL SHADER                      //
//***************************************************//

[maxvertexcount(3)]   // produce a maximum of 3 output vertices
void GShader( triangle DOut input[3], inout TriangleStream<DOut> triStream )
{
  DOut psInput;
  
  for( uint i = 0; i < 3; i++ )
  {
    psInput.position = input[i].position;
    psInput.texcoord = input[i].texcoord;
    psInput.access = input[i].access;
    psInput.access = input[i].access;
    psInput.NormalW = input[i].NormalW;
    psInput.depthPosition = input[i].depthPosition;
    psInput.tessAmount = input[i].tessAmount;

    triStream.Append(psInput);
  }

  triStream.RestartStrip();
}

//***************************************************//
//                 PIXEL SHADER                      //
//***************************************************//

struct POut
{
	float4 Diffuse  : SV_Target0;
	float4 Depth    : SV_Target1;
	float4 Normals  : SV_Target2;
	float4 Lighting : SV_Target3;
};

POut PShader(DOut input)
{
	POut output;

	// Depth
	output.Depth = float4(input.depthPosition.xyz, 1.0f);

	// Normals
	output.Normals = float4(normalize(input.NormalW), 1);

	output.Diffuse = float4(t_map.Sample(ss, input.texcoord).rgb, 1);
	output.Lighting = float4(lightcol.rgb * input.access, 1.0f);

	output.Lighting = float4(1, 1, 1, 1);

	return output;
}

Which I can't seem to solve :(

Share this post


Link to post
Share on other sites
You should get warnings (apart from the truncation) even if you compile the shaders in isolation, at least I do:
 
[tt]migi.fx(52,6): warning X3578: Output value 'VShader' is not completely initialized[/tt]
 
The linkage error also tells you which one is the culprit (semantic [tt]TEXTURE[/tt]), i.e. VOut.depthPosition (you don't write to w, only to xyz).
 
I think you should find the other ones, since your shader actually works when corrected wink.png
 
5d9b57269064730.jpg

(I used a different scale and higher tesselation, though)

Cheers. Edited by unbird

Share this post


Link to post
Share on other sites

The shader, if I forgot something:

cbuffer ConstantObjectBuffer : register (b0)
{
	matrix worldMatrix;
};

cbuffer ConstantFrameBuffer : register (b1)
{
	matrix viewMatrix;
	matrix projectionMatrix;

	float3 eyepos;
	float cppad;

	float4 lightvec;
	float4 lightcol;

	float FogStart;
	float FogEnd;
	float2 __space;

	float3 FogColor;
	float shadows;

	float SpecularIntensity;
	float3 pad3;
	float4 SpecularColor;
}


//***************************************************//
//                 VERTEX SHADER                     //
//***************************************************//

struct VOut
{
    float4 position : POSITION;
	float2 texcoord : TEXCOORD;
	float access : ACCESS;

	float tessAmount : TSSAM;
	
	float3 NormalW : NORMWORLD;
	float3 normal : NORM;
	float4 depthPosition : TEXTURE0;
};

struct GlobalIn
{
	float4 position : POSITION;
	float4 normal : NORMAL;
	float2 texcoord : TEXCOORD;
};

Texture2D t_map : register(t0);
SamplerState ss;

VOut VShader(GlobalIn input)
{
    VOut output;

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

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

	output.position = mul(input.position, viewMatrix);

	// Get Tesselation amount
	output.tessAmount = (1.0f / output.position.z) * 6.0f;

	output.position = input.position;

    output.NormalW = mul(float4(input.normal.xyz,0), mul(worldMatrix, viewMatrix));

	// Store the position value in a second input value for depth value calculations.
	output.depthPosition.xyz = mul(float4(input.position.xyz,1), mul(worldMatrix, viewMatrix)).xyz;
	output.depthPosition.w = 1.0f;

	// Per Vertex lighting
	float4 norm = normalize(input.normal);
	output.access = saturate(dot(norm, lightvec));

	output.normal = input.normal;
	
    return output;
}

//***************************************************//
//                 HULL SHADER                       //
//***************************************************//

struct HOutput
{
    float edges[3] : SV_TessFactor;
    float inside : SV_InsideTessFactor;
};

HOutput ColorPatchConstantFunction(InputPatch<VOut, 3> inputPatch, uint patchId : SV_PrimitiveID)
{    
    HOutput output;

	float tA = inputPatch[0].tessAmount;
	tA = 36.0f;

    // Set the tessellation factors for the three edges of the triangle.
    output.edges[0] = tA;
    output.edges[1] = tA;
    output.edges[2] = tA;

    // Set the tessellation factor for tessallating inside the triangle.
    output.inside = tA;

    return output;
}

[domain("tri")]
[partitioning("integer")]
[outputtopology("triangle_cw")]
[outputcontrolpoints(3)]
[patchconstantfunc("ColorPatchConstantFunction")]

VOut HShader(InputPatch<VOut, 3> patch, uint pointId : SV_OutputControlPointID, uint patchId : SV_PrimitiveID)
{
    VOut output;

    // Set the x for this control point as the output x.
    output.position =      patch[pointId].position;
    output.texcoord =      patch[pointId].texcoord;
    output.depthPosition = patch[pointId].depthPosition;
    output.access =        patch[pointId].access;
    output.tessAmount =    patch[pointId].tessAmount;
    output.NormalW =       patch[pointId].NormalW;
    output.normal =        patch[pointId].normal;

    return output;
}

//***************************************************//
//                 DOMAIN SHADER                     //
//***************************************************//

struct DOut
{
    float4 position : SV_Position;
	float2 texcoord : TEXCOORD;
	float access : ACCESS;

	float tessAmount : TSSAM;
	
	float3 NormalW : NORMWORLD;
	float4 depthPosition : TEXTURE0;
};

[domain("tri")]

DOut DShader(HOutput input, float3 uvwCoord : SV_DomainLocation, const OutputPatch<VOut, 3> patch)
{
    DOut output;

	float3 vertexPosition;
    float2 texCoords;
    float3 normal;
    float4 worldPosition;

	output.access = patch[0].access;
	output.texcoord = patch[0].texcoord;
	output.depthPosition = patch[0].depthPosition;

	vertexPosition = uvwCoord.x * patch[0].position + uvwCoord.y * patch[1].position + uvwCoord.z * patch[2].position;

    texCoords = uvwCoord.x * patch[0].texcoord + uvwCoord.y * patch[1].texcoord + uvwCoord.z * patch[2].texcoord;

    normal =  uvwCoord.x * float3(0, 1, 0) + uvwCoord.y * float3(0, 1, 0) + uvwCoord.z * float3(0, 1, 0);
    normal = normalize(normal);

    float vHeight = t_map.SampleLevel(ss, texCoords, 0);
    vertexPosition += float3(0, 1, 0) * (vHeight * 2.0f);

    output.position = mul(float4(vertexPosition, 1.0f), worldMatrix);
    output.position = mul(output.position, viewMatrix);
    output.position = mul(output.position, projectionMatrix);

    output.texcoord = texCoords;

    output.NormalW = mul(normal,(float3x3)worldMatrix);
    output.NormalW = normalize(output.NormalW);

	output.tessAmount = patch[0].tessAmount;

    return output;
}

//***************************************************//
//                 PIXEL SHADER                      //
//***************************************************//

[maxvertexcount(3)]   // produce a maximum of 3 output vertices
void GShader( triangle DOut input[3], inout TriangleStream<DOut> triStream )
{
  DOut psInput;
  
  for( uint i = 0; i < 3; i++ )
  {
    psInput.position = input[i].position;
    psInput.texcoord = input[i].texcoord;
    psInput.access = input[i].access;
    psInput.access = input[i].access;
    psInput.NormalW = input[i].NormalW;
    psInput.depthPosition = input[i].depthPosition;
    psInput.tessAmount = input[i].tessAmount;

    triStream.Append(psInput);
  }

  triStream.RestartStrip();
}

//***************************************************//
//                 PIXEL SHADER                      //
//***************************************************//

struct POut
{
	float4 Diffuse  : SV_Target0;
	float4 Depth    : SV_Target1;
	float4 Normals  : SV_Target2;
	float4 Lighting : SV_Target3;
};

POut PShader(DOut input)
{
	POut output;

	// Depth
	output.Depth = float4(input.depthPosition.xyz, 1.0f);

	// Normals
	output.Normals = float4(normalize(input.NormalW), 1);

	output.Diffuse = float4(t_map.Sample(ss, input.texcoord).rgb, 1);
	output.Lighting = float4(lightcol.rgb * input.access, 1.0f);

	output.Lighting = float4(1, 1, 1, 1);

	return output;
}

Share this post


Link to post
Share on other sites

While testing the terrain shader after a while, the normals aren't being calculated normally, and I don't see why they shouldn't.

 

Or maybe I'm just stupid... Yeah it has to be that...

 

Terrain Shader:

cbuffer ConstantObjectBuffer : register (b0)
{
	matrix worldMatrix;
};

cbuffer ConstantFrameBuffer : register (b1)
{
	matrix viewMatrix;
	matrix projectionMatrix;

	float3 eyepos;
	float cppad;

	float4 lightvec;
	float4 lightcol;

	float FogStart;
	float FogEnd;
	float2 __space;

	float3 FogColor;
	float shadows;

	float SpecularIntensity;
	float3 pad3;
	float4 SpecularColor;
}


//***************************************************//
//                 VERTEX SHADER                     //
//***************************************************//

struct VOut
{
    float4 position : POSITION;
	float2 texcoord : TEXCOORD;
	float access : ACCESS;

	float tessAmount : TSSAM;
	
	float3 NormalW : NORMWORLD;
	float3 normal : NORM;
	float4 depthPosition : TEXTURE0;
};

struct GlobalIn
{
	float4 position : POSITION;
	float4 normal : NORMAL;
	float2 texcoord : TEXCOORD;
};

Texture2D t_map : register(t0);
Texture2D t_slope_flat  : register(t1);
Texture2D t_slope_slope : register(t2);
Texture2D t_slope_steep : register(t3);
SamplerState ss;

VOut VShader(GlobalIn input)
{
    VOut output;

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

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

	output.position = mul(input.position, viewMatrix);

	// Get Tesselation amount
	output.tessAmount = (1.0f/length(output.position + eyepos)) * 512 + 16.0f;

	output.position = input.position;

    output.NormalW = mul(float4(input.normal.xyz,0), mul(worldMatrix, viewMatrix));

	// Store the position value in a second input value for depth value calculations.
	output.depthPosition.xyz = mul(float4(input.position.xyz,1), mul(worldMatrix, viewMatrix)).xyz;
	output.depthPosition.w = 1.0f;

	// Per Vertex lighting
	float4 norm = normalize(input.normal);
	output.access = saturate(dot(norm, lightvec));

	output.normal = input.normal;
	
    return output;
}

//***************************************************//
//                 HULL SHADER                       //
//***************************************************//

struct HOutput
{
    float edges[3] : SV_TessFactor;
    float inside : SV_InsideTessFactor;
};

HOutput ColorPatchConstantFunction(InputPatch<VOut, 3> inputPatch, uint patchId : SV_PrimitiveID)
{    
    HOutput output;

	float tA = inputPatch[0].tessAmount;
	//tA = 36.0f;

    // Set the tessellation factors for the three edges of the triangle.
    output.edges[0] = tA;
    output.edges[1] = tA;
    output.edges[2] = tA;

    // Set the tessellation factor for tessallating inside the triangle.
    output.inside = tA;

    return output;
}

[domain("tri")]
[partitioning("integer")]
[outputtopology("triangle_cw")]
[outputcontrolpoints(3)]
[patchconstantfunc("ColorPatchConstantFunction")]

VOut HShader(InputPatch<VOut, 3> patch, uint pointId : SV_OutputControlPointID, uint patchId : SV_PrimitiveID)
{
    VOut output;

    // Set the x for this control point as the output x.
    output.position =      patch[pointId].position;
    output.texcoord =      patch[pointId].texcoord;
    output.depthPosition = patch[pointId].depthPosition;
    output.access =        patch[pointId].access;
    output.tessAmount =    patch[pointId].tessAmount;
    output.NormalW =       patch[pointId].NormalW;
    output.normal =        patch[pointId].normal;

    return output;
}

//***************************************************//
//                 DOMAIN SHADER                     //
//***************************************************//

struct DOut
{
    float4 position : SV_Position;
	float2 texcoord : TEXCOORD;
	float access : ACCESS;

	float tessAmount : TSSAM;
	
	float3 NormalW : NORMWORLD;
	float4 depthPosition : TEXTURE0;
};

[domain("tri")]

DOut DShader(HOutput input, float3 uvwCoord : SV_DomainLocation, const OutputPatch<VOut, 3> patch)
{
    DOut output;

	float3 vertexPosition;
    float2 texCoords;
    float3 normal;
    float4 worldPosition;

	output.texcoord = patch[0].texcoord;
	output.depthPosition = patch[0].depthPosition;

	vertexPosition = uvwCoord.x * patch[0].position + uvwCoord.y * patch[1].position + uvwCoord.z * patch[2].position;

    texCoords = uvwCoord.x * patch[0].texcoord + uvwCoord.y * patch[1].texcoord + uvwCoord.z * patch[2].texcoord;

    normal =  uvwCoord.x * patch[0].normal + uvwCoord.y * patch[1].normal + uvwCoord.z * patch[2].normal;
    normal = normalize(normal);

    float vHeight = t_map.SampleLevel(ss, texCoords, 0);
    vertexPosition += normal * (vHeight * 25.0f);

    output.position = mul(float4(vertexPosition, 1.0f), worldMatrix);
    output.position = mul(output.position, viewMatrix);
    output.position = mul(output.position, projectionMatrix);

    output.texcoord = texCoords;

    output.NormalW = normal;//mul(normal ,(float3x3)worldMatrix);
    output.NormalW = normalize(output.NormalW);

	output.NormalW = normal;

	output.tessAmount = patch[0].tessAmount;
	
	output.access = dot(output.NormalW, lightvec);

    return output;
}

//***************************************************//
//                 GEOMETRY SHADER                   //
//***************************************************//

[maxvertexcount(3)]   // produce a maximum of 3 output vertices
void GShader( triangle DOut input[3], inout TriangleStream<DOut> triStream )
{
  DOut psInput;
  
  for( uint i = 0; i < 3; i++ )
  {
    psInput.position = input[i].position;
    psInput.texcoord = input[i].texcoord;
    psInput.access = input[i].access;
    psInput.access = input[i].access;
    psInput.NormalW = input[i].NormalW;
    psInput.depthPosition = input[i].depthPosition;
    psInput.tessAmount = input[i].tessAmount;

    triStream.Append(psInput);
  }

  triStream.RestartStrip();
}

//***************************************************//
//                 PIXEL SHADER                      //
//***************************************************//

struct POut
{
	float4 Diffuse  : SV_Target0;
	float4 Position : SV_Target1;
	float4 Depth    : SV_Target2;
	float4 Normals  : SV_Target3;
	float4 Lighting : SV_Target4;
};

POut PShader(DOut input)
{
	POut output;

	// Depth
	output.Depth = float4(input.depthPosition.xyz, 1.0f);

	// Normals
	output.Normals = float4(normalize(input.NormalW), 1);

	output.Position = float4(1, 1, 1, 1);

	float li = saturate(dot(input.NormalW, -lightvec));

	output.Diffuse = float4(input.NormalW, 1);

	/*
	// Sample the grass color from the texture using the sampler at this texture coordinate location.
    grassColor = grassTexture.Sample(SampleType, input.tex);

    // Sample the slope color from the texture using the sampler at this texture coordinate location.
    slopeColor = slopeTexture.Sample(SampleType, input.tex);

    // Sample the rock color from the texture using the sampler at this texture coordinate location.
    rockColor = rockTexture.Sample(SampleType, input.tex);

    // Calculate the slope of this point.
    slope = 1.0f - input.normal.y;

    // Determine which texture to use based on height.
    if(slope < 0.2)
    {
        blendAmount = slope / 0.2f;
        textureColor = lerp(grassColor, slopeColor, blendAmount);
    }
	
    if((slope < 0.7) && (slope >= 0.2f))
    {
        blendAmount = (slope - 0.2f) * (1.0f / (0.7f - 0.2f));
        textureColor = lerp(slopeColor, rockColor, blendAmount);
    }

    if(slope >= 0.7) 
    {
        textureColor = rockColor;
    }*/
	
	output.Lighting = float4(lightcol.rgb * saturate(dot(input.NormalW, lightvec)), 1.0f);

	return output;
}

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement
  • Advertisement
  • Popular Now

  • Advertisement
  • Similar Content

    • By AxeGuywithanAxe
      I wanted to see how others are currently handling descriptor heap updates and management.
      I've read a few articles and there tends to be three major strategies :
      1 ) You split up descriptor heaps per shader stage ( i.e one for vertex shader , pixel , hull, etc)
      2) You have one descriptor heap for an entire pipeline
      3) You split up descriptor heaps for update each update frequency (i.e EResourceSet_PerInstance , EResourceSet_PerPass , EResourceSet_PerMaterial, etc)
      The benefits of the first two approaches is that it makes it easier to port current code, and descriptor / resource descriptor management and updating tends to be easier to manage, but it seems to be not as efficient.
      The benefits of the third approach seems to be that it's the most efficient because you only manage and update objects when they change.
    • By evelyn4you
      hi,
      until now i use typical vertexshader approach for skinning with a Constantbuffer containing the transform matrix for the bones and an the vertexbuffer containing bone index and bone weight.
      Now i have implemented realtime environment  probe cubemaping so i have to render my scene from many point of views and the time for skinning takes too long because it is recalculated for every side of the cubemap.
      For Info i am working on Win7 an therefore use one Shadermodel 5.0 not 5.x that have more options, or is there a way to use 5.x in Win 7
      My Graphic Card is Directx 12 compatible NVidia GTX 960
      the member turanszkij has posted a good for me understandable compute shader. ( for Info: in his engine he uses an optimized version of it )
      https://turanszkij.wordpress.com/2017/09/09/skinning-in-compute-shader/
      Now my questions
       is it possible to feed the compute shader with my orignial vertexbuffer or do i have to copy it in several ByteAdressBuffers as implemented in the following code ?
        the same question is about the constant buffer of the matrixes
       my more urgent question is how do i feed my normal pipeline with the result of the compute Shader which are 2 RWByteAddressBuffers that contain position an normal
      for example i could use 2 vertexbuffer bindings
      1 containing only the uv coordinates
      2.containing position and normal
      How do i copy from the RWByteAddressBuffers to the vertexbuffer ?
       
      (Code from turanszkij )
      Here is my shader implementation for skinning a mesh in a compute shader:
      1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 struct Bone { float4x4 pose; }; StructuredBuffer<Bone> boneBuffer;   ByteAddressBuffer vertexBuffer_POS; // T-Pose pos ByteAddressBuffer vertexBuffer_NOR; // T-Pose normal ByteAddressBuffer vertexBuffer_WEI; // bone weights ByteAddressBuffer vertexBuffer_BON; // bone indices   RWByteAddressBuffer streamoutBuffer_POS; // skinned pos RWByteAddressBuffer streamoutBuffer_NOR; // skinned normal RWByteAddressBuffer streamoutBuffer_PRE; // previous frame skinned pos   inline void Skinning(inout float4 pos, inout float4 nor, in float4 inBon, in float4 inWei) {  float4 p = 0, pp = 0;  float3 n = 0;  float4x4 m;  float3x3 m3;  float weisum = 0;   // force loop to reduce register pressure  // though this way we can not interleave TEX - ALU operations  [loop]  for (uint i = 0; ((i &lt; 4) &amp;&amp; (weisum&lt;1.0f)); ++i)  {  m = boneBuffer[(uint)inBon].pose;  m3 = (float3x3)m;   p += mul(float4(pos.xyz, 1), m)*inWei;  n += mul(nor.xyz, m3)*inWei;   weisum += inWei;  }   bool w = any(inWei);  pos.xyz = w ? p.xyz : pos.xyz;  nor.xyz = w ? n : nor.xyz; }   [numthreads(1024, 1, 1)] void main( uint3 DTid : SV_DispatchThreadID ) {  const uint fetchAddress = DTid.x * 16; // stride is 16 bytes for each vertex buffer now...   uint4 pos_u = vertexBuffer_POS.Load4(fetchAddress);  uint4 nor_u = vertexBuffer_NOR.Load4(fetchAddress);  uint4 wei_u = vertexBuffer_WEI.Load4(fetchAddress);  uint4 bon_u = vertexBuffer_BON.Load4(fetchAddress);   float4 pos = asfloat(pos_u);  float4 nor = asfloat(nor_u);  float4 wei = asfloat(wei_u);  float4 bon = asfloat(bon_u);   Skinning(pos, nor, bon, wei);   pos_u = asuint(pos);  nor_u = asuint(nor);   // copy prev frame current pos to current frame prev pos streamoutBuffer_PRE.Store4(fetchAddress, streamoutBuffer_POS.Load4(fetchAddress)); // write out skinned props:  streamoutBuffer_POS.Store4(fetchAddress, pos_u);  streamoutBuffer_NOR.Store4(fetchAddress, nor_u); }  
    • By mister345
      Hi, can someone please explain why this is giving an assertion EyePosition!=0 exception?
       
      _lightBufferVS->viewMatrix = DirectX::XMMatrixLookAtLH(XMLoadFloat3(&_lightBufferVS->position), XMLoadFloat3(&_lookAt), XMLoadFloat3(&up));
      It looks like DirectX doesnt want the 2nd parameter to be a zero vector in the assertion, but I passed in a zero vector with this exact same code in another program and it ran just fine. (Here is the version of the code that worked - note XMLoadFloat3(&m_lookAt) parameter value is (0,0,0) at runtime - I debugged it - but it throws no exceptions.
          m_viewMatrix = DirectX::XMMatrixLookAtLH(XMLoadFloat3(&m_position), XMLoadFloat3(&m_lookAt), XMLoadFloat3(&up)); Here is the repo for the broken code (See LightClass) https://github.com/mister51213/DirectX11Engine/blob/master/DirectX11Engine/LightClass.cpp
      and here is the repo with the alternative version of the code that is working with a value of (0,0,0) for the second parameter.
      https://github.com/mister51213/DX11Port_SoftShadows/blob/master/Engine/lightclass.cpp
    • By mister345
      Hi, can somebody please tell me in clear simple steps how to debug and step through an hlsl shader file?
      I already did Debug > Start Graphics Debugging > then captured some frames from Visual Studio and
      double clicked on the frame to open it, but no idea where to go from there.
       
      I've been searching for hours and there's no information on this, not even on the Microsoft Website!
      They say "open the  Graphics Pixel History window" but there is no such window!
      Then they say, in the "Pipeline Stages choose Start Debugging"  but the Start Debugging option is nowhere to be found in the whole interface.
      Also, how do I even open the hlsl file that I want to set a break point in from inside the Graphics Debugger?
       
      All I want to do is set a break point in a specific hlsl file, step thru it, and see the data, but this is so unbelievably complicated
      and Microsoft's instructions are horrible! Somebody please, please help.
       
       
       

    • By mister345
      I finally ported Rastertek's tutorial # 42 on soft shadows and blur shading. This tutorial has a ton of really useful effects and there's no working version anywhere online.
      Unfortunately it just draws a black screen. Not sure what's causing it. I'm guessing the camera or ortho matrix transforms are wrong, light directions, or maybe texture resources not being properly initialized.  I didnt change any of the variables though, only upgraded all types and functions DirectX3DVector3 to XMFLOAT3, and used DirectXTK for texture loading. If anyone is willing to take a look at what might be causing the black screen, maybe something pops out to you, let me know, thanks.
      https://github.com/mister51213/DX11Port_SoftShadows
       
      Also, for reference, here's tutorial #40 which has normal shadows but no blur, which I also ported, and it works perfectly.
      https://github.com/mister51213/DX11Port_ShadowMapping
       
  • Advertisement