HLSL: Add SampleCmp and SampleCmpLevelZero texture methods

Test/hlsl.load.dx10.frag

+SamplerState       g_sSamp : register(s0);
+
+uniform Texture1D <float4> g_tTex1df4 : register(t0);
+Texture1D <int4>   g_tTex1di4;
+Texture1D <uint4>  g_tTex1du4;
+
+Texture2D <float4> g_tTex2df4;
+Texture2D <int4>   g_tTex2di4;
+Texture2D <uint4>  g_tTex2du4;
+
+Texture3D <float4> g_tTex3df4;
+Texture3D <int4>   g_tTex3di4;
+Texture3D <uint4>  g_tTex3du4;
+
+TextureCube <float4> g_tTexcdf4;
+TextureCube <int4>   g_tTexcdi4;
+TextureCube <uint4>  g_tTexcdu4;
+
+Texture1DArray <float4> g_tTex1df4a;
+Texture1DArray <int4>   g_tTex1di4a;
+Texture1DArray <uint4>  g_tTex1du4a;
+
+Texture2DArray <float4> g_tTex2df4a;
+Texture2DArray <int4>   g_tTex2di4a;
+Texture2DArray <uint4>  g_tTex2du4a;
+
+TextureCubeArray <float4> g_tTexcdf4a;
+TextureCubeArray <int4>   g_tTexcdi4a;
+TextureCubeArray <uint4>  g_tTexcdu4a;
+
+struct PS_OUTPUT
+{
+    float4 Color : SV_Target0;
+    float  Depth : SV_Depth;
+};
+
+PS_OUTPUT main()
+{
+   PS_OUTPUT psout;
+
+   // Load, no offset
+   g_tTex1df4.Load(int2(1,2));
+   g_tTex1di4.Load(int2(1,2));
+   g_tTex1du4.Load(int2(1,2));
+
+   g_tTex2df4.Load(int3(1,2,3));
+   g_tTex2di4.Load(int3(1,2,3));
+   g_tTex2du4.Load(int3(1,2,3));
+
+   g_tTex3df4.Load(int4(1,2,3,4));
+   g_tTex3di4.Load(int4(1,2,3,4));
+   g_tTex3du4.Load(int4(1,2,3,4));
+
+   g_tTex1df4a.Load(int3(1,2,3));
+   g_tTex1di4a.Load(int3(1,2,3));
+   g_tTex1du4a.Load(int3(1,2,3));
+
+   g_tTex2df4a.Load(int4(1,2,3,4));
+   g_tTex2di4a.Load(int4(1,2,3,4));
+   g_tTex2du4a.Load(int4(1,2,3,4));
+
+   // Load, offset
+   g_tTex1df4.Load(int2(1,2), 3);
+   g_tTex1di4.Load(int2(1,2), 3);
+   g_tTex1du4.Load(int2(1,2), 3);
+
+   g_tTex2df4.Load(int3(1,2,3), int2(4,5));
+   g_tTex2di4.Load(int3(1,2,3), int2(4,5));
+   g_tTex2du4.Load(int3(1,2,3), int2(4,5));
+
+   g_tTex3df4.Load(int4(1,2,3,4), int3(5,6,7));
+   g_tTex3di4.Load(int4(1,2,3,4), int3(5,6,7));
+   g_tTex3du4.Load(int4(1,2,3,4), int3(5,6,7));
+
+   g_tTex1df4a.Load(int3(1,2,3), 4);
+   g_tTex1di4a.Load(int3(1,2,3), 4);
+   g_tTex1du4a.Load(int3(1,2,3), 4);
+
+   g_tTex2df4a.Load(int4(1,2,3,4), int2(4,5));
+   g_tTex2di4a.Load(int4(1,2,3,4), int2(4,5));
+   g_tTex2du4a.Load(int4(1,2,3,4), int2(4,5));
+
+   // TODO:
+   // Load, SampleIndex
+   // Load, SampleIndex, Offset
+
+   psout.Color = 1.0;
+   psout.Depth = 1.0;
+
+   return psout;
+}

Test/hlsl.samplecmp.array.dx10.frag

+SamplerComparisonState g_sSamp : register(s0);
+
+uniform Texture1D <float4> g_tTex1df4 : register(t0);
+Texture1D <int4>   g_tTex1di4;
+Texture1D <uint4>  g_tTex1du4;
+
+Texture2D <float4> g_tTex2df4;
+Texture2D <int4>   g_tTex2di4;
+Texture2D <uint4>  g_tTex2du4;
+
+Texture3D <float4> g_tTex3df4;
+Texture3D <int4>   g_tTex3di4;
+Texture3D <uint4>  g_tTex3du4;
+
+TextureCube <float4> g_tTexcdf4;
+TextureCube <int4>   g_tTexcdi4;
+TextureCube <uint4>  g_tTexcdu4;
+
+Texture1DArray <float4> g_tTex1df4a;
+Texture1DArray <int4>   g_tTex1di4a;
+Texture1DArray <uint4>  g_tTex1du4a;
+
+Texture2DArray <float4> g_tTex2df4a;
+Texture2DArray <int4>   g_tTex2di4a;
+Texture2DArray <uint4>  g_tTex2du4a;
+
+TextureCubeArray <float4> g_tTexcdf4a;
+TextureCubeArray <int4>   g_tTexcdi4a;
+TextureCubeArray <uint4>  g_tTexcdu4a;
+
+struct PS_OUTPUT
+{
+    float4 Color : SV_Target0;
+    float  Depth : SV_Depth;
+};
+
+PS_OUTPUT main()
+{
+   PS_OUTPUT psout;
+
+   // 1DArray
+   float r10 = g_tTex1df4a . SampleCmp(g_sSamp, float2(0.1, 0.2), 0.75);
+   float r12 = g_tTex1di4a . SampleCmp(g_sSamp, float2(0.1, 0.2), 0.75);
+   float r14 = g_tTex1du4a . SampleCmp(g_sSamp, float2(0.1, 0.2), 0.75);
+
+   // 2DArray
+   float r30 = g_tTex2df4a . SampleCmp(g_sSamp, float3(0.1, 0.2, 0.3), 0.75);
+   float r32 = g_tTex2di4a . SampleCmp(g_sSamp, float3(0.1, 0.2, 0.3), 0.75);
+   float r34 = g_tTex2du4a . SampleCmp(g_sSamp, float3(0.1, 0.2, 0.3), 0.75);
+
+   // CubeArray
+   float r60 = g_tTexcdf4a . SampleCmp(g_sSamp, float4(0.1, 0.2, 0.3, 0.4), 0.75);
+   float r62 = g_tTexcdi4a . SampleCmp(g_sSamp, float4(0.1, 0.2, 0.3, 0.4), 0.75);
+   float r64 = g_tTexcdu4a . SampleCmp(g_sSamp, float4(0.1, 0.2, 0.3, 0.4), 0.75);
+
+   psout.Color = 1.0;
+   psout.Depth = 1.0;
+
+   return psout;
+}

Test/hlsl.samplecmp.basic.dx10.frag

+SamplerComparisonState g_sSamp : register(s0);
+
+uniform Texture1D <float4> g_tTex1df4 : register(t0);
+Texture1D <int4>   g_tTex1di4;
+Texture1D <uint4>  g_tTex1du4;
+
+Texture2D <float4> g_tTex2df4;
+Texture2D <int4>   g_tTex2di4;
+Texture2D <uint4>  g_tTex2du4;
+
+Texture3D <float4> g_tTex3df4;
+Texture3D <int4>   g_tTex3di4;
+Texture3D <uint4>  g_tTex3du4;
+
+TextureCube <float4> g_tTexcdf4;
+TextureCube <int4>   g_tTexcdi4;
+TextureCube <uint4>  g_tTexcdu4;
+
+Texture1DArray <float4> g_tTex1df4a;
+Texture1DArray <int4>   g_tTex1di4a;
+Texture1DArray <uint4>  g_tTex1du4a;
+
+Texture2DArray <float4> g_tTex2df4a;
+Texture2DArray <int4>   g_tTex2di4a;
+Texture2DArray <uint4>  g_tTex2du4a;
+
+TextureCubeArray <float4> g_tTexcdf4a;
+TextureCubeArray <int4>   g_tTexcdi4a;
+TextureCubeArray <uint4>  g_tTexcdu4a;
+
+struct PS_OUTPUT
+{
+    float4 Color : SV_Target0;
+    float  Depth : SV_Depth;
+};
+
+PS_OUTPUT main()
+{
+   PS_OUTPUT psout;
+
+   // 1D
+   float r00 = g_tTex1df4 . SampleCmp(g_sSamp, 0.1, 0.75);
+   float r02 = g_tTex1di4 . SampleCmp(g_sSamp, 0.1, 0.75);
+   float r04 = g_tTex1du4 . SampleCmp(g_sSamp, 0.1, 0.75);
+
+   // 2D
+   float r20 = g_tTex2df4 . SampleCmp(g_sSamp, float2(0.1, 0.2), 0.75);
+   float r22 = g_tTex2di4 . SampleCmp(g_sSamp, float2(0.1, 0.2), 0.75);
+   float r24 = g_tTex2du4 . SampleCmp(g_sSamp, float2(0.1, 0.2), 0.75);
+
+   // *** There's no SampleCmp on 3D textures
+
+   float r50 = g_tTexcdf4 . SampleCmp(g_sSamp, float3(0.1, 0.2, 0.3), 0.75);
+   float r52 = g_tTexcdi4 . SampleCmp(g_sSamp, float3(0.1, 0.2, 0.3), 0.75);
+   float r54 = g_tTexcdu4 . SampleCmp(g_sSamp, float3(0.1, 0.2, 0.3), 0.75);
+
+   psout.Color = 1.0;
+   psout.Depth = 1.0;
+
+   return psout;
+}

Test/hlsl.samplecmp.offset.dx10.frag

+SamplerComparisonState g_sSamp : register(s0);
+
+uniform Texture1D <float4> g_tTex1df4 : register(t0);
+Texture1D <int4>   g_tTex1di4;
+Texture1D <uint4>  g_tTex1du4;
+
+Texture2D <float4> g_tTex2df4;
+Texture2D <int4>   g_tTex2di4;
+Texture2D <uint4>  g_tTex2du4;
+
+Texture3D <float4> g_tTex3df4;
+Texture3D <int4>   g_tTex3di4;
+Texture3D <uint4>  g_tTex3du4;
+
+TextureCube <float4> g_tTexcdf4;
+TextureCube <int4>   g_tTexcdi4;
+TextureCube <uint4>  g_tTexcdu4;
+
+Texture1DArray <float4> g_tTex1df4a;
+Texture1DArray <int4>   g_tTex1di4a;
+Texture1DArray <uint4>  g_tTex1du4a;
+
+Texture2DArray <float4> g_tTex2df4a;
+Texture2DArray <int4>   g_tTex2di4a;
+Texture2DArray <uint4>  g_tTex2du4a;
+
+TextureCubeArray <float4> g_tTexcdf4a;
+TextureCubeArray <int4>   g_tTexcdi4a;
+TextureCubeArray <uint4>  g_tTexcdu4a;
+
+struct PS_OUTPUT
+{
+    float4 Color : SV_Target0;
+    float  Depth : SV_Depth;
+};
+
+PS_OUTPUT main()
+{
+   PS_OUTPUT psout;
+
+   // 1D
+   float r01 = g_tTex1df4 . SampleCmp(g_sSamp, 0.1, 0.75, 2);
+   float r03 = g_tTex1di4 . SampleCmp(g_sSamp, 0.1, 0.75, 2);
+   float r05 = g_tTex1du4 . SampleCmp(g_sSamp, 0.1, 0.75, 2);
+
+   // 2D
+   float r21 = g_tTex2df4 . SampleCmp(g_sSamp, float2(0.1, 0.2), 0.75, int2(2,3));
+   float r23 = g_tTex2di4 . SampleCmp(g_sSamp, float2(0.1, 0.2), 0.75, int2(2,3));
+   float r25 = g_tTex2du4 . SampleCmp(g_sSamp, float2(0.1, 0.2), 0.75, int2(2,3));
+
+   // *** There's no SampleCmp on 3D textures
+
+   // This page: https://msdn.microsoft.com/en-us/library/windows/desktop/bb509696(v=vs.85).aspx
+   // claims offset is supported for cube textures, but FXC does not accept it, and that does
+   // not match other methods, so it may be a documentation bug.  Those lines are commented
+   // out below.
+   // Cube
+   // float r51 = g_tTexcdf4 . SampleCmp(g_sSamp, float3(0.1, 0.2, 0.3), 0.75, int3(2,3,4));
+   // float r53 = g_tTexcdi4 . SampleCmp(g_sSamp, float3(0.1, 0.2, 0.3), 0.75, int3(2,3,4));
+   // float r55 = g_tTexcdu4 . SampleCmp(g_sSamp, float3(0.1, 0.2, 0.3), 0.75, int3(2,3,4));
+
+   psout.Color = 1.0;
+   psout.Depth = 1.0;
+
+   return psout;
+}

Test/hlsl.samplecmp.offsetarray.dx10.frag

+SamplerComparisonState g_sSamp : register(s0);
+
+uniform Texture1D <float4> g_tTex1df4 : register(t0);
+Texture1D <int4>   g_tTex1di4;
+Texture1D <uint4>  g_tTex1du4;
+
+Texture2D <float4> g_tTex2df4;
+Texture2D <int4>   g_tTex2di4;
+Texture2D <uint4>  g_tTex2du4;
+
+Texture3D <float4> g_tTex3df4;
+Texture3D <int4>   g_tTex3di4;
+Texture3D <uint4>  g_tTex3du4;
+
+TextureCube <float4> g_tTexcdf4;
+TextureCube <int4>   g_tTexcdi4;
+TextureCube <uint4>  g_tTexcdu4;
+
+Texture1DArray <float4> g_tTex1df4a;
+Texture1DArray <int4>   g_tTex1di4a;
+Texture1DArray <uint4>  g_tTex1du4a;
+
+Texture2DArray <float4> g_tTex2df4a;
+Texture2DArray <int4>   g_tTex2di4a;
+Texture2DArray <uint4>  g_tTex2du4a;
+
+TextureCubeArray <float4> g_tTexcdf4a;
+TextureCubeArray <int4>   g_tTexcdi4a;
+TextureCubeArray <uint4>  g_tTexcdu4a;
+
+struct PS_OUTPUT
+{
+    float4 Color : SV_Target0;
+    float  Depth : SV_Depth;
+};
+
+PS_OUTPUT main()
+{
+   PS_OUTPUT psout;
+
+   // 1DArray
+   float r11 = g_tTex1df4a . SampleCmp(g_sSamp, float2(0.1, 0.2), 0.75, 2);
+   float r13 = g_tTex1di4a . SampleCmp(g_sSamp, float2(0.1, 0.2), 0.75, 2);
+   float r15 = g_tTex1du4a . SampleCmp(g_sSamp, float2(0.1, 0.2), 0.75, 2);
+
+   // 2DArray
+   float r31 = g_tTex2df4a . SampleCmp(g_sSamp, float3(0.1, 0.2, 0.3), 0.75, int2(2,3));
+   float r33 = g_tTex2di4a . SampleCmp(g_sSamp, float3(0.1, 0.2, 0.3), 0.75, int2(2,3));
+   float r35 = g_tTex2du4a . SampleCmp(g_sSamp, float3(0.1, 0.2, 0.3), 0.75, int2(2,3));
+
+   // *** There's no SampleCmp on 3D textures
+
+   // This page: https://msdn.microsoft.com/en-us/library/windows/desktop/bb509696(v=vs.85).aspx
+   // claims offset is supported for cube textures, but FXC does not accept it, and that does
+   // not match other methods, so it may be a documentation bug.  Those lines are commented
+   // out below.
+
+   // CubeArray
+   // float r61 = g_tTexcdf4a . SampleCmp(g_sSamp, float4(0.1, 0.2, 0.3, 0.4), 0.75, int3(2,3,4));
+   // float r63 = g_tTexcdi4a . SampleCmp(g_sSamp, float4(0.1, 0.2, 0.3, 0.4), 0.75, int3(2,3,4));
+   // float r65 = g_tTexcdu4a . SampleCmp(g_sSamp, float4(0.1, 0.2, 0.3, 0.4), 0.75, int3(2,3,4));
+
+   psout.Color = 1.0;
+   psout.Depth = 1.0;
+
+   return psout;
+}

Test/hlsl.samplecmplevelzero.array.dx10.frag

+SamplerComparisonState g_sSamp : register(s0);
+
+uniform Texture1D <float4> g_tTex1df4 : register(t0);
+Texture1D <int4>   g_tTex1di4;
+Texture1D <uint4>  g_tTex1du4;
+
+Texture2D <float4> g_tTex2df4;
+Texture2D <int4>   g_tTex2di4;
+Texture2D <uint4>  g_tTex2du4;
+
+Texture3D <float4> g_tTex3df4;
+Texture3D <int4>   g_tTex3di4;
+Texture3D <uint4>  g_tTex3du4;
+
+TextureCube <float4> g_tTexcdf4;
+TextureCube <int4>   g_tTexcdi4;
+TextureCube <uint4>  g_tTexcdu4;
+
+Texture1DArray <float4> g_tTex1df4a;
+Texture1DArray <int4>   g_tTex1di4a;
+Texture1DArray <uint4>  g_tTex1du4a;
+
+Texture2DArray <float4> g_tTex2df4a;
+Texture2DArray <int4>   g_tTex2di4a;
+Texture2DArray <uint4>  g_tTex2du4a;
+
+TextureCubeArray <float4> g_tTexcdf4a;
+TextureCubeArray <int4>   g_tTexcdi4a;
+TextureCubeArray <uint4>  g_tTexcdu4a;
+
+struct PS_OUTPUT
+{
+    float4 Color : SV_Target0;
+    float  Depth : SV_Depth;
+};
+
+PS_OUTPUT main()
+{
+   PS_OUTPUT psout;
+
+   // 1DArray
+   float r10 = g_tTex1df4a . SampleCmpLevelZero(g_sSamp, float2(0.1, 0.2), 0.75);
+   float r12 = g_tTex1di4a . SampleCmpLevelZero(g_sSamp, float2(0.1, 0.2), 0.75);
+   float r14 = g_tTex1du4a . SampleCmpLevelZero(g_sSamp, float2(0.1, 0.2), 0.75);
+
+   // 2DArray
+   float r30 = g_tTex2df4a . SampleCmpLevelZero(g_sSamp, float3(0.1, 0.2, 0.3), 0.75);
+   float r32 = g_tTex2di4a . SampleCmpLevelZero(g_sSamp, float3(0.1, 0.2, 0.3), 0.75);
+   float r34 = g_tTex2du4a . SampleCmpLevelZero(g_sSamp, float3(0.1, 0.2, 0.3), 0.75);
+
+   // CubeArray
+   float r60 = g_tTexcdf4a . SampleCmpLevelZero(g_sSamp, float4(0.1, 0.2, 0.3, 0.4), 0.75);
+   float r62 = g_tTexcdi4a . SampleCmpLevelZero(g_sSamp, float4(0.1, 0.2, 0.3, 0.4), 0.75);
+   float r64 = g_tTexcdu4a . SampleCmpLevelZero(g_sSamp, float4(0.1, 0.2, 0.3, 0.4), 0.75);
+
+   psout.Color = 1.0;
+   psout.Depth = 1.0;
+
+   return psout;
+}

Test/hlsl.samplecmplevelzero.basic.dx10.frag

+SamplerComparisonState g_sSamp : register(s0);
+
+uniform Texture1D <float4> g_tTex1df4 : register(t0);
+Texture1D <int4>   g_tTex1di4;
+Texture1D <uint4>  g_tTex1du4;
+
+Texture2D <float4> g_tTex2df4;
+Texture2D <int4>   g_tTex2di4;
+Texture2D <uint4>  g_tTex2du4;
+
+Texture3D <float4> g_tTex3df4;
+Texture3D <int4>   g_tTex3di4;
+Texture3D <uint4>  g_tTex3du4;
+
+TextureCube <float4> g_tTexcdf4;
+TextureCube <int4>   g_tTexcdi4;
+TextureCube <uint4>  g_tTexcdu4;
+
+Texture1DArray <float4> g_tTex1df4a;
+Texture1DArray <int4>   g_tTex1di4a;
+Texture1DArray <uint4>  g_tTex1du4a;
+
+Texture2DArray <float4> g_tTex2df4a;
+Texture2DArray <int4>   g_tTex2di4a;
+Texture2DArray <uint4>  g_tTex2du4a;
+
+TextureCubeArray <float4> g_tTexcdf4a;
+TextureCubeArray <int4>   g_tTexcdi4a;
+TextureCubeArray <uint4>  g_tTexcdu4a;
+
+struct PS_OUTPUT
+{
+    float4 Color : SV_Target0;
+    float  Depth : SV_Depth;
+};
+
+PS_OUTPUT main()
+{
+   PS_OUTPUT psout;
+
+   // 1D
+   float r00 = g_tTex1df4 . SampleCmpLevelZero(g_sSamp, 0.1, 0.75);
+   float r02 = g_tTex1di4 . SampleCmpLevelZero(g_sSamp, 0.1, 0.75);
+   float r04 = g_tTex1du4 . SampleCmpLevelZero(g_sSamp, 0.1, 0.75);
+
+   // 2D
+   float r20 = g_tTex2df4 . SampleCmpLevelZero(g_sSamp, float2(0.1, 0.2), 0.75);
+   float r22 = g_tTex2di4 . SampleCmpLevelZero(g_sSamp, float2(0.1, 0.2), 0.75);
+   float r24 = g_tTex2du4 . SampleCmpLevelZero(g_sSamp, float2(0.1, 0.2), 0.75);
+
+   // *** There's no SampleCmpLevelZero on 3D textures
+
+   float r50 = g_tTexcdf4 . SampleCmpLevelZero(g_sSamp, float3(0.1, 0.2, 0.3), 0.75);
+   float r52 = g_tTexcdi4 . SampleCmpLevelZero(g_sSamp, float3(0.1, 0.2, 0.3), 0.75);
+   float r54 = g_tTexcdu4 . SampleCmpLevelZero(g_sSamp, float3(0.1, 0.2, 0.3), 0.75);
+
+   psout.Color = 1.0;
+   psout.Depth = 1.0;
+
+   return psout;
+}

Test/hlsl.samplecmplevelzero.offset.dx10.frag

+SamplerComparisonState g_sSamp : register(s0);
+
+uniform Texture1D <float4> g_tTex1df4 : register(t0);
+Texture1D <int4>   g_tTex1di4;
+Texture1D <uint4>  g_tTex1du4;
+
+Texture2D <float4> g_tTex2df4;
+Texture2D <int4>   g_tTex2di4;
+Texture2D <uint4>  g_tTex2du4;
+
+Texture3D <float4> g_tTex3df4;
+Texture3D <int4>   g_tTex3di4;
+Texture3D <uint4>  g_tTex3du4;
+
+TextureCube <float4> g_tTexcdf4;
+TextureCube <int4>   g_tTexcdi4;
+TextureCube <uint4>  g_tTexcdu4;
+
+Texture1DArray <float4> g_tTex1df4a;
+Texture1DArray <int4>   g_tTex1di4a;
+Texture1DArray <uint4>  g_tTex1du4a;
+
+Texture2DArray <float4> g_tTex2df4a;
+Texture2DArray <int4>   g_tTex2di4a;
+Texture2DArray <uint4>  g_tTex2du4a;
+
+TextureCubeArray <float4> g_tTexcdf4a;
+TextureCubeArray <int4>   g_tTexcdi4a;
+TextureCubeArray <uint4>  g_tTexcdu4a;
+
+struct PS_OUTPUT
+{
+    float4 Color : SV_Target0;
+    float  Depth : SV_Depth;
+};
+
+PS_OUTPUT main()
+{
+   PS_OUTPUT psout;
+
+   // 1D
+   float r01 = g_tTex1df4 . SampleCmpLevelZero(g_sSamp, 0.1, 0.75, 2);
+   float r03 = g_tTex1di4 . SampleCmpLevelZero(g_sSamp, 0.1, 0.75, 2);
+   float r05 = g_tTex1du4 . SampleCmpLevelZero(g_sSamp, 0.1, 0.75, 2);
+
+   // 2D
+   float r21 = g_tTex2df4 . SampleCmpLevelZero(g_sSamp, float2(0.1, 0.2), 0.75, int2(2,3));
+   float r23 = g_tTex2di4 . SampleCmpLevelZero(g_sSamp, float2(0.1, 0.2), 0.75, int2(2,3));
+   float r25 = g_tTex2du4 . SampleCmpLevelZero(g_sSamp, float2(0.1, 0.2), 0.75, int2(2,3));
+
+   // *** There's no SampleCmpLevelZero on 3D textures
+
+   // This page: https://msdn.microsoft.com/en-us/library/windows/desktop/bb509696(v=vs.85).aspx
+   // claims offset is supported for cube textures, but FXC does not accept it, and that does
+   // not match other methods, so it may be a documentation bug.  Those lines are commented
+   // out below.
+   // Cube
+   // float r51 = g_tTexcdf4 . SampleCmpLevelZero(g_sSamp, float3(0.1, 0.2, 0.3), 0.75, int2(2,3));
+   // float r53 = g_tTexcdi4 . SampleCmpLevelZero(g_sSamp, float3(0.1, 0.2, 0.3), 0.75, int2(2,3));
+   // float r55 = g_tTexcdu4 . SampleCmpLevelZero(g_sSamp, float3(0.1, 0.2, 0.3), 0.75, int2(2,3));
+
+   psout.Color = 1.0;
+   psout.Depth = 1.0;
+
+   return psout;
+}

Test/hlsl.samplecmplevelzero.offsetarray.dx10.frag

+SamplerComparisonState g_sSamp : register(s0);
+
+uniform Texture1D <float4> g_tTex1df4 : register(t0);
+Texture1D <int4>   g_tTex1di4;
+Texture1D <uint4>  g_tTex1du4;
+
+Texture2D <float4> g_tTex2df4;
+Texture2D <int4>   g_tTex2di4;
+Texture2D <uint4>  g_tTex2du4;
+
+Texture3D <float4> g_tTex3df4;
+Texture3D <int4>   g_tTex3di4;
+Texture3D <uint4>  g_tTex3du4;
+
+TextureCube <float4> g_tTexcdf4;
+TextureCube <int4>   g_tTexcdi4;
+TextureCube <uint4>  g_tTexcdu4;
+
+Texture1DArray <float4> g_tTex1df4a;
+Texture1DArray <int4>   g_tTex1di4a;
+Texture1DArray <uint4>  g_tTex1du4a;
+
+Texture2DArray <float4> g_tTex2df4a;
+Texture2DArray <int4>   g_tTex2di4a;
+Texture2DArray <uint4>  g_tTex2du4a;
+
+TextureCubeArray <float4> g_tTexcdf4a;
+TextureCubeArray <int4>   g_tTexcdi4a;
+TextureCubeArray <uint4>  g_tTexcdu4a;
+
+struct PS_OUTPUT
+{
+    float4 Color : SV_Target0;
+    float  Depth : SV_Depth;
+};
+
+PS_OUTPUT main()
+{
+   PS_OUTPUT psout;
+
+   // 1DArray
+   float r11 = g_tTex1df4a . SampleCmpLevelZero(g_sSamp, float2(0.1, 0.2), 0.75, 2);
+   float r13 = g_tTex1di4a . SampleCmpLevelZero(g_sSamp, float2(0.1, 0.2), 0.75, 2);
+   float r15 = g_tTex1du4a . SampleCmpLevelZero(g_sSamp, float2(0.1, 0.2), 0.75, 2);
+
+   // 2DArray
+   float r31 = g_tTex2df4a . SampleCmpLevelZero(g_sSamp, float3(0.1, 0.2, 0.3), 0.75, int2(2,3));
+   float r33 = g_tTex2di4a . SampleCmpLevelZero(g_sSamp, float3(0.1, 0.2, 0.3), 0.75, int2(2,3));
+   float r35 = g_tTex2du4a . SampleCmpLevelZero(g_sSamp, float3(0.1, 0.2, 0.3), 0.75, int2(2,3));
+
+   // *** There's no SampleCmpLevelZero on 3D textures
+
+   // This page: https://msdn.microsoft.com/en-us/library/windows/desktop/bb509696(v=vs.85).aspx
+   // claims offset is supported for cube textures, but FXC does not accept it, and that does
+   // not match other methods, so it may be a documentation bug.  Those lines are commented
+   // out below.
+
+   // CubeArray
+   // float r61 = g_tTexcdf4a . SampleCmpLevelZero(g_sSamp, float4(0.1, 0.2, 0.3, 0.4), 0.75, int3(2,3,4));
+   // float r63 = g_tTexcdi4a . SampleCmpLevelZero(g_sSamp, float4(0.1, 0.2, 0.3, 0.4), 0.75, int3(2,3,4));
+   // float r65 = g_tTexcdu4a . SampleCmpLevelZero(g_sSamp, float4(0.1, 0.2, 0.3, 0.4), 0.75, int3(2,3,4));
+
+   psout.Color = 1.0;
+   psout.Depth = 1.0;
+
+   return psout;
+}

gtests/Hlsl.FromFile.cpp

@@ -104,6 +104,14 @@ INSTANTIATE_TEST_CASE_P(
         {"hlsl.samplebias.basic.dx10.frag", "main"},
         {"hlsl.samplebias.offset.dx10.frag", "main"},
         {"hlsl.samplebias.offsetarray.dx10.frag", "main"},
+        {"hlsl.samplecmp.array.dx10.frag", "main"},
+        {"hlsl.samplecmp.basic.dx10.frag", "main"},
+        {"hlsl.samplecmp.offset.dx10.frag", "main"},
+        {"hlsl.samplecmp.offsetarray.dx10.frag", "main"},
+        {"hlsl.samplecmplevelzero.array.dx10.frag", "main"},
+        {"hlsl.samplecmplevelzero.basic.dx10.frag", "main"},
+        {"hlsl.samplecmplevelzero.offset.dx10.frag", "main"},
+        {"hlsl.samplecmplevelzero.offsetarray.dx10.frag", "main"},
         {"hlsl.samplegrad.array.dx10.frag", "main"},
         {"hlsl.samplegrad.basic.dx10.frag", "main"},
         {"hlsl.samplegrad.basic.dx10.vert", "main"},

hlsl/hlslGrammar.cpp

@@ -661,8 +661,11 @@ bool HlslGrammar::acceptSamplerType(TType& type)
     // read sampler type
     const EHlslTokenClass samplerType = peek();
 
+    // TODO: for DX9
     // TSamplerDim dim = EsdNone;
 
+    bool isShadow = false;
+
     switch (samplerType) {
     case EHTokSampler:      break;
     case EHTokSampler1d:    /*dim = Esd1D*/; break;
@@ -670,7 +673,7 @@ bool HlslGrammar::acceptSamplerType(TType& type)
     case EHTokSampler3d:    /*dim = Esd3D*/; break;
     case EHTokSamplerCube:  /*dim = EsdCube*/; break;
     case EHTokSamplerState: break;
-    case EHTokSamplerComparisonState: break;
+    case EHTokSamplerComparisonState: isShadow = true; break;
     default:
         return false;  // not a sampler declaration
     }
@@ -678,10 +681,9 @@ bool HlslGrammar::acceptSamplerType(TType& type)
     advanceToken();  // consume the sampler type keyword
 
     TArraySizes* arraySizes = nullptr; // TODO: array
-    bool shadow = false;               // TODO: shadow
 
     TSampler sampler;
-    sampler.setPureSampler(shadow);
+    sampler.setPureSampler(isShadow);
 
     type.shallowCopy(TType(sampler, EvqUniform, arraySizes));
 

hlsl/hlslParseHelper.cpp

@@ -825,6 +825,7 @@ TIntermAggregate* HlslParseContext::handleSamplerTextureCombine(const TSourceLoc
 
     TSampler samplerType = argTex->getType().getSampler();
     samplerType.combined = true;
+    samplerType.shadow   = argSampler->getType().getSampler().shadow;
 
     txcombine->setType(TType(samplerType, EvqTemporary));
     txcombine->setLoc(loc);
@@ -1063,6 +1064,66 @@ void HlslParseContext::decomposeSampleMethods(const TSourceLoc& loc, TIntermType
             break;
         }
 
+    case EOpMethodSampleCmp:  // fall through...
+    case EOpMethodSampleCmpLevelZero:
+        {
+            TIntermTyped* argTex    = argAggregate->getSequence()[0]->getAsTyped();
+            TIntermTyped* argSamp   = argAggregate->getSequence()[1]->getAsTyped();
+            TIntermTyped* argCoord  = argAggregate->getSequence()[2]->getAsTyped();
+            TIntermTyped* argCmpVal = argAggregate->getSequence()[3]->getAsTyped();
+            TIntermTyped* argOffset = nullptr;
+
+            // optional offset value
+            if (argAggregate->getSequence().size() > 4)
+                argOffset = argAggregate->getSequence()[4]->getAsTyped();
+            
+            const int coordDimWithCmpVal = argCoord->getType().getVectorSize() + 1; // +1 for cmp
+
+            // AST wants comparison value as one of the texture coordinates
+            TOperator constructOp = EOpNull;
+            switch (coordDimWithCmpVal) {
+            // 1D can't happen: there's always at least 1 coordinate dimension + 1 cmp val
+            case 2: constructOp = EOpConstructVec2;  break;
+            case 3: constructOp = EOpConstructVec3;  break;
+            case 4: constructOp = EOpConstructVec4;  break;
+            case 5: constructOp = EOpConstructVec4;  break; // cubeArrayShadow, cmp value is separate arg.
+            default: assert(0); break;
+            }
+
+            TIntermAggregate* coordWithCmp = new TIntermAggregate(constructOp);
+            coordWithCmp->getSequence().push_back(argCoord);
+            if (coordDimWithCmpVal != 5) // cube array shadow is special.
+                coordWithCmp->getSequence().push_back(argCmpVal);
+            coordWithCmp->setLoc(loc);
+
+            TOperator textureOp = (op == EOpMethodSampleCmpLevelZero ? EOpTextureLod : EOpTexture);
+            if (argOffset != nullptr)
+                textureOp = (op == EOpMethodSampleCmpLevelZero ? EOpTextureLodOffset : EOpTextureOffset);
+
+            // Create combined sampler & texture op
+            TIntermAggregate* txcombine = handleSamplerTextureCombine(loc, argTex, argSamp);
+            TIntermAggregate* txsample = new TIntermAggregate(textureOp);
+            txsample->getSequence().push_back(txcombine);
+            txsample->getSequence().push_back(coordWithCmp);
+
+            if (coordDimWithCmpVal == 5) // cube array shadow is special: cmp val follows coord.
+                txsample->getSequence().push_back(argCmpVal);
+
+            // the LevelZero form uses 0 as an explicit LOD
+            if (op == EOpMethodSampleCmpLevelZero)
+                txsample->getSequence().push_back(intermediate.addConstantUnion(0.0, EbtFloat, loc, true));
+
+            // Add offset if present
+            if (argOffset != nullptr)
+                txsample->getSequence().push_back(argOffset);
+
+            txsample->setType(node->getType());
+            txsample->setLoc(loc);
+            node = txsample;
+
+            break;
+        }
+
     default:
         break; // most pass through unchanged
     }