metaforce/Runtime/Graphics/Shaders/CModelShadersMetal.cpp

#include "CModelShaders.hpp"

namespace urde {
using namespace std::literals;

extern const hecl::Backend::Function ExtensionLightingFuncsMetal[];
extern const hecl::Backend::Function ExtensionPostFuncsMetal[];

#define FOG_STRUCT_METAL                                                                                               \
  "struct Fog\n"                                                                                                       \
  "{\n"                                                                                                                \
  "    float4 color;\n"                                                                                                \
  "    float A;\n"                                                                                                     \
  "    float B;\n"                                                                                                     \
  "    float C;\n"                                                                                                     \
  "    int mode;\n"                                                                                                    \
  "};\n"

#define FOG_ALGORITHM_METAL                                                                                            \
  "    float fogZ;\n"                                                                                                  \
  "    float fogF = saturate((lu.fog.A / (lu.fog.B - (1.0 - vtf.mvpPos.z))) - lu.fog.C);\n"                            \
  "    switch (lu.fog.mode)\n"                                                                                         \
  "    {\n"                                                                                                            \
  "    case 2:\n"                                                                                                      \
  "        fogZ = fogF;\n"                                                                                             \
  "        break;\n"                                                                                                   \
  "    case 4:\n"                                                                                                      \
  "        fogZ = 1.0 - exp2(-8.0 * fogF);\n"                                                                          \
  "        break;\n"                                                                                                   \
  "    case 5:\n"                                                                                                      \
  "        fogZ = 1.0 - exp2(-8.0 * fogF * fogF);\n"                                                                   \
  "        break;\n"                                                                                                   \
  "    case 6:\n"                                                                                                      \
  "        fogZ = exp2(-8.0 * (1.0 - fogF));\n"                                                                        \
  "        break;\n"                                                                                                   \
  "    case 7:\n"                                                                                                      \
  "        fogF = 1.0 - fogF;\n"                                                                                       \
  "        fogZ = exp2(-8.0 * fogF * fogF);\n"                                                                         \
  "        break;\n"                                                                                                   \
  "    default:\n"                                                                                                     \
  "        fogZ = 0.0;\n"                                                                                              \
  "        break;\n"                                                                                                   \
  "    }\n"                                                                                                            \
  "#ifdef BLEND_DST_ONE\n"                                                                                             \
  "    return float4(mix(colorIn, float4(0.0), saturate(fogZ)).rgb, colorIn.a);\n"                                     \
  "#else\n"                                                                                                            \
  "    return float4(mix(colorIn, lu.fog.color, saturate(fogZ)).rgb, colorIn.a);\n"                                       \
  "#endif\n"

static std::string_view LightingMetal =
"struct Light\n"
"{\n"
"    float4 pos;\n"
"    float4 dir;\n"
"    float4 color;\n"
"    float4 linAtt;\n"
"    float4 angAtt;\n"
"};\n"
FOG_STRUCT_METAL
"\n"
"struct LightingUniform\n"
"{\n"
"    Light lights[" _XSTR(URDE_MAX_LIGHTS) "];\n"
"    float4 ambient;\n"
"    float4 colorReg0;\n"
"    float4 colorReg1;\n"
"    float4 colorReg2;\n"
"    float4 mulColor;\n"
"    float4 addColor;\n"
"    Fog fog;\n"
"};\n"
"\n"
"static float4 LightingFunc(constant LightingUniform& lu, float3 mvPosIn, float3 mvNormIn, thread VertToFrag& vtf)\n"
"{\n"
"    float4 ret = lu.ambient;\n"
"    \n"
"    for (int i=0 ; i<" _XSTR(URDE_MAX_LIGHTS) " ; ++i)\n"
"    {\n"
"        float3 delta = mvPosIn - lu.lights[i].pos.xyz;\n"
"        float dist = length(delta);\n"
"        float angDot = saturate(dot(normalize(delta), lu.lights[i].dir.xyz));\n"
"        float att = 1.0 / (lu.lights[i].linAtt[2] * dist * dist +\n"
"                           lu.lights[i].linAtt[1] * dist +\n"
"                           lu.lights[i].linAtt[0]);\n"
"        float angAtt = lu.lights[i].angAtt[2] * angDot * angDot +\n"
"                       lu.lights[i].angAtt[1] * angDot +\n"
"                       lu.lights[i].angAtt[0];\n"
"        ret += lu.lights[i].color * angAtt * att * saturate(dot(normalize(-delta), mvNormIn));\n"
"    }\n"
"    \n"
"    return saturate(ret);\n"
"}\n"sv;

static std::string_view LightingShadowMetal =
"struct Light\n"
"{\n"
"    float4 pos;\n"
"    float4 dir;\n"
"    float4 color;\n"
"    float4 linAtt;\n"
"    float4 angAtt;\n"
"};\n"
FOG_STRUCT_METAL
"\n"
"struct LightingUniform\n"
"{\n"
"    Light lights[" _XSTR(URDE_MAX_LIGHTS) "];\n"
"    float4 ambient;\n"
"    float4 colorReg0;\n"
"    float4 colorReg1;\n"
"    float4 colorReg2;\n"
"    float4 mulColor;\n"
"    float4 addColor;\n"
"    Fog fog;\n"
"};\n"
"\n"
"static float4 EXTLightingShadowFunc(constant LightingUniform& lu, float3 mvPosIn, float3 mvNormIn,\n"
"                                    thread VertToFrag& vtf, sampler samp, sampler clampSamp, texture2d<float> extTex7)\n"
"{\n"
"    float4 ret = lu.ambient;\n"
"    \n"
"    float3 delta = mvPosIn - lu.lights[0].pos.xyz;\n"
"    float dist = length(delta);\n"
"    float angDot = saturate(dot(normalize(delta), lu.lights[0].dir.xyz));\n"
"    float att = 1.0 / (lu.lights[0].linAtt[2] * dist * dist +\n"
"                       lu.lights[0].linAtt[1] * dist +\n"
"                       lu.lights[0].linAtt[0]);\n"
"    float angAtt = lu.lights[0].angAtt[2] * angDot * angDot +\n"
"                   lu.lights[0].angAtt[1] * angDot +\n"
"                   lu.lights[0].angAtt[0];\n"
"    ret += lu.lights[0].color * saturate(angAtt) * att * saturate(dot(normalize(-delta), mvNormIn)) *\n"
"           extTex7.sample(clampSamp, vtf.extTcgs0).r;\n"
"    \n"
"    for (int i=1 ; i<" _XSTR(URDE_MAX_LIGHTS) " ; ++i)\n"
"    {\n"
"        float3 delta = mvPosIn - lu.lights[i].pos.xyz;\n"
"        float dist = length(delta);\n"
"        float angDot = saturate(dot(normalize(delta), lu.lights[i].dir.xyz));\n"
"        float att = 1.0 / (lu.lights[i].linAtt[2] * dist * dist +\n"
"                           lu.lights[i].linAtt[1] * dist +\n"
"                           lu.lights[i].linAtt[0]);\n"
"        float angAtt = lu.lights[i].angAtt[2] * angDot * angDot +\n"
"                       lu.lights[i].angAtt[1] * angDot +\n"
"                       lu.lights[i].angAtt[0];\n"
"        ret += lu.lights[i].color * saturate(angAtt) * att * saturate(dot(normalize(-delta), mvNormIn));\n"
"    }\n"
"    \n"
"    return ret;\n"
"}\n"sv;

static std::string_view MainPostMetal =
    "float4 MainPostFunc(thread VertToFrag& vtf, constant LightingUniform& lu, float4 colorIn)\n"
    "{\n" FOG_ALGORITHM_METAL
    "}\n"
    "\n"sv;

static std::string_view ThermalPostMetal =
    "struct ThermalUniform\n"
    "{\n"
    "    float4 tmulColor;\n"
    "    float4 taddColor;\n"
    "};\n"
    "static float4 EXTThermalPostFunc(thread VertToFrag& vtf, constant ThermalUniform& lu,\n"
    "    sampler samp, sampler clampSamp, texture2d<float> extTex7, float4 colorIn)\n"
    "{\n"
    "    return extTex7.sample(samp, vtf.extTcgs0).rrrr * lu.tmulColor + lu.taddColor;\n"
    "}\n"
    "\n"sv;

static std::string_view SolidPostMetal =
    "struct SolidUniform\n"
    "{\n"
    "    float4 solidColor;\n"
    "};\n"
    "static float4 SolidPostFunc(thread VertToFrag& vtf, constant SolidUniform& lu, float4 colorIn)\n"
    "{\n"
    "    return lu.solidColor;\n"
    "}\n"
    "\n"sv;

static std::string_view MBShadowPostMetal =
    "struct MBShadowUniform\n"
    "{\n"
    "    float4 shadowUp;\n"
    "    float shadowId;\n"
    "};\n"
    "static float4 EXTMBShadowPostFunc(thread VertToFrag& vtf, constant MBShadowUniform& su, sampler samp,\n"
    "                                  sampler clampSamp, texture2d<float> extTex0, texture2d<float> extTex1,\n"
    "                                  texture2d<float> extTex2, float4 colorIn)\n"
    "{\n"
    "    float idTexel = extTex0.sample(samp, vtf.extTcgs0).a;\n"
    "    float sphereTexel = extTex1.sample(samp, vtf.extTcgs1).a;\n"
    "    float fadeTexel = extTex2.sample(samp, vtf.extTcgs2).a;\n"
    "    float val = ((fabs(idTexel - su.shadowId) < 0.001) ?\n"
    "        (dot(vtf.mvNorm.xyz, su.shadowUp.xyz) * su.shadowUp.w) : 0.0) *\n"
    "        sphereTexel * fadeTexel;\n"
    "    return float4(0.0, 0.0, 0.0, val);\n"
    "}\n"
    "\n"sv;

static std::string_view DisintegratePostMetal = FOG_STRUCT_METAL
    "struct DisintegrateUniform\n"
    "{\n"
    "    float4 daddColor;\n"
    "    Fog fog;\n"
    "};\n"
    "static float4 EXTDisintegratePostFunc(thread VertToFrag& vtf, constant DisintegrateUniform& lu, sampler samp,\n"
    "                                      sampler clampSamp, texture2d<float> extTex7, float4 colorIn)\n"
    "{\n"
    "    float4 texel0 = extTex7.sample(samp, vtf.extTcgs0);\n"
    "    float4 texel1 = extTex7.sample(samp, vtf.extTcgs1);\n"
    "    colorIn = mix(float4(0.0), texel1, texel0);\n"
    "    colorIn.rgb += lu.daddColor.rgb;\n" FOG_ALGORITHM_METAL
    "}\n"
    "\n"sv;

static std::string_view ThermalColdPostMetal =
  "static float4 ThermalColdPostFunc(thread VertToFrag& vtf, float4 colorIn)\n"
  "{\n"
  "    return colorIn * float4(0.75, 0.75, 0.75, 0.75);\n"
  "}\n"
  "\n"sv;

const hecl::Backend::Function ExtensionLightingFuncsMetal[] = {{},
                                                               {LightingMetal, "LightingFunc"},
                                                               {},
                                                               {LightingMetal, "LightingFunc"},
                                                               {LightingMetal, "LightingFunc"},
                                                               {},
                                                               {},
                                                               {},
                                                               {},
                                                               {},
                                                               {},
                                                               {},
                                                               {LightingShadowMetal, "EXTLightingShadowFunc"},
                                                               {LightingMetal, "LightingFunc"},
                                                               {LightingMetal, "LightingFunc"},
                                                               {LightingMetal, "LightingFunc"},
                                                               {LightingMetal, "LightingFunc"},
                                                               {LightingMetal, "LightingFunc"},
                                                               {LightingMetal, "LightingFunc"},
                                                               {LightingMetal, "LightingFunc"},
                                                               {},
                                                               {LightingMetal, "LightingFunc"},
                                                               {},
                                                               {LightingMetal, "LightingFunc"},};

const hecl::Backend::Function ExtensionPostFuncsMetal[] = {
    {},
    {MainPostMetal, "MainPostFunc"},
    {ThermalPostMetal, "EXTThermalPostFunc"},
    {MainPostMetal, "MainPostFunc"},
    {MainPostMetal, "MainPostFunc"},
    {SolidPostMetal, "SolidPostFunc"},
    {SolidPostMetal, "SolidPostFunc"},
    {SolidPostMetal, "SolidPostFunc"},
    {SolidPostMetal, "SolidPostFunc"},
    {SolidPostMetal, "SolidPostFunc"},
    {SolidPostMetal, "SolidPostFunc"},
    {MBShadowPostMetal, "EXTMBShadowPostFunc"},
    {MainPostMetal, "MainPostFunc"},
    {MainPostMetal, "MainPostFunc"},
    {MainPostMetal, "MainPostFunc"},
    {MainPostMetal, "MainPostFunc"},
    {MainPostMetal, "MainPostFunc"},
    {MainPostMetal, "MainPostFunc"},
    {MainPostMetal, "MainPostFunc"},
    {MainPostMetal, "MainPostFunc"},
    {DisintegratePostMetal, "EXTDisintegratePostFunc"},
    {MainPostMetal, "MainPostFunc"},
    {ThermalColdPostMetal, "ThermalColdPostFunc"},
    {MainPostMetal, "MainPostFunc"},
};

} // namespace urde