An atmospheric entry geometry shader written in HLSL.
I learned to work with HLSL’s geometry shader, and learned about shadow mapping. You can read an in-depth analysis in my paper (linked in project specifications)
//Atmospheric Entry Shader - DX11
//Digital Arts & Entertainment
//AtmosphericShader.fx
//author: Brian Van Hyfte
//class: 2DAE1
//Matrices
float4x4 gWorldViewProj : WORLDVIEWPROJECTION;
float4x4 gWorld: WORLD;
float4x4 gViewProj;
float4x4 gViewInverse: VIEWINVERSE;
float4x4 gVelocityViewProj;
//Color
bool gUseTextureDiffuse = false;
Texture2D gTextureDiffuse;
bool gUseTextureSpecularIntensity = false;
Texture2D gTextureSpecularIntensity;
float4 gColorDiffuse : COLOR = float4(1.0, 1.0, 1.0, 1.0);
float4 gColorAmbient : COLOR = float4(0.05, 0.05, 0.05, 1.0);
float gAmbientIntensity = 1.0f;
float4 gColorSpecular : COLOR = float4(1.0, 1.0, 1.0, 1.0);
float gShininess = 50.0f;
//Non-Color maps
Texture2D gVelocityShadowMap;
Texture2D gNoiseMap;
//Shadow
float gShadowStrength = 1.f;
//Global lighting
float3 gLightDirection : DIRECTION = float3(-.577f, -.577f, .577f);
float gGlobalLightMultiplier = 0.65f;
//Friction-related stuff
float3 gVelocityDirection = float3(0, -1, 0);
float gVelocity = 1;
float gEntryIntensity = 1;
float4 gEntryLightColor = float4(1, 0.5f, 0.2f, 1);
float4 gEntryLightColorSecond = float4(1, 0.15f, 0, 0.00f);
float4 gEntryLightColorBright = float4(1, 0.85f, 0.3f, 0.05f);
float gVelocityShadowBias = 0.003f;
float gVelMultiplier = 20.f;
float gColorModifier = 1.5f;
float gUVAdd = 0.f;
float gLengthMultiplier = 1.f;
//States
RasterizerState NoCulling
{
CullMode = NONE;
};
BlendState AlphaBlending
{
BlendEnable[0] = TRUE;
SrcBlend = SRC_ALPHA;
DestBlend = INV_SRC_ALPHA;
};
DepthStencilState DisableDepthWriting
{
DepthEnable = TRUE;
DepthWriteMask = ZERO;
};
//Samplers
SamplerState gTextureSampler
{
Filter = MIN_MAG_MIP_LINEAR;
AddressU = WRAP;
AddressV = WRAP;
};
SamplerComparisonState cmpSampler
{
Filter = COMPARISON_MIN_MAG_MIP_LINEAR;
AddressU = MIRROR;
AddressV = MIRROR;
ComparisonFunc = LESS_EQUAL;
};
//Input / output
struct VS_INPUT
{
float3 pos : POSITION;
float3 normal : NORMAL;
float2 texCoord : TEXCOORD0;
};
struct VS_OUTPUT
{
float4 pos : SV_POSITION;
float3 normal : NORMAL;
float2 texCoord : TEXCOORD0;
float3 worldPos : TEXCOORD1;
float4 lPos : TEXCOORD2;
};
//Helper functions
float2 TexOffset(int u, int v)
{
int width, height;
gVelocityShadowMap.GetDimensions(width, height);
return float2(u * 1.0f / width, v * 1.0f / height);
}
float CalculateShadow(float4 lightPos, Texture2D shadowMap, float bias)
{
float4 lpos = float4(lightPos.xyz / lightPos.w, lightPos.w);
if (lpos.x < -1.0f || lpos.x > 1.0f || lpos.y < -1.0f || lpos.y > 1.0f || lpos.z < 0.0f || lpos.z > 1.0f)
return 1;
lpos.x = lpos.x / 2 + 0.5;
lpos.y = lpos.y / -2 + 0.5;
lpos.z -= bias;
float sum;
float x, y;
for (y = -2; y <= 2; y += 1.0f)
{
for (x = -2; x <= 2; x += 1.0f)
{
sum += shadowMap.SampleCmpLevelZero(cmpSampler, lpos.xy + texOffset(x, y), lpos.z);
}
}
float shadowFac = sum / 25.0f;
return saturate(shadowFac + 1 - gShadowStrength);
}
float3 CalculateDiffuse(float3 normal, float2 texCoord, float3 lightDirection)
{
float3 diffuseColor = gColorDiffuse;
//Diffuse Logic
float diffuseStrength = saturate(dot(normal, -lightDirection));
diffuseColor *= diffuseStrength;
if (gUseTextureDiffuse) {
diffuseColor = gTextureDiffuse.Sample(gTextureSampler, texCoord) * diffuseStrength;
}
return diffuseColor;
}
float3 CalculateSpecularPhong(float3 viewDirection, float3 normal, float2 texCoord, float3 lightDirection)
{
float3 specularColor = gColorSpecular;
if (gUseTextureSpecularIntensity) {
specularColor = gTextureSpecularIntensity.Sample(gTextureSampler, texCoord);
}
//Specular Specular Logic
float3 reflectedVector = reflect(lightDirection, normal);
float specularStrength = dot(-viewDirection, reflectedVector);
specularStrength = saturate(specularStrength);
specularStrength = pow(specularStrength, gShininess);
specularColor *= specularStrength;
return specularColor;
}
//--------------//
//HEATING EFFECT//
//--------------//
//VERTEX SHADER
//Applies heating effect on the model
VS_OUTPUT MainVS(VS_INPUT input)
{
VS_OUTPUT output = (VS_OUTPUT)0;
output.pos = mul(float4(input.pos, 1.0f), gWorldViewProj);
output.normal = mul(input.normal, (float3x3)gWorld);
output.texCoord = input.texCoord;
// Use a float4 for transforming
output.worldPos = mul(float4(input.pos, 1.0f), gWorld);
output.lPos = mul(float4(input.pos, 1), mul(gWorld, gVelocityViewProj));
return output;
}
//PIXEL SHADER
//Applies heating effect on the model
float4 MainPS(VS_OUTPUT input) : SV_TARGET
{
float3 normal = input.normal;
float3 ambient = gColorAmbient*gAmbientIntensity;
float3 viewDirection = normalize(input.worldPos.xyz - gViewInverse[3].xyz);
//Calculate diffuse and specular global lighting
float3 globalLight = CalculateDiffuse(normal, input.texCoord, gLightDirection)
+ CalculateSpecularPhong(viewDirection, normal, input.texCoord, gLightDirection);
globalLight *= gGlobalLightMultiplier;
float velShadow = CalculateShadow(input.lPos, gVelocityShadowMap, gVelocityShadowBias);
float3 entryHeat = CalculateDiffuse(normal, input.texCoord, gVelocityDirection)
+ CalculateSpecularPhong(viewDirection, normal, input.texCoord, gVelocityDirection);
entryHeat *= gEntryLightColor.rgb*gEntryLightColor.a;
entryHeat *= velShadow; //Add shadows so it only shows light on planes that are directly exposed to the velocity vector
entryHeat *= gEntryIntensity; //Strength of the light. Atmospheric density can change friction, which means surfaces heat up more
entryHeat *= gVelocity; //A faster object has more friction, thus it is hotter
return float4(ambient + globalLight + entryHeat, 1);
}
//------------------------------//
//TRAIL EFFECT - GEOMETRY SHADER//
//------------------------------//
//STRUCTS
//data
struct GS_DATA
{
float4 pos : SV_POSITION;
float4 color : COLOR;
};
//input
struct GS_INPUT
{
float3 pos : POSITION;
float3 worldPos : POSITION1;
float3 normal : NORMAL;
float4 lPos : TEXCOORD1;
};
//Helper functions
void CreateVertex(inout TriangleStream<GS_DATA> triStream, float3 pos, float4 col)
{
GS_DATA data = (GS_DATA)0;
data.pos = mul(float4(pos, 1.0f), gViewProj);
data.color = col;
triStream.Append(data);
}
float GetNoiseLength(float2 uv)
{
float lengthVar = gNoiseMap.SampleLevel(gTextureSampler, uv, 0);
return lengthVar * gLengthMultiplier;
}
//Pixel Shader
float4 VelocityTrailPS(GS_DATA input) : SV_TARGET
{
return input.color;
}
//Vertex Shader
GS_INPUT VelocityTrailerVS(VS_INPUT input)
{
GS_INPUT output = (GS_INPUT)0;
output.pos = input.pos;
output.worldPos = mul(float4(input.pos, 1.0f), gWorld);
output.normal = mul(input.normal, (float3x3)gWorld);
output.lPos = mul(float4(input.pos, 1), mul(gWorld, gVelocityViewProj));
return output;
}
[maxvertexcount(6)]
void VelocityTrailerGS(triangle GS_INPUT vertex[3], inout TriangleStream<GS_DATA> triStream)
{
//colors
float3 brightCol = gEntryLightColorBright.rgb;
float4 col1 = float4(brightCol, gEntryLightColorBright.a)*gVelocity;
float4 col2 = lerp(gEntryLightColorBright, gEntryLightColorSecond, gColorModifier)*gVelocity;
float4 col3 = gEntryLightColorSecond*gVelocity;
float3 normVel = normalize(gVelocityDirection);
for (int i = 0; i < 3; i++)
{
float3 normal = normalize(vertex[i].normal);
float velDot = -dot(normal, normVel);
float occlusion = CalculateShadow(vertex[i].lPos, gVelocityShadowMap, gVelocityShadowBias);
//determining length based on normal
if (velDot >= 0 && occlusion>0.9f)
{
int j = (i + 1) % 3;
//Create vertices on the edge itself
CreateVertex(triStream, vertex[i].worldPos, col1);
CreateVertex(triStream, vertex[j].worldPos, col1);
//Calculate length
float3 normalized = normalize(vertex[i].pos) + gUVAdd;
float randomI = GetNoiseLength(float2(normalized.x, normalized.y));
normalized = normalize(vertex[j].pos) + gUVAdd;
float randomJ = GetNoiseLength(float2(normalized.x, normalized.y));
//Create "stacked" quads that create a gradient which simulates heat dissipation
CreateVertex(triStream, vertex[i].worldPos + (gVelocity * gVelMultiplier * occlusion * velDot * normVel * randomI), col2);
CreateVertex(triStream, vertex[j].worldPos + (gVelocity * gVelMultiplier * occlusion * velDot * normVel * randomJ), col2);
CreateVertex(triStream, vertex[i].worldPos + (gVelocity * gVelMultiplier * occlusion * velDot * normVel * gColorModifier * randomI), col3);
CreateVertex(triStream, vertex[j].worldPos + (gVelocity * gVelMultiplier * occlusion * velDot * normVel * gColorModifier * randomJ), col3);
}
}
}
//Techniques
technique11 TechPhong
{
pass p0
{
SetRasterizerState(NoCulling);
SetVertexShader(CompileShader(vs_4_0, MainVS()));
SetPixelShader(CompileShader(ps_4_0, MainPS()));
}
pass p1
{
SetRasterizerState(NoCulling);
SetDepthStencilState(DisableDepthWriting, 0);
SetBlendState(AlphaBlending, float4(0.0f, 0.0f, 0.0f, 0.0f), 0xFFFFFFFF);
SetVertexShader(CompileShader(vs_4_0, VelocityTrailerVS()));
SetGeometryShader(CompileShader(gs_4_0, VelocityTrailerGS()));
SetPixelShader(CompileShader(ps_4_0, VelocityTrailPS()));
}
}