Moved shaders to new directory

shaders/hlsl/tessellation/base.frag

@@ -0,0 +1,20 @@
+// Copyright 2020 Google LLC
+
+Texture2D textureColorMap : register(t2);
+SamplerState samplerColorMap : register(s2);
+
+struct DSOutput
+{
+[[vk::location(0)]] float3 Normal : NORMAL0;
+[[vk::location(1)]] float2 UV : TEXCOORD0;
+};
+
+float4 main(DSOutput input) : SV_TARGET
+{
+	float3 N = normalize(input.Normal);
+	float3 L = normalize(float3(0.0, -4.0, 4.0));
+
+	float4 color = textureColorMap.Sample(samplerColorMap, input.UV);
+
+	return float4(clamp(max(dot(N,L), 0.0), 0.2, 1.0) * color.rgb * 1.5, 1);
+}

shaders/hlsl/tessellation/base.vert

@@ -0,0 +1,24 @@
+// Copyright 2020 Google LLC
+
+struct VSInput
+{
+[[vk::location(0)]] float3 Pos : POSITION0;
+[[vk::location(1)]] float3 Normal : NORMAL0;
+[[vk::location(2)]] float2 UV : TEXCOORD0;
+};
+
+struct VSOutput
+{
+	float4 Pos : SV_POSITION;
+[[vk::location(0)]] float3 Normal : NORMAL0;
+[[vk::location(1)]] float2 UV : TEXCOORD0;
+};
+
+VSOutput main(VSInput input)
+{
+	VSOutput output = (VSOutput)0;
+	output.Pos = float4(input.Pos.xyz, 1.0);
+	output.Normal = input.Normal;
+	output.UV = input.UV;
+	return output;
+}

shaders/hlsl/tessellation/passthrough.tesc

@@ -0,0 +1,46 @@
+// Copyright 2020 Google LLC
+
+struct VSOutput
+{
+    float4 Pos : SV_POSITION;
+[[vk::location(0)]] float3 Normal : NORMAL0;
+[[vk::location(1)]] float2 UV : TEXCOORD0;
+};
+
+struct HSOutput
+{
+    float4 Pos : SV_POSITION;
+[[vk::location(0)]] float3 Normal : NORMAL0;
+[[vk::location(1)]] float2 UV : TEXCOORD0;
+};
+
+struct ConstantsHSOutput
+{
+    float TessLevelOuter[3] : SV_TessFactor;
+    float TessLevelInner : SV_InsideTessFactor;
+};
+
+ConstantsHSOutput ConstantsHS(InputPatch<VSOutput, 3> patch, uint InvocationID : SV_PrimitiveID)
+{
+    ConstantsHSOutput output = (ConstantsHSOutput)0;
+    output.TessLevelInner = 1;
+    output.TessLevelOuter[0] = 1;
+    output.TessLevelOuter[1] = 1;
+    output.TessLevelOuter[2] = 1;
+    return output;
+}
+
+[domain("tri")]
+[partitioning("integer")]
+[outputtopology("triangle_ccw")]
+[outputcontrolpoints(3)]
+[patchconstantfunc("ConstantsHS")]
+[maxtessfactor(20.0f)]
+HSOutput main(InputPatch<VSOutput, 3> patch, uint InvocationID : SV_OutputControlPointID)
+{
+    HSOutput output = (HSOutput)0;
+    output.Pos = patch[InvocationID].Pos;
+	output.Normal = patch[InvocationID].Normal;
+	output.UV = patch[InvocationID].UV;
+    return output;
+}

shaders/hlsl/tessellation/passthrough.tese

@@ -0,0 +1,44 @@
+// Copyright 2020 Google LLC
+
+struct UBO
+{
+	float4x4 projection;
+	float4x4 model;
+	float tessAlpha;
+};
+
+cbuffer ubo : register(b1) { UBO ubo; }
+
+struct HSOutput
+{
+	float4 Pos : SV_POSITION;
+[[vk::location(0)]] float3 Normal : NORMAL0;
+[[vk::location(1)]] float2 UV : TEXCOORD0;
+};
+
+struct ConstantsHSOutput
+{
+    float TessLevelOuter[3] : SV_TessFactor;
+    float TessLevelInner : SV_InsideTessFactor;
+};
+
+struct DSOutput
+{
+	float4 Pos : SV_POSITION;
+[[vk::location(0)]] float3 Normal : NORMAL0;
+[[vk::location(1)]] float2 UV : TEXCOORD0;
+};
+
+[domain("tri")]
+DSOutput main(ConstantsHSOutput input, float3 TessCoord : SV_DomainLocation, const OutputPatch<HSOutput, 3> patch)
+{
+	DSOutput output = (DSOutput)0;
+    output.Pos = (TessCoord.x * patch[0].Pos) +
+                  (TessCoord.y * patch[1].Pos) +
+                  (TessCoord.z * patch[2].Pos);
+	output.Pos = mul(ubo.projection, mul(ubo.model, output.Pos));
+
+	output.Normal = TessCoord.x*patch[0].Normal + TessCoord.y*patch[1].Normal + TessCoord.z*patch[2].Normal;
+	output.UV = TessCoord.x*patch[0].UV + TessCoord.y*patch[1].UV + TessCoord.z*patch[2].UV;
+	return output;
+}

shaders/hlsl/tessellation/pntriangles.tesc

@@ -0,0 +1,128 @@
+// Copyright 2020 Google LLC
+
+// PN patch data
+struct PnPatch
+{
+	float b210;
+	float b120;
+	float b021;
+	float b012;
+	float b102;
+	float b201;
+	float b111;
+	float n110;
+	float n011;
+	float n101;
+};
+
+// tessellation levels
+struct UBO
+{
+	float tessLevel;
+};
+
+cbuffer ubo : register(b0) { UBO ubo; }
+
+struct VSOutput
+{
+	float4 Pos : SV_POSITION;
+[[vk::location(0)]] float3 Normal : NORMAL0;
+[[vk::location(1)]] float2 UV : TEXCOORD0;
+};
+
+struct HSOutput
+{
+	float4 Pos : SV_POSITION;
+[[vk::location(0)]] float3 Normal : NORMAL0;
+[[vk::location(3)]] float2 UV : TEXCOORD0;
+[[vk::location(6)]]	float pnPatch[10] : TEXCOORD6;
+};
+
+struct ConstantsHSOutput
+{
+    float TessLevelOuter[3] : SV_TessFactor;
+    float TessLevelInner : SV_InsideTessFactor;
+};
+
+void SetPnPatch(out float output[10], PnPatch patch)
+{
+	output[0] = patch.b210;
+	output[1] = patch.b120;
+	output[2] = patch.b021;
+	output[3] = patch.b012;
+	output[4] = patch.b102;
+	output[5] = patch.b201;
+	output[6] = patch.b111;
+	output[7] = patch.n110;
+	output[8] = patch.n011;
+	output[9] = patch.n101;
+}
+
+float wij(float4 iPos, float3 iNormal, float4 jPos)
+{
+	return dot(jPos.xyz - iPos.xyz, iNormal);
+}
+
+float vij(float4 iPos, float3 iNormal, float4 jPos, float3 jNormal)
+{
+	float3 Pj_minus_Pi = jPos.xyz
+					- iPos.xyz;
+	float3 Ni_plus_Nj  = iNormal+jNormal;
+	return 2.0*dot(Pj_minus_Pi, Ni_plus_Nj)/dot(Pj_minus_Pi, Pj_minus_Pi);
+}
+
+ConstantsHSOutput ConstantsHS(InputPatch<VSOutput, 3> patch, uint InvocationID : SV_PrimitiveID)
+{
+    ConstantsHSOutput output = (ConstantsHSOutput)0;
+	output.TessLevelOuter[0] = ubo.tessLevel;
+	output.TessLevelOuter[1] = ubo.tessLevel;
+	output.TessLevelOuter[2] = ubo.tessLevel;
+	output.TessLevelInner = ubo.tessLevel;
+    return output;
+}
+
+[domain("tri")]
+[partitioning("fractional_odd")]
+[outputtopology("triangle_ccw")]
+[outputcontrolpoints(3)]
+[patchconstantfunc("ConstantsHS")]
+[maxtessfactor(20.0f)]
+HSOutput main(InputPatch<VSOutput, 3> patch, uint InvocationID : SV_OutputControlPointID)
+{
+	HSOutput output = (HSOutput)0;
+	// get data
+	output.Pos = patch[InvocationID].Pos;
+	output.Normal = patch[InvocationID].Normal;
+	output.UV = patch[InvocationID].UV;
+
+	// set base
+	float P0 = patch[0].Pos[InvocationID];
+	float P1 = patch[1].Pos[InvocationID];
+	float P2 = patch[2].Pos[InvocationID];
+	float N0 = patch[0].Normal[InvocationID];
+	float N1 = patch[1].Normal[InvocationID];
+	float N2 = patch[2].Normal[InvocationID];
+
+	// compute control points
+	PnPatch pnPatch;
+	pnPatch.b210 = (2.0*P0 + P1 - wij(patch[0].Pos, patch[0].Normal, patch[1].Pos)*N0)/3.0;
+	pnPatch.b120 = (2.0*P1 + P0 - wij(patch[1].Pos, patch[1].Normal, patch[0].Pos)*N1)/3.0;
+	pnPatch.b021 = (2.0*P1 + P2 - wij(patch[1].Pos, patch[1].Normal, patch[2].Pos)*N1)/3.0;
+	pnPatch.b012 = (2.0*P2 + P1 - wij(patch[2].Pos, patch[2].Normal, patch[1].Pos)*N2)/3.0;
+	pnPatch.b102 = (2.0*P2 + P0 - wij(patch[2].Pos, patch[2].Normal, patch[0].Pos)*N2)/3.0;
+	pnPatch.b201 = (2.0*P0 + P2 - wij(patch[0].Pos, patch[0].Normal, patch[2].Pos)*N0)/3.0;
+	float E = ( pnPatch.b210
+			+ pnPatch.b120
+			+ pnPatch.b021
+			+ pnPatch.b012
+			+ pnPatch.b102
+			+ pnPatch.b201 ) / 6.0;
+	float V = (P0 + P1 + P2)/3.0;
+	pnPatch.b111 = E + (E - V)*0.5;
+	pnPatch.n110 = N0+N1-vij(patch[0].Pos, patch[0].Normal, patch[1].Pos, patch[1].Normal)*(P1-P0);
+	pnPatch.n011 = N1+N2-vij(patch[1].Pos, patch[1].Normal, patch[2].Pos, patch[2].Normal)*(P2-P1);
+	pnPatch.n101 = N2+N0-vij(patch[2].Pos, patch[2].Normal, patch[0].Pos, patch[0].Normal)*(P0-P2);
+	SetPnPatch(output.pnPatch, pnPatch);
+
+	return output;
+}

shaders/hlsl/tessellation/pntriangles.tese

@@ -0,0 +1,126 @@
+// Copyright 2020 Google LLC
+
+// PN patch data
+struct PnPatch
+{
+ float b210;
+ float b120;
+ float b021;
+ float b012;
+ float b102;
+ float b201;
+ float b111;
+ float n110;
+ float n011;
+ float n101;
+};
+
+struct UBO
+{
+    float4x4 projection;
+    float4x4 model;
+    float tessAlpha;
+};
+
+cbuffer ubo : register(b1) { UBO ubo; }
+
+struct HSOutput
+{
+	float4 Pos : SV_POSITION;
+[[vk::location(0)]] float3 Normal : NORMAL0;
+[[vk::location(3)]] float2 UV : TEXCOORD0;
+[[vk::location(6)]] float pnPatch[10] : TEXCOORD6;
+};
+
+struct ConstantsHSOutput
+{
+    float TessLevelOuter[3] : SV_TessFactor;
+    float TessLevelInner : SV_InsideTessFactor;
+};
+
+struct DSOutput
+{
+	float4 Pos : SV_POSITION;
+[[vk::location(0)]] float3 Normal : NORMAL0;
+[[vk::location(1)]] float2 UV : TEXCOORD0;
+};
+
+#define uvw TessCoord
+
+PnPatch GetPnPatch(float pnPatch[10])
+{
+    PnPatch output;
+    output.b210 = pnPatch[0];
+	output.b120 = pnPatch[1];
+	output.b021 = pnPatch[2];
+	output.b012 = pnPatch[3];
+	output.b102 = pnPatch[4];
+	output.b201 = pnPatch[5];
+	output.b111 = pnPatch[6];
+	output.n110 = pnPatch[7];
+	output.n011 = pnPatch[8];
+	output.n101 = pnPatch[9];
+    return output;
+}
+
+[domain("tri")]
+DSOutput main(ConstantsHSOutput input, float3 TessCoord : SV_DomainLocation, const OutputPatch<HSOutput, 3> patch)
+{
+    PnPatch pnPatch[3];
+    pnPatch[0] = GetPnPatch(patch[0].pnPatch);
+    pnPatch[1] = GetPnPatch(patch[1].pnPatch);
+    pnPatch[2] = GetPnPatch(patch[2].pnPatch);
+
+    DSOutput output = (DSOutput)0;
+    float3 uvwSquared = uvw * uvw;
+    float3 uvwCubed   = uvwSquared * uvw;
+
+    // extract control points
+    float3 b210 = float3(pnPatch[0].b210, pnPatch[1].b210, pnPatch[2].b210);
+    float3 b120 = float3(pnPatch[0].b120, pnPatch[1].b120, pnPatch[2].b120);
+    float3 b021 = float3(pnPatch[0].b021, pnPatch[1].b021, pnPatch[2].b021);
+    float3 b012 = float3(pnPatch[0].b012, pnPatch[1].b012, pnPatch[2].b012);
+    float3 b102 = float3(pnPatch[0].b102, pnPatch[1].b102, pnPatch[2].b102);
+    float3 b201 = float3(pnPatch[0].b201, pnPatch[1].b201, pnPatch[2].b201);
+    float3 b111 = float3(pnPatch[0].b111, pnPatch[1].b111, pnPatch[2].b111);
+
+    // extract control normals
+    float3 n110 = normalize(float3(pnPatch[0].n110, pnPatch[1].n110, pnPatch[2].n110));
+    float3 n011 = normalize(float3(pnPatch[0].n011, pnPatch[1].n011, pnPatch[2].n011));
+    float3 n101 = normalize(float3(pnPatch[0].n101, pnPatch[1].n101, pnPatch[2].n101));
+
+    // compute texcoords
+    output.UV  = TessCoord[2]*patch[0].UV + TessCoord[0]*patch[1].UV + TessCoord[1]*patch[2].UV;
+
+    // normal
+    // Barycentric normal
+    float3 barNormal = TessCoord[2]*patch[0].Normal + TessCoord[0]*patch[1].Normal + TessCoord[1]*patch[2].Normal;
+    float3 pnNormal  = patch[0].Normal*uvwSquared[2] + patch[1].Normal*uvwSquared[0] + patch[2].Normal*uvwSquared[1]
+                   + n110*uvw[2]*uvw[0] + n011*uvw[0]*uvw[1]+ n101*uvw[2]*uvw[1];
+    output.Normal = ubo.tessAlpha*pnNormal + (1.0-ubo.tessAlpha) * barNormal;
+
+    // compute interpolated pos
+    float3 barPos = TessCoord[2]*patch[0].Pos.xyz
+                + TessCoord[0]*patch[1].Pos.xyz
+                + TessCoord[1]*patch[2].Pos.xyz;
+
+    // save some computations
+    uvwSquared *= 3.0;
+
+    // compute PN position
+    float3 pnPos  = patch[0].Pos.xyz*uvwCubed[2]
+                + patch[1].Pos.xyz*uvwCubed[0]
+                + patch[2].Pos.xyz*uvwCubed[1]
+                + b210*uvwSquared[2]*uvw[0]
+                + b120*uvwSquared[0]*uvw[2]
+                + b201*uvwSquared[2]*uvw[1]
+                + b021*uvwSquared[0]*uvw[1]
+                + b102*uvwSquared[1]*uvw[2]
+                + b012*uvwSquared[1]*uvw[0]
+                + b111*6.0*uvw[0]*uvw[1]*uvw[2];
+
+    // final position and normal
+    float3 finalPos = (1.0-ubo.tessAlpha)*barPos + ubo.tessAlpha*pnPos;
+    output.Pos = mul(ubo.projection, mul(ubo.model, float4(finalPos,1.0)));
+    return output;
+}