Molehill Shader

HLSL

/*DirtPileShader.fx
FirstName: Ga?l
LastName: Vanhalst
Class: 2DAE_GD1
*/

//************
// VARIABLES *
//************
cbuffer cbPerObject
{
	float4x4 m_MatrixWorldViewProj : WORLDVIEWPROJECTION;
	float4x4 m_MatrixWorld : WORLD;
	float3 m_LightDir=float3(-0.577f, -0.577f, 0.577f);
	float m_Radius={5.f};
}


RasterizerState FrontCulling
{
	CullMode = NONE;
};

SamplerState samLinear
{
    Filter = MIN_MAG_MIP_LINEAR;
    AddressU = Wrap;// of Mirror of Clamp of Border
    AddressV = Wrap;// of Mirror of Clamp of Border
};

Texture2D m_TextureDiffuse;

//**********
// STRUCTS *
//**********
struct VS_DATA
{
	float3 Position : POSITION;
	float3 Normal : NORMAL;
    float2 TexCoord : TEXCOORD;
	float Height: HEIGHT;
};

struct GS_DATA
{
	float4 Position : SV_POSITION;
	float3 Normal : NORMAL;
	float2 TexCoord : TEXCOORD0;
};



//****************
// VERTEX SHADER *
//****************
VS_DATA MainVS(VS_DATA vsData)
{
	if(vsData.Height<0)vsData.Height=0;

	if(vsData.Height>1)vsData.Height=1;

	return vsData;
}

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

float3 normalCalculator(VS_DATA vertex1, VS_DATA vertex2, VS_DATA vertex3)
{
	float3 delta13=vertex1.Position-vertex3.Position;
	float3 delta12=vertex1.Position-vertex2.Position;


	float3 normal;
	normal=cross(delta12,delta13);
	normal=normalize(normal);

	return normal;
}

[maxvertexcount(9)]
void GS(triangle VS_DATA gln[3], inout TriangleStream<GS_DATA> triStream)
{
	GS_DATA output = (GS_DATA)0;

	output.Position=mul(float4(gln[0].Position,1),m_MatrixWorldViewProj);
	output.Normal = mul(gln[0].Normal, (float3x3)m_MatrixWorld);
	output.TexCoord = gln[0].TexCoord;
	triStream.Append(output);

	output.Position=mul(float4(gln[1].Position,1),m_MatrixWorldViewProj);
	output.Normal = mul(gln[1].Normal, (float3x3)m_MatrixWorld);
	output.TexCoord = gln[1].TexCoord;
	triStream.Append(output);

	output.Position=mul(float4(gln[2].Position,1),m_MatrixWorldViewProj);
	output.Normal = mul(gln[2].Normal, (float3x3)m_MatrixWorld);
	output.TexCoord = gln[2].TexCoord;
	triStream.Append(output);

	//Check how many points are elevated
	uint counter=0;
	for(uint i=0;i<3;i++)
	{
		if(gln[i].Height>0)counter++;
	}

	//Nothing needs to happen
	if(counter==0)return;

	//Generate new triangles
	if(counter==1)
	{

		VS_DATA newV[3]={(VS_DATA)0,(VS_DATA)0,(VS_DATA)0};

		int levetatedPoint;
		int groundPoint1, groundPoint2;
		bool groundPSet=false;

		for(uint i=0;i<3;i++)
		{
			newV[i]=gln[i];
			if(gln[i].Height>0)levetatedPoint=i;
			else if(groundPSet)
			{
				groundPoint2=i;
			}
			else
			{
				groundPoint1=i;
				groundPSet=true;
			}
		}

		float distance=(1-sqrt(1-(gln[levetatedPoint].Height*gln[levetatedPoint].Height)))*m_Radius;

		float deltaX=gln[groundPoint1].Position.x-gln[levetatedPoint].Position.x;
		float deltaY=gln[groundPoint1].Position.y-gln[levetatedPoint].Position.y;
		float deltaZ=gln[groundPoint1].Position.z-gln[levetatedPoint].Position.z;

		float deltaU=gln[groundPoint1].TexCoord.x-gln[levetatedPoint].TexCoord.x;
		float deltaV=gln[groundPoint1].TexCoord.y-gln[levetatedPoint].TexCoord.y;

		float ratio=sqrt((distance*distance)/((deltaY*deltaY)+(deltaX*deltaX)+(deltaZ*deltaZ)));

		float3 position=gln[levetatedPoint].Position;
		position.x+=deltaX*ratio;
		position.y+=deltaY*ratio;
		position.z+=deltaZ*ratio;
		newV[groundPoint1].Position=float3(position);

		float2 uvposition=gln[levetatedPoint].TexCoord;
		uvposition.x+=deltaU*ratio;
		uvposition.y+=deltaV*ratio;
		newV[groundPoint1].TexCoord=uvposition;


		deltaX=gln[groundPoint2].Position.x-gln[levetatedPoint].Position.x;
		deltaY=gln[groundPoint2].Position.y-gln[levetatedPoint].Position.y;
		deltaZ=gln[groundPoint2].Position.z-gln[levetatedPoint].Position.z;

		deltaU=gln[groundPoint2].TexCoord.x-gln[levetatedPoint].TexCoord.x;
		deltaV=gln[groundPoint2].TexCoord.y-gln[levetatedPoint].TexCoord.y;

		ratio=sqrt((distance*distance)/((deltaY*deltaY)+(deltaX*deltaX)+(deltaZ*deltaZ)));

		position=gln[levetatedPoint].Position;
		position.x+=deltaX*ratio;
		position.y+=deltaY*ratio;
		position.z+=deltaZ*ratio;
		newV[groundPoint2].Position=float3(position);

		uvposition=gln[levetatedPoint].TexCoord;
		uvposition.x+=deltaU*ratio;
		uvposition.y+=deltaV*ratio;
		newV[groundPoint2].TexCoord=uvposition;


		newV[0].Position+=(newV[0].Height*m_Radius)*newV[0].Normal;
		newV[1].Position+=(newV[1].Height*m_Radius)*newV[1].Normal;
		newV[2].Position+=(newV[2].Height*m_Radius)*newV[2].Normal;

		newV[0].Normal=normalCalculator(newV[0],newV[1],newV[2]);
		newV[1].Normal=normalCalculator(newV[1],newV[2],newV[0]);
		newV[2].Normal=normalCalculator(newV[2],newV[0],newV[1]);

		triStream.RestartStrip();


		output.Position=mul(float4(newV[0].Position,1),m_MatrixWorldViewProj);
		output.Normal = mul(newV[0].Normal, (float3x3)m_MatrixWorld);
		output.TexCoord = newV[0].TexCoord;
		triStream.Append(output);


		output.Position=mul(float4(newV[1].Position,1),m_MatrixWorldViewProj);
		output.Normal = mul(newV[1].Normal, (float3x3)m_MatrixWorld);
		output.TexCoord = newV[1].TexCoord;
		triStream.Append(output);

		output.Position=mul(float4(newV[2].Position,1),m_MatrixWorldViewProj);
		output.Normal = mul(newV[2].Normal, (float3x3)m_MatrixWorld);
		output.TexCoord = newV[2].TexCoord;
		triStream.Append(output);
	}

	//Generate new triangles
	else if(counter==2)
	{

		VS_DATA newV[3]={(VS_DATA)0,(VS_DATA)0,(VS_DATA)0};
		int elevetatedPoint1, elevetatedPoint2;
		int groundPoint;
		bool elevPSet=false;

		for(uint i=0;i<3;i++)
		{
			newV[i]=gln[i];
			if(gln[i].Height<=0)groundPoint=i;
			else if(elevPSet)
			{
				elevetatedPoint2=i;
			}
			else
			{
				elevetatedPoint1=i;
				elevPSet=true;
			}
		}
		float distance=(1-sqrt(1-(gln[elevetatedPoint1].Height*gln[elevetatedPoint1].Height)))*m_Radius;

		float deltaX=gln[groundPoint].Position.x-gln[elevetatedPoint1].Position.x;
		float deltaY=gln[groundPoint].Position.y-gln[elevetatedPoint1].Position.y;
		float deltaZ=gln[groundPoint].Position.z-gln[elevetatedPoint1].Position.z;

		float deltaU=gln[groundPoint].TexCoord.x-gln[elevetatedPoint1].TexCoord.x;
		float deltaV=gln[groundPoint].TexCoord.y-gln[elevetatedPoint1].TexCoord.y;

		float ratio=sqrt((distance*distance)/((deltaY*deltaY)+(deltaX*deltaX)+(deltaZ*deltaZ)));

		float3 position=gln[elevetatedPoint1].Position;
		position.x+=deltaX*ratio;
		position.y+=deltaY*ratio;
		position.z+=deltaZ*ratio;
		newV[elevetatedPoint1].Position=float3(position);

		float2 uvposition=gln[elevetatedPoint1].TexCoord;
		uvposition.x+=deltaU*ratio;
		uvposition.y+=deltaV*ratio;
		newV[elevetatedPoint1].TexCoord=uvposition;


		distance=(1-sqrt(1-gln[elevetatedPoint2].Height*gln[elevetatedPoint2].Height))*m_Radius;

		deltaX=gln[groundPoint].Position.x-gln[elevetatedPoint2].Position.x;
		deltaY=gln[groundPoint].Position.y-gln[elevetatedPoint2].Position.y;
		deltaZ=gln[groundPoint].Position.z-gln[elevetatedPoint2].Position.z;

		deltaU=gln[groundPoint].TexCoord.x-gln[elevetatedPoint2].TexCoord.x;
		deltaV=gln[groundPoint].TexCoord.y-gln[elevetatedPoint2].TexCoord.y;

		ratio=sqrt((distance*distance)/((deltaY*deltaY)+(deltaX*deltaX)+(deltaZ*deltaZ)));

		position=gln[elevetatedPoint2].Position;
		position.x+=deltaX*ratio;
		position.y+=deltaY*ratio;
		position.z+=deltaZ*ratio;
		newV[elevetatedPoint2].Position=float3(position);

		uvposition=gln[elevetatedPoint2].TexCoord;
		uvposition.x+=deltaU*ratio;
		uvposition.y+=deltaV*ratio;
		newV[elevetatedPoint2].TexCoord=uvposition;


		gln[0].Position+=(gln[0].Height*m_Radius)*gln[0].Normal;
		gln[1].Position+=(gln[1].Height*m_Radius)*gln[1].Normal;
		gln[2].Position+=(gln[2].Height*m_Radius)*gln[2].Normal;

		triStream.RestartStrip();
		if(gln[0].Height>0)gln[0].Normal=normalCalculator(gln[0],gln[1],gln[2]);
		if(gln[1].Height>0)gln[1].Normal=normalCalculator(gln[1],gln[2],gln[0]);
		if(gln[2].Height>0)gln[2].Normal=normalCalculator(gln[2],gln[0],gln[1]);

		output.Position=mul(float4(gln[elevetatedPoint1].Position,1),m_MatrixWorldViewProj);
		output.Normal = mul(gln[elevetatedPoint1].Normal, (float3x3)m_MatrixWorld);
		output.TexCoord = gln[elevetatedPoint1].TexCoord;
		triStream.Append(output);


		output.Position=mul(float4(gln[elevetatedPoint2].Position,1),m_MatrixWorldViewProj);
		output.Normal = mul(gln[elevetatedPoint2].Normal, (float3x3)m_MatrixWorld);
		output.TexCoord = gln[elevetatedPoint2].TexCoord;
		triStream.Append(output);

		output.Position=mul(float4(newV[elevetatedPoint1].Position,1),m_MatrixWorldViewProj);
		output.Normal = mul(newV[elevetatedPoint1].Normal, (float3x3)m_MatrixWorld);
		output.TexCoord = newV[elevetatedPoint1].TexCoord;
		triStream.Append(output);

		triStream.RestartStrip();

		output.Position=mul(float4(newV[elevetatedPoint1].Position,1),m_MatrixWorldViewProj);
		output.Normal = mul(newV[elevetatedPoint1].Normal, (float3x3)m_MatrixWorld);
		output.TexCoord = newV[elevetatedPoint1].TexCoord;
		triStream.Append(output);

		output.Position=mul(float4(gln[elevetatedPoint2].Position,1),m_MatrixWorldViewProj);
		output.Normal = mul(gln[elevetatedPoint2].Normal, (float3x3)m_MatrixWorld);
		output.TexCoord = gln[elevetatedPoint2].TexCoord;
		triStream.Append(output);

		output.Position=mul(float4(newV[elevetatedPoint2].Position,1),m_MatrixWorldViewProj);
		output.Normal = mul(newV[elevetatedPoint2].Normal, (float3x3)m_MatrixWorld);
		output.TexCoord = newV[elevetatedPoint2].TexCoord;
		triStream.Append(output);


	}
	//Elevate existing triangle (no new triangles need to be generated)
	else if(counter==3)
	{
		triStream.RestartStrip();
		gln[0].Position+=(gln[0].Height*m_Radius)*gln[0].Normal;
		gln[1].Position+=(gln[1].Height*m_Radius)*gln[1].Normal;
		gln[2].Position+=(gln[2].Height*m_Radius)*gln[2].Normal;

		gln[0].Normal=normalCalculator(gln[0],gln[1],gln[2]);
		gln[1].Normal=normalCalculator(gln[1],gln[2],gln[0]);
		gln[2].Normal=normalCalculator(gln[2],gln[0],gln[1]);

		output.Position=mul(float4(gln[0].Position,1),m_MatrixWorldViewProj);
		output.Normal = mul(gln[0].Normal, (float3x3)m_MatrixWorld);
		output.TexCoord = gln[0].TexCoord;
		triStream.Append(output);



		output.Position=mul(float4(gln[1].Position,1),m_MatrixWorldViewProj);
		output.Normal = mul(gln[1].Normal, (float3x3)m_MatrixWorld);
		output.TexCoord = gln[1].TexCoord;
		triStream.Append(output);


		output.Position=mul(float4(gln[2].Position,1),m_MatrixWorldViewProj);
		output.Normal = mul(gln[2].Normal, (float3x3)m_MatrixWorld);
		output.TexCoord = gln[2].TexCoord;
		triStream.Append(output);
	}

}

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


float3 CalculateDiffuse(float3 normal, float2 texCoord)
{
	float4 diffuseColor=float4(0,0,0,1);
	diffuseColor = m_TextureDiffuse.Sample( samLinear,texCoord );
	float3 color_rgb= diffuseColor.rgb;

	float diffuseStrength = dot(normal, -m_LightDir);
	diffuseStrength = diffuseStrength * 0.5 + 0.5;
	diffuseStrength = saturate(diffuseStrength);
	color_rgb = color_rgb * diffuseStrength;

	return float3( color_rgb);
}

float4 MainPS(GS_DATA input) : SV_TARGET
{

	input.Normal = normalize(input.Normal);

	float3 diffColor = CalculateDiffuse(input.Normal, input.TexCoord);

	return float4(diffColor,1);
}

//*************
// TECHNIQUES *
//*************
technique10 DefaultTechnique
{
	pass p0 {
		SetRasterizerState(FrontCulling);
		SetVertexShader(CompileShader(vs_4_0, MainVS()));
		SetGeometryShader(CompileShader(gs_4_0,GS()));
		SetPixelShader(CompileShader(ps_4_0, MainPS()));
	}
}