View more

View more

View more

### Image of the Day Submit

IOTD | Top Screenshots

### The latest, straight to your Inbox.

Subscribe to GameDev.net Direct to receive the latest updates and exclusive content.

# DX11 - Terrain Tessellation repeating

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.

21 replies to this topic

### #1Migi0027 (肉コーダ)  Members

Posted 24 July 2013 - 10:30 AM

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;

float4 lightvec;
float4 lightcol;

float FogStart;
float FogEnd;
float2 __space;

float3 FogColor;

float SpecularIntensity;
float4 SpecularColor;
}

//***************************************************//
//***************************************************//

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 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;
}

//***************************************************//
//***************************************************//

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;
}

//***************************************************//
//***************************************************//

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;
}

//***************************************************//
//***************************************************//

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

{
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?)

Thank you, as always GameDev.

Edited by Migi0027, 24 July 2013 - 10:32 AM.

FastCall22: "I want to make the distinction that my laptop is a whore-box that connects to different network"

Blog about... stuff (GDNet, WordPress): www.gamedev.net/blog/1882-the-cuboid-zone/cuboidzone.wordpress.com/

### #2Zaoshi Kaba  Members

Posted 25 July 2013 - 04:57 AM

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.

### #3Jason Z  Members

Posted 26 July 2013 - 05:37 AM

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?

Jason Zink :: DirectX MVP

Direct3D 11 engine on CodePlex: Hieroglyph 3

Games: Lunar Rift

### #4Migi0027 (肉コーダ)  Members

Posted 05 August 2013 - 08:33 AM

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:

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?

FastCall22: "I want to make the distinction that my laptop is a whore-box that connects to different network"

Blog about... stuff (GDNet, WordPress): www.gamedev.net/blog/1882-the-cuboid-zone/cuboidzone.wordpress.com/

### #5unbird  Members

Posted 05 August 2013 - 10:19 AM

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 (return float4(texcoord.xy, 0, 1);). 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).

### #6Migi0027 (肉コーダ)  Members

Posted 05 August 2013 - 10:40 AM

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.

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.

FastCall22: "I want to make the distinction that my laptop is a whore-box that connects to different network"

Blog about... stuff (GDNet, WordPress): www.gamedev.net/blog/1882-the-cuboid-zone/cuboidzone.wordpress.com/

### #7unbird  Members

Posted 05 August 2013 - 11:07 AM

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

### #8Migi0027 (肉コーダ)  Members

Posted 05 August 2013 - 12:32 PM

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)
...


FastCall22: "I want to make the distinction that my laptop is a whore-box that connects to different network"

Blog about... stuff (GDNet, WordPress): www.gamedev.net/blog/1882-the-cuboid-zone/cuboidzone.wordpress.com/

### #9unbird  Members

Posted 05 August 2013 - 01:29 PM

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 ?

### #10Migi0027 (肉コーダ)  Members

Posted 05 August 2013 - 01:38 PM

Sure!

PS. I know, it's quite small, but it's fine for now.

Edited by Migi0027, 05 August 2013 - 01:38 PM.

FastCall22: "I want to make the distinction that my laptop is a whore-box that connects to different network"

Blog about... stuff (GDNet, WordPress): www.gamedev.net/blog/1882-the-cuboid-zone/cuboidzone.wordpress.com/

### #11Migi0027 (肉コーダ)  Members

Posted 05 August 2013 - 02:13 PM

This is the output in Pix with the geometry shader:

FastCall22: "I want to make the distinction that my laptop is a whore-box that connects to different network"

Blog about... stuff (GDNet, WordPress): www.gamedev.net/blog/1882-the-cuboid-zone/cuboidzone.wordpress.com/

### #12Migi0027 (肉コーダ)  Members

Posted 05 August 2013 - 02:17 PM

The texture visualization:

FastCall22: "I want to make the distinction that my laptop is a whore-box that connects to different network"

Blog about... stuff (GDNet, WordPress): www.gamedev.net/blog/1882-the-cuboid-zone/cuboidzone.wordpress.com/

### #13unbird  Members

Posted 05 August 2013 - 03:03 PM

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 ?

### #14Migi0027 (肉コーダ)  Members

Posted 05 August 2013 - 03:09 PM

Whoops! That white grid is a whole other thing, just ignore that...

PreVS tab:

FastCall22: "I want to make the distinction that my laptop is a whore-box that connects to different network"

Blog about... stuff (GDNet, WordPress): www.gamedev.net/blog/1882-the-cuboid-zone/cuboidzone.wordpress.com/

### #15unbird  Members

Posted 05 August 2013 - 03:28 PM

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.

### #16Migi0027 (肉コーダ)  Members

Posted 05 August 2013 - 03:39 PM

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;

float4 lightvec;
float4 lightcol;

float FogStart;
float FogEnd;
float2 __space;

float3 FogColor;

float SpecularIntensity;
float4 SpecularColor;
}

//***************************************************//
//***************************************************//

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 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;
}

//***************************************************//
//***************************************************//

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;
}

//***************************************************//
//***************************************************//

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;
}

//***************************************************//
//***************************************************//

[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();
}

//***************************************************//
//***************************************************//

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

{
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

FastCall22: "I want to make the distinction that my laptop is a whore-box that connects to different network"

Blog about... stuff (GDNet, WordPress): www.gamedev.net/blog/1882-the-cuboid-zone/cuboidzone.wordpress.com/

### #17Migi0027 (肉コーダ)  Members

Posted 05 August 2013 - 03:54 PM

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 ]


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

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

float3 eyepos;

float4 lightvec;
float4 lightcol;

float FogStart;
float FogEnd;
float2 __space;

float3 FogColor;

float SpecularIntensity;
float4 SpecularColor;
}

//***************************************************//
//***************************************************//

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 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;
}

//***************************************************//
//***************************************************//

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;
}

//***************************************************//
//***************************************************//

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;
}

//***************************************************//
//***************************************************//

[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();
}

//***************************************************//
//***************************************************//

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

{
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

FastCall22: "I want to make the distinction that my laptop is a whore-box that connects to different network"

Blog about... stuff (GDNet, WordPress): www.gamedev.net/blog/1882-the-cuboid-zone/cuboidzone.wordpress.com/

### #18unbird  Members

Posted 05 August 2013 - 04:09 PM

You should get warnings (apart from the truncation) even if you compile the shaders in isolation, at least I do:

migi.fx(52,6): warning X3578: Output value 'VShader' is not completely initialized

The linkage error also tells you which one is the culprit (semantic TEXTURE), 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

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

Cheers.

Edited by unbird, 05 August 2013 - 04:09 PM.

### #19Migi0027 (肉コーダ)  Members

Posted 05 August 2013 - 04:17 PM

Huh, I still don't get that

... Still thinking what could be wrong.

FastCall22: "I want to make the distinction that my laptop is a whore-box that connects to different network"

Blog about... stuff (GDNet, WordPress): www.gamedev.net/blog/1882-the-cuboid-zone/cuboidzone.wordpress.com/

### #20Migi0027 (肉コーダ)  Members

Posted 05 August 2013 - 04:19 PM

The shader, if I forgot something:

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

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

float3 eyepos;

float4 lightvec;
float4 lightcol;

float FogStart;
float FogEnd;
float2 __space;

float3 FogColor;

float SpecularIntensity;
float4 SpecularColor;
}

//***************************************************//
//***************************************************//

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 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;
}

//***************************************************//
//***************************************************//

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;
}

//***************************************************//
//***************************************************//

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;
}

//***************************************************//
//***************************************************//

[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();
}

//***************************************************//
//***************************************************//

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

{
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;
}


FastCall22: "I want to make the distinction that my laptop is a whore-box that connects to different network"

Blog about... stuff (GDNet, WordPress): www.gamedev.net/blog/1882-the-cuboid-zone/cuboidzone.wordpress.com/

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.