MSL Shader Generation

Signed-off-by: Isaac Marovitz <[email protected]>

Author: IsaacMarovitz

XenosRecomp/CMakeLists.txt

@@ -4,6 +4,10 @@ if (WIN32)
     option(XENOS_RECOMP_DXIL "Generate DXIL shader cache" ON)
 endif()
 
+if (APPLE)
+    option(XENOS_RECOMP_AIR "Generate Metal AIR shader cache" ON)
+endif()
+
 set(SMOLV_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../thirdparty/smol-v/source")
 
 add_executable(XenosRecomp 
@@ -51,3 +55,7 @@ if (XENOS_RECOMP_DXIL)
     target_compile_definitions(XenosRecomp PRIVATE XENOS_RECOMP_DXIL)
     target_link_libraries(XenosRecomp PRIVATE Microsoft::DXIL)
 endif()
+
+if (XENOS_RECOMP_AIR)
+    target_compile_definitions(XenosRecomp PRIVATE XENOS_RECOMP_AIR)
+endif()

XenosRecomp/dxc_compiler.cpp

@@ -34,6 +34,11 @@ IDxcBlob* DxcCompiler::compile(const std::string& shaderSource, bool compilePixe
             target = L"-T vs_6_0";
     }
 
+    if (!compileLibrary)
+    {
+        args[argCount++] = L"-E shaderMain";
+    }
+
     args[argCount++] = target;
     args[argCount++] = L"-HV 2021";
     args[argCount++] = L"-all-resources-bound";

XenosRecomp/shader_common.h

@@ -10,10 +10,12 @@
     #define SPEC_CONSTANT_REVERSE_Z         (1 << 4)
 #endif
 
-#if !defined(__cplusplus) || defined(__INTELLISENSE__)
+#if defined(__air__) || !defined(__cplusplus) || defined(__INTELLISENSE__)
 
+#ifndef __air__
 #define FLT_MIN asfloat(0xff7fffff)
 #define FLT_MAX asfloat(0x7f7fffff)
+#endif
 
 #ifdef __spirv__
 
@@ -34,6 +36,30 @@ struct PushConstants
 
 #define g_SpecConstants() g_SpecConstants
 
+#elif __air__
+
+#include <metal_stdlib>
+
+using namespace metal;
+
+constant uint G_SPEC_CONSTANT [[function_constant(0)]];
+
+uint g_SpecConstants()
+{
+    return G_SPEC_CONSTANT;
+}
+
+struct PushConstants
+{
+    ulong VertexShaderConstants;
+    ulong PixelShaderConstants;
+    ulong SharedConstants;
+};
+
+#define g_Booleans (*(reinterpret_cast<device uint*>(g_PushConstants.SharedConstants + 256)))
+#define g_SwappedTexcoords (*(reinterpret_cast<device uint*>(g_PushConstants.SharedConstants + 260)))
+#define g_AlphaThreshold (*(reinterpret_cast<device float*>(g_PushConstants.SharedConstants + 264)))
+
 #else
 
 #define DEFINE_SHARED_CONSTANTS() \
@@ -45,6 +71,56 @@ uint g_SpecConstants();
 
 #endif
 
+#ifdef __air__
+
+struct Texture2DDescriptorHeap
+{
+    array<texture2d<float>, 1> g [[id(0)]];
+};
+
+struct Texture3DDescriptorHeap
+{
+    array<texture3d<float>, 1> g [[id(0)]];
+};
+
+struct TextureCubeDescriptorHeap
+{
+    array<texturecube<float>, 1> g [[id(0)]];
+};
+
+struct SamplerDescriptorHeap
+{
+    array<sampler, 1> g [[id(0)]];
+};
+
+uint2 getTexture2DDimensions(texture2d<float> texture)
+{
+    return uint2(texture.get_width(), texture.get_height());
+}
+
+float4 tfetch2D(constant Texture2DDescriptorHeap& textureHeap,
+                constant SamplerDescriptorHeap& samplerHeap,
+                uint resourceDescriptorIndex,
+                uint samplerDescriptorIndex,
+                float2 texCoord, float2 offset)
+{
+    texture2d<float> texture = textureHeap.g[resourceDescriptorIndex];
+    sampler sampler = samplerHeap.g[samplerDescriptorIndex];
+    return texture.sample(sampler, texCoord + offset / (float2)getTexture2DDimensions(texture));
+}
+
+float2 getWeights2D(constant Texture2DDescriptorHeap& textureHeap,
+                    constant SamplerDescriptorHeap& samplerHeap,
+                    uint resourceDescriptorIndex,
+                    uint samplerDescriptorIndex,
+                    float2 texCoord, float2 offset)
+{
+    texture2d<float> texture = textureHeap.g[resourceDescriptorIndex];
+    return select(fract(texCoord * (float2)getTexture2DDimensions(texture) + offset - 0.5), 0.0, isnan(texCoord));
+}
+
+#else
+
 Texture2D<float4> g_Texture2DDescriptorHeap[] : register(t0, space0);
 Texture3D<float4> g_Texture3DDescriptorHeap[] : register(t0, space1);
 TextureCube<float4> g_TextureCubeDescriptorHeap[] : register(t0, space2);
@@ -69,6 +145,46 @@ float2 getWeights2D(uint resourceDescriptorIndex, uint samplerDescriptorIndex, f
     return select(isnan(texCoord), 0.0, frac(texCoord * getTexture2DDimensions(texture) + offset - 0.5));
 }
 
+#endif
+
+#ifdef __air__
+#define selectWrapper(a, b, c) select(c, b, a)
+#else
+#define selectWrapper(a, b, c) select(a, b, c)
+#endif
+
+#ifdef __air__
+#define frac(X) fract(X)
+
+template<typename T>
+void clip(T a)
+{
+    if (a < 0.0) {
+        discard_fragment();
+    }
+}
+
+template<typename T>
+float rcp(T a)
+{
+    return 1.0 / a;
+}
+
+template<typename T>
+float4x4 mul(T a, T b)
+{
+    return a * b;
+}
+#endif
+
+#ifdef __air__
+#define UNROLL
+#define BRANCH
+#else
+#define UNROLL [unroll]
+#define BRANCH [branch]
+#endif
+
 float w0(float a)
 {
     return (1.0f / 6.0f) * (a * (a * (-a + 3.0f) - 3.0f) + 1.0f);
@@ -109,6 +225,74 @@ float h1(float a)
     return 1.0f + w3(a) / (w2(a) + w3(a)) + 0.5f;
 }
 
+struct CubeMapData
+{
+    float3 cubeMapDirections[2];
+    uint cubeMapIndex;
+};
+
+#ifdef __air__
+
+float4 tfetch2DBicubic(constant Texture2DDescriptorHeap& textureHeap,
+                       constant SamplerDescriptorHeap& samplerHeap,
+                       uint resourceDescriptorIndex,
+                       uint samplerDescriptorIndex,
+                       float2 texCoord, float2 offset)
+{
+    texture2d<float> texture = textureHeap.g[resourceDescriptorIndex];
+    sampler sampler = samplerHeap.g[samplerDescriptorIndex];
+    uint2 dimensions = getTexture2DDimensions(texture);
+
+    float x = texCoord.x * dimensions.x + offset.x;
+    float y = texCoord.y * dimensions.y + offset.y;
+
+    x -= 0.5f;
+    y -= 0.5f;
+    float px = floor(x);
+    float py = floor(y);
+    float fx = x - px;
+    float fy = y - py;
+
+    float g0x = g0(fx);
+    float g1x = g1(fx);
+    float h0x = h0(fx);
+    float h1x = h1(fx);
+    float h0y = h0(fy);
+    float h1y = h1(fy);
+
+    float4 r =
+        g0(fy) * (g0x * texture.sample(sampler, float2(px + h0x, py + h0y) / float2(dimensions)) +
+              g1x * texture.sample(sampler, float2(px + h1x, py + h0y) / float2(dimensions))) +
+        g1(fy) * (g0x * texture.sample(sampler, float2(px + h0x, py + h1y) / float2(dimensions)) +
+              g1x * texture.sample(sampler, float2(px + h1x, py + h1y) / float2(dimensions)));
+
+    return r;
+}
+
+float4 tfetch3D(constant Texture3DDescriptorHeap& textureHeap,
+                constant SamplerDescriptorHeap& samplerHeap,
+                uint resourceDescriptorIndex,
+                uint samplerDescriptorIndex,
+                float3 texCoord)
+{
+    texture3d<float> texture = textureHeap.g[resourceDescriptorIndex];
+    sampler sampler = samplerHeap.g[samplerDescriptorIndex];
+    return texture.sample(sampler, texCoord);
+}
+
+float4 tfetchCube(constant TextureCubeDescriptorHeap& textureHeap,
+                  constant SamplerDescriptorHeap& samplerHeap,
+                  uint resourceDescriptorIndex,
+                  uint samplerDescriptorIndex,
+                  float3 texCoord, thread CubeMapData* cubeMapData)
+{
+    texturecube<float> texture = textureHeap.g[resourceDescriptorIndex];
+    sampler sampler = samplerHeap.g[samplerDescriptorIndex];
+    return texture.sample(sampler, cubeMapData->cubeMapDirections[(uint)texCoord.z]);
+}
+
+#else
+
 float4 tfetch2DBicubic(uint resourceDescriptorIndex, uint samplerDescriptorIndex, float2 texCoord, float2 offset)
 {
     Texture2D<float4> texture = g_Texture2DDescriptorHeap[resourceDescriptorIndex];
@@ -146,17 +330,13 @@ float4 tfetch3D(uint resourceDescriptorIndex, uint samplerDescriptorIndex, float
     return g_Texture3DDescriptorHeap[resourceDescriptorIndex].Sample(g_SamplerDescriptorHeap[samplerDescriptorIndex], texCoord);
 }
 
-struct CubeMapData
-{
-    float3 cubeMapDirections[2];
-    uint cubeMapIndex;
-};
-
 float4 tfetchCube(uint resourceDescriptorIndex, uint samplerDescriptorIndex, float3 texCoord, inout CubeMapData cubeMapData)
 {
     return g_TextureCubeDescriptorHeap[resourceDescriptorIndex].Sample(g_SamplerDescriptorHeap[samplerDescriptorIndex], cubeMapData.cubeMapDirections[texCoord.z]);
 }
 
+#endif
+
 float4 tfetchR11G11B10(uint4 value)
 {
     if (g_SpecConstants() & SPEC_CONSTANT_R11G11B10_NORMAL)
@@ -169,7 +349,11 @@ float4 tfetchR11G11B10(uint4 value)
     }
     else
     {
+#ifdef __air__
+        return as_type<float4>(value);
+#else
         return asfloat(value);
+#endif
     }
 }
 
@@ -178,6 +362,19 @@ float4 tfetchTexcoord(uint swappedTexcoords, float4 value, uint semanticIndex)
     return (swappedTexcoords & (1ull << semanticIndex)) != 0 ? value.yxwz : value;
 }
 
+#ifdef __air__
+
+float4 cube(float4 value, thread CubeMapData* cubeMapData)
+{
+    uint index = cubeMapData->cubeMapIndex;
+    cubeMapData->cubeMapDirections[index] = value.xyz;
+    ++cubeMapData->cubeMapIndex;
+
+    return float4(0.0, 0.0, 0.0, index);
+}
+
+#else
+
 float4 cube(float4 value, inout CubeMapData cubeMapData)
 {
     uint index = cubeMapData.cubeMapIndex;
@@ -187,6 +384,8 @@ float4 cube(float4 value, inout CubeMapData cubeMapData)
     return float4(0.0, 0.0, 0.0, index);
 }
 
+#endif
+
 float4 dst(float4 src0, float4 src1)
 {
     float4 dest;
@@ -202,15 +401,34 @@ float4 max4(float4 src0)
     return max(max(src0.x, src0.y), max(src0.z, src0.w));
 }
 
+#ifdef __air__
+
+float2 getPixelCoord(constant Texture2DDescriptorHeap& textureHeap,
+                     uint resourceDescriptorIndex,
+                     float2 texCoord)
+{
+    texture2d<float> texture = textureHeap.g[resourceDescriptorIndex];
+    return (float2)getTexture2DDimensions(texture) * texCoord;
+}
+
+#else
+
 float2 getPixelCoord(uint resourceDescriptorIndex, float2 texCoord)
 {
     return getTexture2DDimensions(g_Texture2DDescriptorHeap[resourceDescriptorIndex]) * texCoord;
 }
 
+#endif
+
 float computeMipLevel(float2 pixelCoord)
 {
+#ifdef __air__
+    float2 dx = dfdx(pixelCoord);
+    float2 dy = dfdy(pixelCoord);
+#else
     float2 dx = ddx(pixelCoord);
     float2 dy = ddy(pixelCoord);
+#endif
     float deltaMaxSqr = max(dot(dx, dx), dot(dy, dy));
     return max(0.0, 0.5 * log2(deltaMaxSqr));
 }