macOS API sync

Editor/icons/CMakeLists.txt

@@ -45,6 +45,12 @@ if(NOT INKSCAPE_BIN)
   add_custom_command(OUTPUT icons.bin COMMAND ${CMAKE_COMMAND} ARGS -P
       ${CMAKE_CURRENT_SOURCE_DIR}/IconDownload.cmake)
 else()
+  if(APPLE)
+    get_filename_component(INKSCAPE_DIR ${INKSCAPE_BIN} DIRECTORY)
+    if(EXISTS "${INKSCAPE_DIR}/../Resources/bin/inkscape")
+      set(INKSCAPE_BIN "${INKSCAPE_DIR}/../Resources/bin/inkscape")
+    endif()
+  endif()
   message(STATUS "Inkscape found; will render icons locally")
   add_custom_command(OUTPUT icons.bin COMMAND $<TARGET_FILE:packicons>
                      ARGS ${INKSCAPE_BIN} ${CMAKE_CURRENT_SOURCE_DIR}/icons.svg

Runtime/Graphics/Shaders/CModelShaders.cpp

@@ -71,86 +71,91 @@ static const hecl::Backend::TextureInfo WorldShadowTextures[] =
     {hecl::Backend::TexGenSrc::Position, 7, 0, 7, false} // Shadow tex
 };
 
+static const char* BlockNames[] = {"LightingUniform"};
+static const char* ThermalBlockNames[] = {"ThermalUniform"};
+static const char* SolidBlockNames[] = {"SolidUniform"};
+static const char* MBShadowBlockNames[] = {"MBShadowUniform"};
+
 static hecl::Backend::ExtensionSlot g_ExtensionSlots[] =
 {
     /* Default solid shading */
     {},
     /* Normal lit shading */
-    {0, nullptr, hecl::Backend::BlendFactor::Original,
+    {1, BlockNames, 0, nullptr, hecl::Backend::BlendFactor::Original,
         hecl::Backend::BlendFactor::Original, hecl::Backend::ZTest::Original,
         hecl::Backend::CullMode::Backface, false, false, true},
     /* Thermal Visor shading */
-    {1, ThermalTextures, hecl::Backend::BlendFactor::One,
+    {1, ThermalBlockNames, 1, ThermalTextures, hecl::Backend::BlendFactor::One,
         hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::Original,
         hecl::Backend::CullMode::Backface, false, false, false, true},
     /* Forced alpha shading */
-    {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
+    {1, BlockNames, 0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
         hecl::Backend::BlendFactor::InvSrcAlpha, hecl::Backend::ZTest::Original,
         hecl::Backend::CullMode::Backface, false, false, true},
     /* Forced additive shading */
-    {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
+    {1, BlockNames, 0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
         hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::Original,
         hecl::Backend::CullMode::Backface, true, false, true},
     /* Solid color */
-    {0, nullptr, hecl::Backend::BlendFactor::One,
+    {1, SolidBlockNames, 0, nullptr, hecl::Backend::BlendFactor::One,
         hecl::Backend::BlendFactor::Zero, hecl::Backend::ZTest::LEqual,
         hecl::Backend::CullMode::Backface, false, false, false},
     /* Solid color additive */
-    {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
+    {1, SolidBlockNames, 0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
         hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::LEqual,
         hecl::Backend::CullMode::Backface, true, false, true},
     /* Alpha-only Solid color frontface cull, LEqual */
-    {0, nullptr, hecl::Backend::BlendFactor::Zero,
+    {1, SolidBlockNames, 0, nullptr, hecl::Backend::BlendFactor::Zero,
         hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::LEqual,
         hecl::Backend::CullMode::Frontface, false, true, false},
     /* Alpha-only Solid color frontface cull, Always, No Z-write */
-    {0, nullptr, hecl::Backend::BlendFactor::Zero,
+    {1, SolidBlockNames, 0, nullptr, hecl::Backend::BlendFactor::Zero,
         hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::None,
         hecl::Backend::CullMode::Frontface, true, true, false},
     /* Alpha-only Solid color backface cull, LEqual */
-    {0, nullptr, hecl::Backend::BlendFactor::Zero,
+    {1, SolidBlockNames, 0, nullptr, hecl::Backend::BlendFactor::Zero,
         hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::LEqual,
         hecl::Backend::CullMode::Backface, false, true, false},
     /* Alpha-only Solid color backface cull, Greater, No Z-write */
-    {0, nullptr, hecl::Backend::BlendFactor::Zero,
+    {1, SolidBlockNames, 0, nullptr, hecl::Backend::BlendFactor::Zero,
         hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::Greater,
         hecl::Backend::CullMode::Backface, true, true, false},
     /* MorphBall shadow shading */
-    {3, BallFadeTextures,
+    {1, MBShadowBlockNames, 3, BallFadeTextures,
         hecl::Backend::BlendFactor::SrcAlpha,
         hecl::Backend::BlendFactor::InvSrcAlpha,
         hecl::Backend::ZTest::Equal,
         hecl::Backend::CullMode::Backface, false, false, true, false, true},
     /* World shadow shading (modified lighting) */
-    {1, WorldShadowTextures, hecl::Backend::BlendFactor::Original,
+    {1, BlockNames, 1, WorldShadowTextures, hecl::Backend::BlendFactor::Original,
         hecl::Backend::BlendFactor::Original, hecl::Backend::ZTest::Original,
         hecl::Backend::CullMode::Backface, false, false, true},
     /* Forced alpha shading without culling */
-    {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
+    {1, BlockNames, 0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
         hecl::Backend::BlendFactor::InvSrcAlpha, hecl::Backend::ZTest::Original,
         hecl::Backend::CullMode::None, false, false, true},
     /* Forced additive shading without culling */
-    {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
+    {1, BlockNames, 0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
         hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::Original,
         hecl::Backend::CullMode::None, false, false, true},
     /* Forced alpha shading without Z-write */
-    {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
+    {1, BlockNames, 0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
         hecl::Backend::BlendFactor::InvSrcAlpha, hecl::Backend::ZTest::Original,
         hecl::Backend::CullMode::Original, true, false, true},
     /* Forced additive shading without Z-write */
-    {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
+    {1, BlockNames, 0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
         hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::Original,
         hecl::Backend::CullMode::Original, true, false, true},
     /* Forced alpha shading without culling or Z-write */
-    {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
+    {1, BlockNames, 0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
         hecl::Backend::BlendFactor::InvSrcAlpha, hecl::Backend::ZTest::Original,
         hecl::Backend::CullMode::None, true, false, true},
     /* Forced additive shading without culling or Z-write */
-    {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
+    {1, BlockNames, 0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
         hecl::Backend::BlendFactor::One, hecl::Backend::ZTest::Original,
         hecl::Backend::CullMode::None, true, false, true},
     /* Depth GEqual no Z-write */
-    {0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
+    {1, BlockNames, 0, nullptr, hecl::Backend::BlendFactor::SrcAlpha,
         hecl::Backend::BlendFactor::InvSrcAlpha, hecl::Backend::ZTest::GEqual,
         hecl::Backend::CullMode::Backface, true, false, true}
 };

Runtime/Graphics/Shaders/CModelShadersMetal.cpp

@@ -208,7 +208,7 @@ const hecl::Backend::Function ExtensionLightingFuncsMetal[] =
     {},
     {},
     {},
-    {LightingShadowMetal, "LightingShadowFunc"},
+    {LightingShadowMetal, "EXTLightingShadowFunc"},
     {LightingMetal, "LightingFunc"},
     {LightingMetal, "LightingFunc"},
     {LightingMetal, "LightingFunc"},
@@ -222,7 +222,7 @@ const hecl::Backend::Function ExtensionPostFuncsMetal[] =
 {
     {},
     {MainPostMetal, "MainPostFunc"},
-    {ThermalPostMetal, "ThermalPostFunc"},
+    {ThermalPostMetal, "EXTThermalPostFunc"},
     {MainPostMetal, "MainPostFunc"},
     {MainPostMetal, "MainPostFunc"},
     {SolidPostMetal, "SolidPostFunc"},
@@ -231,7 +231,7 @@ const hecl::Backend::Function ExtensionPostFuncsMetal[] =
     {SolidPostMetal, "SolidPostFunc"},
     {SolidPostMetal, "SolidPostFunc"},
     {SolidPostMetal, "SolidPostFunc"},
-    {MBShadowPostMetal, "MBShadowPostFunc"},
+    {MBShadowPostMetal, "EXTMBShadowPostFunc"},
     {MainPostMetal, "MainPostFunc"},
     {MainPostMetal, "MainPostFunc"},
     {MainPostMetal, "MainPostFunc"},

Shaders/CAABoxShader.shader

@@ -109,7 +109,7 @@ vertex VertToFrag vmain(VertData v [[ stage_in ]], constant CAABoxUniform& bu [[
 }
 
 #fragment metal
-"struct VertToFrag
+struct VertToFrag
 {
     float4 pos [[ position ]];
     float4 color;

Shaders/CElementGenShaders.shader

@@ -435,7 +435,7 @@ struct VertToFrag
 };
 
 fragment float4 fmain(VertToFrag vtf [[ stage_in ]],
-                      sampler samp [[ sampler(0) ]],"
+                      sampler samp [[ sampler(0) ]],
                       texture2d<float> tex0 [[ texture(0) ]],
                       texture2d<float> tex1 [[ texture(1) ]],
                       texture2d<float> tex2 [[ texture(2) ]])
@@ -444,7 +444,7 @@ fragment float4 fmain(VertToFrag vtf [[ stage_in ]],
     float4 sceneTexel = tex1.sample(samp, mix(vtf.uvScene.xy, vtf.uvScene.zw, tindTexel));
     float4 texrTexel = tex0.sample(samp, vtf.uvTexr);
     float4 colr = vtf.color * float4(sceneTexel.rgb, 1.0) + texrTexel;
-    return float4(colr.rgb, vtf.color.a * texrTexel.a);"
+    return float4(colr.rgb, vtf.color.a * texrTexel.a);
 }
 
 #shader CElementGenShaderIndTexNoZWrite : CElementGenShaderIndTexZWrite

Shaders/shader_CFluidPlaneShaderMetal.cpp

@@ -0,0 +1,769 @@
+#include "shader_CFluidPlaneShader.hpp"
+
+static const char* VS =
+"struct VertData\n"
+"{\n"
+"    float4 posIn [[ attribute(0) ]];\n"
+"    float4 normalIn [[ attribute(1) ]];\n"
+"    float4 binormalIn [[ attribute(2) ]];\n"
+"    float4 tangentIn [[ attribute(3) ]];\n"
+"    float4 colorIn [[ attribute(4) ]];\n"
+"};\n"
+"\n"
+"struct FluidPlaneUniform\n"
+"{\n"
+"    float4x4 mv;\n"
+"    float4x4 mvNorm;\n"
+"    float4x4 proj;\n"
+"    float4x4 texMtxs[6];\n"
+"};\n"
+"\n"
+"struct VertToFrag\n"
+"{\n"
+"    float4 pos [[ position ]];\n"
+"    float4 mvPos;\n"
+"    float4 mvNorm;\n"
+"    float4 mvBinorm;\n"
+"    float4 mvTangent;\n"
+"    float4 color;\n"
+"    float2 uv0;\n"
+"    float2 uv1;\n"
+"    float2 uv2;\n"
+"    float2 uv3;\n"
+"    float2 uv4;\n"
+"    float2 uv5;\n"
+"    float2 uv6;\n"
+"};\n"
+"\n"
+"vertex VertToFrag vmain(VertData v [[ stage_in ]],\n"
+"                        constant FluidPlaneUniform& fu [[ buffer(2) ]])\n"
+"{\n"
+"    VertToFrag vtf;\n"
+"    float4 pos = float4(v.posIn.xyz, 1.0);\n"
+"    float4 normalIn = v.normalIn;\n"
+"    vtf.mvPos = fu.mv * pos;\n"
+"    vtf.pos = fu.proj * vtf.mvPos;\n"
+"    vtf.mvNorm = fu.mvNorm * v.normalIn;\n"
+"    vtf.mvBinorm = fu.mvNorm * v.binormalIn;\n"
+"    vtf.mvTangent = fu.mvNorm * v.tangentIn;\n"
+"    vtf.color = v.colorIn;\n"
+"    vtf.uv0 = (fu.texMtxs[0] * pos).xy;\n"
+"    vtf.uv1 = (fu.texMtxs[1] * pos).xy;\n"
+"    vtf.uv2 = (fu.texMtxs[2] * pos).xy;\n"
+"%s" // Additional TCGs here
+"    return vtf;\n"
+"}\n";
+
+static const char* TessCS =
+"struct VertData\n"
+"{\n"
+"    float4 minMaxPos [[ attribute(0) ]];\n"
+"    float4 outerLevelsIn [[ attribute(1) ]];\n"
+"    float2 innerLevelsIn [[ attribute(2) ]];\n"
+"};\n"
+"\n"
+"struct KernelPatchInfo {\n"
+"    uint numPatches; // total number of patches to process.\n"
+"                     // we need this because this value may\n"
+"                     // not be a multiple of threadgroup size.\n"
+"    ushort numPatchesInThreadGroup; // number of patches processed by a\n"
+"                                    // thread-group\n"
+"    ushort numControlPointsPerPatch;\n"
+"};\n"
+"\n"
+"kernel void\n"
+"cmain(VertData v [[ stage_in ]],\n"
+"      constant KernelPatchInfo& patchInfo [[ buffer(2) ]],\n"
+"      device MTLQuadTessellationFactorsHalf* tessellationFactorBuffer [[ buffer(3) ]],\n"
+"      ushort lID [[ thread_position_in_threadgroup ]],\n"
+"      ushort groupID [[ threadgroup_position_in_grid ]])\n"
+"{\n"
+"    uint patchGroupID = groupID * patchInfo.numPatchesInThreadGroup;\n"
+"\n"
+"    // execute the per-patch hull function\n"
+"    if (lID < patchInfo.numPatchesInThreadGroup)\n"
+"    {\n"
+"        uint patchID = patchGroupID + lID;\n"
+"        device MTLQuadTessellationFactorsHalf& patchOut = tessellationFactorBuffer[patchID];\n"
+"        for (int i=0 ; i<4 ; ++i)\n"
+"            patchOut.edgeTessellationFactor[i] = v.outerLevelsIn[i];\n"
+"        for (int i=0 ; i<2 ; ++i)\n"
+"            patchOut.insideTessellationFactor[i] = v.innerLevelsIn[i];\n"
+"    }\n"
+"}\n";
+
+static const char* TessES =
+"struct Ripple\n"
+"{\n"
+"    float4 center; // time, distFalloff\n"
+"    float4 params; // amplitude, lookupPhase, lookupTime\n"
+"};\n"
+"\n"
+"struct FluidPlaneUniform\n"
+"{\n"
+"    float4x4 mv;\n"
+"    float4x4 mvNorm;\n"
+"    float4x4 proj;\n"
+"    float4x4 texMtxs[6];\n"
+"    Ripple ripples[20];\n"
+"    float4 colorMul;\n"
+"    float rippleNormResolution;\n"
+"};\n"
+"\n"
+"struct VertToFrag\n"
+"{\n"
+"    float4 pos [[ position ]];\n"
+"    float4 mvPos;\n"
+"    float4 mvNorm;\n"
+"    float4 mvBinorm;\n"
+"    float4 mvTangent;\n"
+"    float4 color;\n"
+"    float2 uv0;\n"
+"    float2 uv1;\n"
+"    float2 uv2;\n"
+"    float2 uv3;\n"
+"    float2 uv4;\n"
+"    float2 uv5;\n"
+"    float2 uv6;\n"
+"};\n"
+"\n"
+"struct VertData\n"
+"{\n"
+"    float4 minMaxPos [[ attribute(0) ]];\n"
+"    float4 outerLevelsIn [[ attribute(1) ]];\n"
+"    float2 innerLevelsIn [[ attribute(2) ]];\n"
+"};\n"
+"\n"
+"#define PI_X2 6.283185307179586\n"
+"\n"
+"static void ApplyRipple(constant Ripple& ripple, float2 pos, thread float& height,\n"
+"                        sampler samp, texture2d<float> RippleMap)\n"
+"{\n"
+"    float dist = length(ripple.center.xy - pos);\n"
+"    float rippleV = RippleMap.sample(samp, float2(dist * ripple.center.w, ripple.center.z), level(0.0)).r;\n"
+"    height += rippleV * ripple.params.x * sin((dist * ripple.params.y + ripple.params.z) * PI_X2);\n"
+"}\n"
+"\n"
+"[[ patch(quad, 1) ]]\n"
+"vertex VertToFrag emain(VertData v [[ stage_in ]], float2 TessCoord [[ position_in_patch ]],\n"
+"                        constant FluidPlaneUniform& fu [[ buffer(2) ]],\n"
+"                        sampler samp [[ sampler(2) ]],\n"
+"                        texture2d<float> RippleMap [[ texture(%d) ]])\n"
+"{\n"
+"    float2 posIn = float2(mix(v.minMaxPos.x, v.minMaxPos.z, TessCoord.x),\n"
+"                          mix(v.minMaxPos.y, v.minMaxPos.w, TessCoord.y));\n"
+"    float height = 0.0;\n"
+"    float upHeight = 0.0;\n"
+"    float downHeight = 0.0;\n"
+"    float rightHeight = 0.0;\n"
+"    float leftHeight = 0.0;\n"
+"    for (int i=0 ; i<20 ; ++i)\n"
+"    {\n"
+"        ApplyRipple(fu.ripples[i], posIn, height, samp, RippleMap);\n"
+"        ApplyRipple(fu.ripples[i], posIn + float2(0.0, fu.rippleNormResolution), upHeight, samp, RippleMap);\n"
+"        ApplyRipple(fu.ripples[i], posIn - float2(0.0, fu.rippleNormResolution), downHeight, samp, RippleMap);\n"
+"        ApplyRipple(fu.ripples[i], posIn + float2(fu.rippleNormResolution, 0.0), rightHeight, samp, RippleMap);\n"
+"        ApplyRipple(fu.ripples[i], posIn - float2(fu.rippleNormResolution, 0.0), leftHeight, samp, RippleMap);\n"
+"    }\n"
+"    float4 normalIn = float4(normalize(float3((leftHeight - rightHeight),\n"
+"                                              (downHeight - upHeight),\n"
+"                                              fu.rippleNormResolution)), 1.0);\n"
+"    float4 binormalIn = float4(normalIn.x, normalIn.z, -normalIn.y, 1.0);\n"
+"    float4 tangentIn = float4(normalIn.z, normalIn.y, -normalIn.x, 1.0);\n"
+"    float4 pos = float4(posIn, height, 1.0);\n"
+"    VertToFrag vtf;\n"
+"    vtf.mvPos = (fu.mv * pos);\n"
+"    vtf.pos = (fu.proj * vtf.mvPos);\n"
+"    vtf.mvNorm = (fu.mvNorm * normalIn);\n"
+"    vtf.mvBinorm = (fu.mvNorm * binormalIn);\n"
+"    vtf.mvTangent = (fu.mvNorm * tangentIn);\n"
+"    vtf.color = max(height, 0.0) * fu.colorMul;\n"
+"    vtf.color.a = 1.0;\n"
+"    vtf.uv0 = (fu.texMtxs[0] * pos).xy;\n"
+"    vtf.uv1 = (fu.texMtxs[1] * pos).xy;\n"
+"    vtf.uv2 = (fu.texMtxs[2] * pos).xy;\n"
+"%s\n" // Additional TCGs here
+"    return vtf;\n"
+"}\n";
+
+static const char* FS =
+"struct Light\n"
+"{\n"
+"    float4 pos;\n"
+"    float4 dir;\n"
+"    float4 color;\n"
+"    float4 linAtt;\n"
+"    float4 angAtt;\n"
+"};\n"
+"struct Fog\n" // Reappropriated for indirect texture scaling
+"{\n"
+"    int mode;\n"
+"    float4 color;\n"
+"    float indScale;\n"
+"    float start;\n"
+"};\n"
+"\n"
+"struct LightingUniform\n"
+"{\n"
+"    Light lights[" _XSTR(URDE_MAX_LIGHTS) "];\n"
+"    float4 ambient;\n"
+"    float4 kColor0;\n"
+"    float4 kColor1;\n"
+"    float4 kColor2;\n"
+"    float4 kColor3;\n"
+"    Fog fog;\n"
+"};\n"
+"\n"
+"static float4 LightingFunc(constant LightingUniform& lu, float3 mvPosIn, float3 mvNormIn)\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 = clamp(dot(normalize(delta), lu.lights[i].dir.xyz), 0.0, 1.0);\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 * clamp(angAtt, 0.0, 1.0) * att * clamp(dot(normalize(-delta), mvNormIn), 0.0, 1.0);\n"
+"    }\n"
+"    \n"
+"    return ret;\n"
+"}\n"
+"\n"
+"struct VertToFrag\n"
+"{\n"
+"    float4 pos [[ position ]];\n"
+"    float4 mvPos;\n"
+"    float4 mvNorm;\n"
+"    float4 mvBinorm;\n"
+"    float4 mvTangent;\n"
+"    float4 color;\n"
+"    float2 uv0;\n"
+"    float2 uv1;\n"
+"    float2 uv2;\n"
+"    float2 uv3;\n"
+"    float2 uv4;\n"
+"    float2 uv5;\n"
+"    float2 uv6;\n"
+"};\n"
+"\n"
+"fragment float4 fmain(VertToFrag vtf [[ stage_in ]],\n"
+"                      sampler samp [[ sampler(0) ]],\n"
+"                      constant LightingUniform& lu [[ buffer(4) ]]%s)\n" // Textures here
+"{\n"
+"    float4 lighting = LightingFunc(lu, vtf.mvPos.xyz, normalize(vtf.mvNorm.xyz));\n"
+"    float4 colorOut;\n"
+"%s" // Combiner expression here
+"    return colorOut;\n"
+"}\n";
+
+static const char* FSDoor =
+"struct Light\n"
+"{\n"
+"    float4 pos;\n"
+"    float4 dir;\n"
+"    float4 color;\n"
+"    float4 linAtt;\n"
+"    float4 angAtt;\n"
+"};\n"
+"struct Fog\n" // Reappropriated for indirect texture scaling
+"{\n"
+"    int mode;\n"
+"    float4 color;\n"
+"    float indScale;\n"
+"    float start;\n"
+"};\n"
+"\n"
+"struct LightingUniform\n"
+"{\n"
+"    Light lights[" _XSTR(URDE_MAX_LIGHTS) "];\n"
+"    float4 ambient;\n"
+"    float4 kColor0;\n"
+"    float4 kColor1;\n"
+"    float4 kColor2;\n"
+"    float4 kColor3;\n"
+"    Fog fog;\n"
+"};\n"
+"\n"
+"struct VertToFrag\n"
+"{\n"
+"    float4 pos [[ position ]];\n"
+"    float4 mvPos;\n"
+"    float4 mvNorm;\n"
+"    float4 mvBinorm;\n"
+"    float4 mvTangent;\n"
+"    float4 color;\n"
+"    float2 uv0;\n"
+"    float2 uv1;\n"
+"    float2 uv2;\n"
+"    float2 uv3;\n"
+"    float2 uv4;\n"
+"    float2 uv5;\n"
+"    float2 uv6;\n"
+"};\n"
+"\n"
+"fragment float4 fmain(VertToFrag vtf [[ stage_in ]],\n"
+"                      sampler samp [[ sampler(0) ]],\n"
+"                      constant LightingUniform& lu [[ buffer(4) ]]%s)\n" // Textures here
+"{\n"
+"    float4 colorOut;\n"
+"%s" // Combiner expression here
+"    return colorOut;\n"
+"}\n";
+
+static std::string _BuildFS(const SFluidPlaneShaderInfo& info)
+{
+    std::string textures;
+    std::string combiner;
+    int nextTex = 0;
+    int nextTCG = 3;
+    int nextMtx = 4;
+    int bumpMapUv, envBumpMapUv, envMapUv, lightmapUv;
+
+    if (info.m_hasPatternTex1)
+        textures += hecl::Format(",\ntexture2d<float> patternTex1 [[ texture(%d) ]]", nextTex++);
+    if (info.m_hasPatternTex2)
+        textures += hecl::Format(",\ntexture2d<float> patternTex2 [[ texture(%d) ]]", nextTex++);
+    if (info.m_hasColorTex)
+        textures += hecl::Format(",\ntexture2d<float> colorTex [[ texture(%d) ]]", nextTex++);
+    if (info.m_hasBumpMap)
+        textures += hecl::Format(",\ntexture2d<float> bumpMap [[ texture(%d) ]]", nextTex++);
+    if (info.m_hasEnvMap)
+        textures += hecl::Format(",\ntexture2d<float> envMap [[ texture(%d) ]]", nextTex++);
+    if (info.m_hasEnvBumpMap)
+        textures += hecl::Format(",\ntexture2d<float> envBumpMap [[ texture(%d) ]]", nextTex++);
+    if (info.m_hasLightmap)
+        textures += hecl::Format(",\ntexture2d<float> lightMap [[ texture(%d) ]]", nextTex++);
+
+    if (info.m_hasBumpMap)
+    {
+        bumpMapUv = nextTCG;
+    }
+    if (info.m_hasEnvBumpMap)
+    {
+        envBumpMapUv = nextTCG;
+    }
+    if (info.m_hasEnvMap)
+    {
+        envMapUv = nextTCG;
+    }
+    if (info.m_hasLightmap)
+    {
+        lightmapUv = nextTCG;
+    }
+
+    switch (info.m_type)
+    {
+    case EFluidType::NormalWater:
+    case EFluidType::PhazonFluid:
+    case EFluidType::Four:
+        if (info.m_hasLightmap)
+        {
+            combiner += hecl::Format("    float4 lightMapTexel = lightMap.sample(samp, vtf.uv%d);\n", lightmapUv);
+            // 0: Tex4TCG, Tex4, doubleLightmapBlend ? NULL : GX_COLOR1A1
+            // ZERO, TEX, KONST, doubleLightmapBlend ? ZERO : RAS
+            // Output reg 2
+            // KColor 2
+            if (info.m_doubleLightmapBlend)
+            {
+                // 1: Tex4TCG2, Tex4, GX_COLOR1A1
+                // C2, TEX, KONST, RAS
+                // Output reg 2
+                // KColor 3
+                // Tex * K2 + Lighting
+                combiner += "    lighting += mix(lightMapTexel * lu.kColor2, lightMapTexel, lu.kColor3);\n";
+            }
+            else
+            {
+                // mix(Tex * K2, Tex, K3) + Lighting
+                combiner += "    lighting += lightMapTexel * lu.kColor2;\n";
+            }
+        }
+
+        // Next: Tex0TCG, Tex0, GX_COLOR1A1
+        // ZERO, TEX, KONST, RAS
+        // Output reg prev
+        // KColor 0
+
+        // Next: Tex1TCG, Tex1, GX_COLOR0A0
+        // ZERO, TEX, PREV, RAS
+        // Output reg prev
+
+        // Next: Tex2TCG, Tex2, GX_COLOR1A1
+        // ZERO, TEX, hasTex4 ? C2 : RAS, PREV
+        // Output reg prev
+
+        // (Tex0 * kColor0 + Lighting) * Tex1 + VertColor + Tex2 * Lighting
+        if (info.m_hasPatternTex2)
+        {
+            if (info.m_hasPatternTex1)
+                combiner += "    colorOut = (patternTex1.sample(samp, vtf.uv0) * lu.kColor0 + lighting) *\n"
+                            "               patternTex2.sample(samp, vtf.uv1) + vtf.color;\n";
+            else
+                combiner += "    colorOut = lighting * patternTex2.sample(samp, vtf.uv1) + vtf.color;\n";
+        }
+        else
+        {
+            combiner += "    colorOut = vtf.color;\n";
+        }
+
+
+        if (info.m_hasColorTex && !info.m_hasEnvMap && info.m_hasEnvBumpMap)
+        {
+            // Make previous stage indirect, mtx0
+            combiner += hecl::Format("    float2 indUvs = (envBumpMap.sample(samp, vtf.uv%d).ra - float2(0.5, 0.5)) *\n"
+                                     "        float2(lu.fog.indScale, -lu.fog.indScale);\n", envBumpMapUv);
+            combiner += "    colorOut += colorTex.sample(samp, indUvs + vtf.uv2) * lighting;\n";
+        }
+        else if (info.m_hasEnvMap)
+        {
+            // Next: envTCG, envTex, NULL
+            // PREV, TEX, KONST, ZERO
+            // Output reg prev
+            // KColor 1
+
+            // Make previous stage indirect, mtx0
+            if (info.m_hasColorTex)
+                combiner += "    colorOut += colorTex.sample(samp, vtf.uv2) * lighting;\n";
+            combiner += hecl::Format("    float2 indUvs = (envBumpMap.sample(samp, vtf.uv%d).ra - float2(0.5, 0.5)) *\n"
+                                     "        float2(lu.fog.indScale, -lu.fog.indScale);\n", envBumpMapUv);
+            combiner += hecl::Format("    colorOut = mix(colorOut, envMap.sample(samp, indUvs + vtf.uv%d), lu.kColor1);\n",
+                                     envMapUv);
+        }
+        else if (info.m_hasColorTex)
+        {
+            combiner += "    colorOut += colorTex.sample(samp, vtf.uv2) * lighting;\n";
+        }
+
+        break;
+
+    case EFluidType::PoisonWater:
+        if (info.m_hasLightmap)
+        {
+            combiner += hecl::Format("    float4 lightMapTexel = lightMap.sample(samp, vtf.uv%d);\n", lightmapUv);
+            // 0: Tex4TCG, Tex4, doubleLightmapBlend ? NULL : GX_COLOR1A1
+            // ZERO, TEX, KONST, doubleLightmapBlend ? ZERO : RAS
+            // Output reg 2
+            // KColor 2
+            if (info.m_doubleLightmapBlend)
+            {
+                // 1: Tex4TCG2, Tex4, GX_COLOR1A1
+                // C2, TEX, KONST, RAS
+                // Output reg 2
+                // KColor 3
+                // Tex * K2 + Lighting
+                combiner += "    lighting += mix(lightMapTexel * lu.kColor2, lightMapTexel, lu.kColor3);\n";
+            }
+            else
+            {
+                // mix(Tex * K2, Tex, K3) + Lighting
+                combiner += "    lighting += lightMapTexel * lu.kColor2;\n";
+            }
+        }
+
+        // Next: Tex0TCG, Tex0, GX_COLOR1A1
+        // ZERO, TEX, KONST, RAS
+        // Output reg prev
+        // KColor 0
+
+        // Next: Tex1TCG, Tex1, GX_COLOR0A0
+        // ZERO, TEX, PREV, RAS
+        // Output reg prev
+
+        // Next: Tex2TCG, Tex2, GX_COLOR1A1
+        // ZERO, TEX, hasTex4 ? C2 : RAS, PREV
+        // Output reg prev
+
+        // (Tex0 * kColor0 + Lighting) * Tex1 + VertColor + Tex2 * Lighting
+        if (info.m_hasPatternTex2)
+        {
+            if (info.m_hasPatternTex1)
+                combiner += "    colorOut = (patternTex1.sample(samp, vtf.uv0) * lu.kColor0 + lighting) *\n"
+                            "               patternTex2.sample(samp, vtf.uv1) + vtf.color;\n";
+            else
+                combiner += "    colorOut = lighting * patternTex2.sample(samp, vtf.uv1) + vtf.color;\n";
+        }
+        else
+        {
+            combiner += "    colorOut = vtf.color;\n";
+        }
+
+        if (info.m_hasColorTex)
+        {
+            if (info.m_hasEnvBumpMap)
+            {
+                // Make previous stage indirect, mtx0
+                combiner += hecl::Format("    float2 indUvs = (envBumpMap.sample(samp, vtf.uv%d).ra - float2(0.5, 0.5)) *\n"
+                                         "        float2(lu.fog.indScale, -lu.fog.indScale);\n", envBumpMapUv);
+                combiner += "    colorOut += colorTex.sample(samp, indUvs + vtf.uv2) * lighting;\n";
+            }
+            else
+            {
+                combiner += "    colorOut += colorTex.sample(samp, vtf.uv2) * lighting;\n";
+            }
+        }
+
+        break;
+
+    case EFluidType::Lava:
+        // 0: Tex0TCG, Tex0, GX_COLOR0A0
+        // ZERO, TEX, KONST, RAS
+        // Output reg prev
+        // KColor 0
+
+        // 1: Tex1TCG, Tex1, GX_COLOR0A0
+        // ZERO, TEX, PREV, RAS
+        // Output reg prev
+
+        // 2: Tex2TCG, Tex2, NULL
+        // ZERO, TEX, ONE, PREV
+        // Output reg prev
+
+        // (Tex0 * kColor0 + VertColor) * Tex1 + VertColor + Tex2
+        if (info.m_hasPatternTex2)
+        {
+            if (info.m_hasPatternTex1)
+                combiner += "    colorOut = (patternTex1.sample(samp, vtf.uv0) * lu.kColor0 + vtf.color) *\n"
+                            "               patternTex2.sample(samp, vtf.uv1) + vtf.color;\n";
+            else
+                combiner += "    colorOut = vtf.color * patternTex2.sample(samp, vtf.uv1) + vtf.color;\n";
+        }
+        else
+        {
+            combiner += "    colorOut = vtf.color;\n";
+        }
+
+        if (info.m_hasColorTex)
+            combiner += "    colorOut += colorTex.sample(samp, vtf.uv2);\n";
+
+        if (info.m_hasBumpMap)
+        {
+            // 3: bumpMapTCG, bumpMap, NULL
+            // ZERO, TEX, ONE, HALF
+            // Output reg 0, no clamp, no bias
+
+            // 4: bumpMapTCG2, bumpMap, NULL
+            // ZERO, TEX, ONE, C0
+            // Output reg 0, subtract, clamp, no bias
+
+            combiner += "    float3 lightVec = lights[3].pos.xyz - vtf.mvPos.xyz;\n"
+                        "    float lx = dot(vtf.mvTangent.xyz, lightVec);\n"
+                        "    float ly = dot(vtf.mvBinorm.xyz, lightVec);\n";
+            combiner += hecl::Format("    float4 emboss1 = bumpMap.sample(samp, vtf.uv%d) + float4(0.5);\n"
+                                     "    float4 emboss2 = bumpMap.sample(samp, vtf.uv%d + float2(lx, ly));\n",
+                                     bumpMapUv, bumpMapUv);
+
+            // 5: NULL, NULL, NULL
+            // ZERO, PREV, C0, ZERO
+            // Output reg prev, scale 2, clamp
+
+            // colorOut * clamp(emboss1 + 0.5 - emboss2, 0.0, 1.0) * 2.0
+            combiner += "colorOut *= clamp((emboss1 + float4(0.5) - emboss2) * float4(2.0), float4(0.0), float4(1.0));\n";
+        }
+
+        break;
+
+    case EFluidType::ThickLava:
+        // 0: Tex0TCG, Tex0, GX_COLOR0A0
+        // ZERO, TEX, KONST, RAS
+        // Output reg prev
+        // KColor 0
+
+        // 1: Tex1TCG, Tex1, GX_COLOR0A0
+        // ZERO, TEX, PREV, RAS
+        // Output reg prev
+
+        // 2: Tex2TCG, Tex2, NULL
+        // ZERO, TEX, ONE, PREV
+        // Output reg prev
+
+        // (Tex0 * kColor0 + VertColor) * Tex1 + VertColor + Tex2
+        if (info.m_hasPatternTex2)
+        {
+            if (info.m_hasPatternTex1)
+                combiner += "    colorOut = (patternTex1.sample(samp, vtf.uv0) * lu.kColor0 + vtf.color) *\n"
+                            "               patternTex2.sample(samp, vtf.uv1) + vtf.color;\n";
+            else
+                combiner += "    colorOut = vtf.color * patternTex2.sample(samp, vtf.uv1) + vtf.color;\n";
+        }
+        else
+        {
+            combiner += "    colorOut = vtf.color;\n";
+        }
+
+        if (info.m_hasColorTex)
+            combiner += "    colorOut += colorTex.sample(samp, vtf.uv2);\n";
+
+        if (info.m_hasBumpMap)
+        {
+            // 3: bumpMapTCG, bumpMap, NULL
+            // ZERO, TEX, PREV, ZERO
+            // Output reg prev, scale 2
+            combiner += hecl::Format("    float4 emboss1 = bumpMap.sample(samp, vtf.uv%d) + float4(0.5);\n", bumpMapUv);
+            combiner += "colorOut *= emboss1 * float4(2.0);\n";
+        }
+
+        break;
+    }
+
+    combiner += "    colorOut.a = lu.kColor0.a;\n";
+
+    char *finalFS;
+    asprintf(&finalFS, FS, textures.c_str(), combiner.c_str());
+    std::string ret(finalFS);
+    free(finalFS);
+    return ret;
+}
+
+static std::string _BuildAdditionalTCGs(const SFluidPlaneShaderInfo& info)
+{
+    std::string additionalTCGs;
+    int nextTCG = 3;
+    int nextMtx = 4;
+
+    if (info.m_hasBumpMap)
+    {
+        additionalTCGs += hecl::Format("    vtf.uv%d = (fu.texMtxs[0] * pos).xy;\n", nextTCG++);
+    }
+    if (info.m_hasEnvBumpMap)
+    {
+        additionalTCGs += hecl::Format("    vtf.uv%d = (fu.texMtxs[3] * float4(normalIn.xyz, 1.0)).xy;\n", nextTCG++);
+    }
+    if (info.m_hasEnvMap)
+    {
+        additionalTCGs += hecl::Format("    vtf.uv%d = (fu.texMtxs[%d] * pos).xy;\n", nextTCG++, nextMtx++);
+    }
+    if (info.m_hasLightmap)
+    {
+        additionalTCGs += hecl::Format("    vtf.uv%d = (fu.texMtxs[%d] * pos).xy;\n", nextTCG++, nextMtx++);
+    }
+
+    return additionalTCGs;
+}
+
+static std::string _BuildVS(const SFluidPlaneShaderInfo& info, bool tessellation)
+{
+    if (tessellation)
+        return TessCS;
+
+    std::string additionalTCGs = _BuildAdditionalTCGs(info);
+
+    char *finalVSs;
+    asprintf(&finalVSs, VS, additionalTCGs.c_str());
+    std::string ret(finalVSs);
+    free(finalVSs);
+    return ret;
+}
+template <>
+std::string StageObject_CFluidPlaneShader<hecl::PlatformType::Metal, hecl::PipelineStage::Vertex>::BuildShader
+    (const SFluidPlaneShaderInfo& in, bool tessellation)
+{
+    return _BuildVS(in, tessellation);
+}
+
+template <>
+std::string StageObject_CFluidPlaneShader<hecl::PlatformType::Metal, hecl::PipelineStage::Fragment>::BuildShader
+    (const SFluidPlaneShaderInfo& in, bool tessellation)
+{
+    return _BuildFS(in);
+}
+
+static std::string BuildES(const SFluidPlaneShaderInfo& info)
+{
+    int nextTex = 0;
+    if (info.m_hasPatternTex1)
+        nextTex++;
+    if (info.m_hasPatternTex2)
+        nextTex++;
+    if (info.m_hasColorTex)
+        nextTex++;
+    if (info.m_hasBumpMap)
+        nextTex++;
+    if (info.m_hasEnvMap)
+        nextTex++;
+    if (info.m_hasEnvBumpMap)
+        nextTex++;
+    if (info.m_hasLightmap)
+        nextTex++;
+
+    std::string additionalTCGs = _BuildAdditionalTCGs(info);
+
+    char *finalESs;
+    asprintf(&finalESs, TessES, nextTex, additionalTCGs.c_str());
+    std::string ret(finalESs);
+    free(finalESs);
+
+    return ret;
+}
+template <>
+std::string StageObject_CFluidPlaneShader<hecl::PlatformType::Metal, hecl::PipelineStage::Evaluation>::BuildShader
+    (const SFluidPlaneShaderInfo& in, bool tessellation)
+{
+    return BuildES(in);
+}
+
+static std::string _BuildVS(const SFluidPlaneDoorShaderInfo& info)
+{
+    char *finalVSs;
+    asprintf(&finalVSs, VS, "");
+    std::string ret(finalVSs);
+    free(finalVSs);
+    return ret;
+}
+
+static std::string _BuildFS(const SFluidPlaneDoorShaderInfo& info)
+{
+    int nextTex = 0;
+    std::string textures;
+    std::string combiner;
+
+    if (info.m_hasPatternTex1)
+        textures += hecl::Format(",\ntexture2d<float> patternTex1 [[ texture(%d) ]]", nextTex++);
+    if (info.m_hasPatternTex2)
+        textures += hecl::Format(",\ntexture2d<float> patternTex2 [[ texture(%d) ]]", nextTex++);
+    if (info.m_hasColorTex)
+        textures += hecl::Format(",\ntexture2d<float> colorTex [[ texture(%d) ]]", nextTex++);
+
+    // Tex0 * kColor0 * Tex1 + Tex2
+    if (info.m_hasPatternTex1 && info.m_hasPatternTex2)
+    {
+        combiner += "    colorOut = patternTex1.sample(samp, vtf.uv0) * lu.kColor0 *\n"
+                    "               patternTex2.sample(samp, vtf.uv1);\n";
+    }
+    else
+    {
+        combiner += "    colorOut = float4(0.0);\n";
+    }
+
+    if (info.m_hasColorTex)
+    {
+        combiner += "    colorOut += colorTex.sample(samp, vtf.uv2);\n";
+    }
+
+    combiner += "    colorOut.a = lu.kColor0.a;\n";
+
+    char *finalFSs;
+    asprintf(&finalFSs, FSDoor, textures.c_str(), combiner.c_str());
+    std::string ret(finalFSs);
+    free(finalFSs);
+    return ret;
+}
+
+template <>
+std::string StageObject_CFluidPlaneDoorShader<hecl::PlatformType::Metal, hecl::PipelineStage::Vertex>::BuildShader
+    (const SFluidPlaneDoorShaderInfo& in)
+{
+    return _BuildVS(in);
+}
+
+template <>
+std::string StageObject_CFluidPlaneDoorShader<hecl::PlatformType::Metal, hecl::PipelineStage::Fragment>::BuildShader
+    (const SFluidPlaneDoorShaderInfo& in)
+{
+    return _BuildFS(in);
+}

gmm/gmm_domain_decomp.h

@@ -81,7 +81,7 @@ namespace gmm {
     std::vector<size_type> ns(dim), na(dim), nu(dim);
     for (size_type i = 0; i < nbpts; ++i) {
       for (int k = 0; k < dim; ++k) {
-	register double a = (pts[i][k] - pmin[k]) / msize;
+	double a = (pts[i][k] - pmin[k]) / msize;
 	ns[k] = size_type(a) - 1; na[k] = 0;
 	pts1[k] = int(a + overlap); pts2[k] = int(ceil(a-1.0-overlap));
       }

hecl

@@ -1 +1 @@
-Subproject commit 012d0a4514fb7b0716ca873b888db651b80f770d
+Subproject commit 9fe82ea92f5719a698a32dc7bea0fce66d1b3391

nod

@@ -1 +1 @@
-Subproject commit f87b286ff3c1f46b4294f15fdc6e849cc4f4d296
+Subproject commit 3d380fdc3b1b243c057dac13c9019a08b7eb8700

specter

@@ -1 +1 @@
-Subproject commit 472852162e34e55a1087ffbd743ccf1885fdc16e
+Subproject commit 8653be549c224160fe3bc9ad0c41131dd2fe549d

visigen/CMakeLists.txt

@@ -27,6 +27,11 @@ add_executable(visigen ${PLAT_SRCS}
 
 set_target_properties(visigen PROPERTIES COMPILE_DEFINITIONS URDE_DLPACKAGE="${URDE_DLPACKAGE}")
 
-target_link_libraries(visigen logvisor athena-core athena-libyaml zeus glew
+if(APPLE)
-                      xxhash ${ZLIB_LIBRARIES} ${LZO_LIB} ${BOO_SYS_LIBS})
+  find_library(OPENGL_LIBRARY OpenGL)
+  set(PLAT_LIBS ${OPENGL_LIBRARY})
+endif()
+
+target_link_libraries(visigen logvisor athena-core athena-libyaml zeus glew
+                      xxhash ${ZLIB_LIBRARIES} ${LZO_LIB} ${BOO_SYS_LIBS} ${PLAT_LIBS})
 endif()