Holy shit!
I fixed it, the stride when sending the vertex buffer was wrong!
Thanks for all your help!
Holy shit!
I fixed it, the stride when sending the vertex buffer was wrong!
Thanks for all your help!
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;
}