Add slang shaders for tessellation samples

Author: SaschaWillems

shaders/slang/terraintessellation/skysphere.slang

@@ -0,0 +1,42 @@
+/* Copyright (c) 2025, Sascha Willems
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+struct VSInput
+{
+    float3 Pos;
+    float3 Normal;
+    float2 UV;
+};
+
+struct VSOutput
+{
+    float4 Pos : SV_POSITION;
+    float2 UV;
+};
+
+struct UBO
+{
+    float4x4 mvp;
+};
+ConstantBuffer<UBO> ubo;
+
+Sampler2D samplerColorMap;
+
+[shader("vertex")]
+VSOutput vertexMain(VSInput input)
+{
+    VSOutput output;
+    output.Pos = mul(ubo.mvp, float4(input.Pos, 1.0));
+    output.UV = input.UV;
+    return output;
+}
+
+
+[shader("fragment")]
+float4 fragmentMain(VSOutput input)
+{
+	return samplerColorMap.Sample(input.UV);
+}

shaders/slang/terraintessellation/terrain.slang

@@ -0,0 +1,252 @@
+/* Copyright (c) 2025, Sascha Willems
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+struct VSInput
+{
+    float3 Pos;
+    float3 Normal;
+    float2 UV;
+};
+
+struct VSOutput
+{
+    float4 Pos : SV_POSITION;
+    float3 Normal;
+    float2 UV;
+};
+
+struct DSOutput
+{
+	float4 Pos : SV_POSITION;
+	float3 Normal;
+	float2 UV;
+	float3 ViewVec;
+	float3 LightVec;
+	float3 EyePos;
+	float3 WorldPos;
+};
+
+struct UBO
+{
+    float4x4 projection;
+    float4x4 modelview;
+    float4 lightPos;
+    float4 frustumPlanes[6];
+    float displacementFactor;
+    float tessellationFactor;
+    float2 viewportDim;
+    float tessellatedEdgeSize;
+};
+ConstantBuffer<UBO> ubo;
+
+Sampler2D samplerHeight;
+Sampler2DArray samplerLayers;
+
+struct HSOutput
+{
+	float4 Pos : SV_POSITION;
+	float3 Normal : NORMAL0;
+	float2 UV : TEXCOORD0;
+};
+
+struct ConstantsHSOutput
+{
+    float TessLevelOuter[4] : SV_TessFactor;
+    float TessLevelInner[2] : SV_InsideTessFactor;
+};
+
+// Calculate the tessellation factor based on screen space
+// dimensions of the edge
+float screenSpaceTessFactor(float4 p0, float4 p1)
+{
+    // Calculate edge mid point
+    float4 midPoint = 0.5 * (p0 + p1);
+    // Sphere radius as distance between the control points
+    float radius = distance(p0, p1) / 2.0;
+
+    // View space
+    float4 v0 = mul(ubo.modelview, midPoint);
+
+    // Project into clip space
+    float4 clip0 = mul(ubo.projection, (v0 - float4(radius, float3(0.0, 0.0, 0.0))));
+    float4 clip1 = mul(ubo.projection, (v0 + float4(radius, float3(0.0, 0.0, 0.0))));
+
+    // Get normalized device coordinates
+    clip0 /= clip0.w;
+    clip1 /= clip1.w;
+
+    // Convert to viewport coordinates
+    clip0.xy *= ubo.viewportDim;
+    clip1.xy *= ubo.viewportDim;
+
+    // Return the tessellation factor based on the screen size
+    // given by the distance of the two edge control points in screen space
+    // and a reference (min.) tessellation size for the edge set by the application
+    return clamp(distance(clip0, clip1) / ubo.tessellatedEdgeSize * ubo.tessellationFactor, 1.0, 64.0);
+}
+
+// Checks the current's patch visibility against the frustum using a sphere check
+// Sphere radius is given by the patch size
+bool frustumCheck(float4 Pos, float2 inUV)
+{
+    // Fixed radius (increase if patch size is increased in example)
+    const float radius = 8.0f;
+    float4 pos = Pos;
+    pos.y -= samplerHeight.SampleLevel(inUV, 0.0).r * ubo.displacementFactor;
+
+    // Check sphere against frustum planes
+    for (int i = 0; i < 6; i++) {
+        if (dot(pos, ubo.frustumPlanes[i]) + radius < 0.0)
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+ConstantsHSOutput ConstantsHS(InputPatch<VSOutput, 4> patch)
+{
+    ConstantsHSOutput output;
+
+    if (!frustumCheck(patch[0].Pos, patch[0].UV))
+    {
+        output.TessLevelInner[0] = 0.0;
+        output.TessLevelInner[1] = 0.0;
+        output.TessLevelOuter[0] = 0.0;
+        output.TessLevelOuter[1] = 0.0;
+        output.TessLevelOuter[2] = 0.0;
+        output.TessLevelOuter[3] = 0.0;
+    }
+    else
+    {
+        if (ubo.tessellationFactor > 0.0)
+        {
+            output.TessLevelOuter[0] = screenSpaceTessFactor(patch[3].Pos, patch[0].Pos);
+            output.TessLevelOuter[1] = screenSpaceTessFactor(patch[0].Pos, patch[1].Pos);
+            output.TessLevelOuter[2] = screenSpaceTessFactor(patch[1].Pos, patch[2].Pos);
+            output.TessLevelOuter[3] = screenSpaceTessFactor(patch[2].Pos, patch[3].Pos);
+            output.TessLevelInner[0] = lerp(output.TessLevelOuter[0], output.TessLevelOuter[3], 0.5);
+            output.TessLevelInner[1] = lerp(output.TessLevelOuter[2], output.TessLevelOuter[1], 0.5);
+        }
+        else
+        {
+            // Tessellation factor can be set to zero by example
+            // to demonstrate a simple passthrough
+            output.TessLevelInner[0] = 1.0;
+            output.TessLevelInner[1] = 1.0;
+            output.TessLevelOuter[0] = 1.0;
+            output.TessLevelOuter[1] = 1.0;
+            output.TessLevelOuter[2] = 1.0;
+            output.TessLevelOuter[3] = 1.0;
+        }
+    }
+
+    return output;
+}
+
+float3 sampleTerrainLayer(float2 inUV)
+{
+	// Define some layer ranges for sampling depending on terrain height
+	float2 layers[6];
+	layers[0] = float2(-10.0, 10.0);
+	layers[1] = float2(5.0, 45.0);
+	layers[2] = float2(45.0, 80.0);
+	layers[3] = float2(75.0, 100.0);
+	layers[4] = float2(95.0, 140.0);
+	layers[5] = float2(140.0, 190.0);
+
+	float3 color = float3(0.0, 0.0, 0.0);
+
+    // Get height from displacement map
+    float height = samplerHeight.SampleLevel(inUV, 0.0).r * 255.0;
+
+	for (int i = 0; i < 6; i++)
+	{
+		float range = layers[i].y - layers[i].x;
+		float weight = (range - abs(height - layers[i].y)) / range;
+        weight = max(0.0, weight);
+        color += weight * samplerLayers.Sample(float3(inUV * 16.0, i)).rgb;
+	}
+
+	return color;
+}
+
+float fog(float density, float4 FragCoord)
+{
+	const float LOG2 = -1.442695;
+	float dist = FragCoord.z / FragCoord.w * 0.1;
+	float d = density * dist;
+	return 1.0 - clamp(exp2(d * d * LOG2), 0.0, 1.0);
+}
+
+[shader("vertex")]
+VSOutput vertexMain(VSInput input)
+{
+    VSOutput output;
+    output.Pos = float4(input.Pos.xyz, 1.0);
+    output.UV = input.UV;
+    output.Normal = input.Normal;
+    return output;
+}
+
+[shader("hull")]
+[domain("quad")]
+[partitioning("integer")]
+[outputtopology("triangle_cw")]
+[outputcontrolpoints(4)]
+[patchconstantfunc("ConstantsHS")]
+[maxtessfactor(20.0f)]
+HSOutput hullMain(InputPatch<VSOutput, 4> patch, uint InvocationID: SV_OutputControlPointID)
+{
+    HSOutput output;
+    output.Pos = patch[InvocationID].Pos;
+    output.Normal = patch[InvocationID].Normal;
+    output.UV = patch[InvocationID].UV;
+    return output;
+}
+
+[shader("domain")]
+[domain("quad")]
+DSOutput domainMain(ConstantsHSOutput input, float2 TessCoord: SV_DomainLocation, const OutputPatch<HSOutput, 4> patch)
+{
+    // Interpolate UV coordinates
+    DSOutput output;
+    float2 uv1 = lerp(patch[0].UV, patch[1].UV, TessCoord.x);
+    float2 uv2 = lerp(patch[3].UV, patch[2].UV, TessCoord.x);
+    output.UV = lerp(uv1, uv2, TessCoord.y);
+
+    float3 n1 = lerp(patch[0].Normal, patch[1].Normal, TessCoord.x);
+    float3 n2 = lerp(patch[3].Normal, patch[2].Normal, TessCoord.x);
+    output.Normal = lerp(n1, n2, TessCoord.y);
+
+    // Interpolate positions
+    float4 pos1 = lerp(patch[0].Pos, patch[1].Pos, TessCoord.x);
+    float4 pos2 = lerp(patch[3].Pos, patch[2].Pos, TessCoord.x);
+    float4 pos = lerp(pos1, pos2, TessCoord.y);
+    // Displace
+    pos.y -= samplerHeight.SampleLevel(output.UV, 0.0).r * ubo.displacementFactor;
+    // Perspective projection
+    output.Pos = mul(ubo.projection, mul(ubo.modelview, pos));
+
+    // Calculate vectors for lighting based on tessellated position
+    output.ViewVec = -pos.xyz;
+    output.LightVec = normalize(ubo.lightPos.xyz + output.ViewVec);
+    output.WorldPos = pos.xyz;
+    output.EyePos = mul(ubo.modelview, pos).xyz;
+    return output;
+}
+
+[shader("fragment")]
+float4 fragmentMain(DSOutput input)
+{
+	float3 N = normalize(input.Normal);
+	float3 L = normalize(input.LightVec);
+	float3 ambient = float3(0.5, 0.5, 0.5);
+	float3 diffuse = max(dot(N, L), 0.0) * float3(1.0, 1.0, 1.0);
+	float4 color = float4((ambient + diffuse) * sampleTerrainLayer(input.UV), 1.0);
+	const float4 fogColor = float4(0.47, 0.5, 0.67, 0.0);
+	return lerp(color, fogColor, fog(0.25, input.Pos));
+}

shaders/slang/tessellation/base.slang

@@ -0,0 +1,46 @@
+/* Copyright (c) 2025, Sascha Willems
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+struct VSInput
+{
+    float3 Pos;
+    float3 Normal;
+    float2 UV;
+};
+
+struct VSOutput
+{
+    float4 Pos : SV_POSITION;
+    float3 Normal;
+    float2 UV;
+};
+
+struct DSOutput
+{
+	float3 Normal;
+	float2 UV;
+};
+
+[[vk::binding(0, 1)]] Sampler2D samplerColorMap;
+
+[shader("vertex")]
+VSOutput vertexMain(VSInput input)
+{
+    VSOutput output;
+    output.Pos = float4(input.Pos.xyz, 1.0);
+    output.Normal = input.Normal;
+    output.UV = input.UV;
+    return output;
+}
+
+[shader("fragment")]
+float4 fragmentMain(DSOutput input)
+{
+	float3 N = normalize(input.Normal);
+    float3 L = normalize(float3(0.0, -4.0, 4.0));
+    float4 color = samplerColorMap.Sample(input.UV);
+	return float4(clamp(max(dot(N,L), 0.0), 0.2, 1.0) * color.rgb * 1.5, 1);
+}