Jump to content

  • Log In with Google      Sign In   
  • Create Account

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.

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

#21 Migi0027   Crossbones+   -  Reputation: 1725

Like
1Likes
Like

Posted 05 August 2013 - 04:22 PM

Holy shit! laugh.png

 

I fixed it, the stride when sending the vertex buffer was wrong!

 

Thanks for all your help!


Hi! Cuboid Zone
The Rule: Be polite, be professional, but have a plan to kill everyone you meet, ohh, AND STEAL ALL ZE TRIANGLES FROM ZHEM!

Sponsor:

#22 Migi0027   Crossbones+   -  Reputation: 1725

Like
0Likes
Like

Posted 17 August 2013 - 06:56 AM

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

Hi! Cuboid Zone
The Rule: Be polite, be professional, but have a plan to kill everyone you meet, ohh, AND STEAL ALL ZE TRIANGLES FROM ZHEM!




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



PARTNERS