Add supplemental data for iw4 statemap layout

src/Common/Game/IW4/IW4_Assets.h

@@ -680,7 +680,7 @@ namespace IW4
         float literal[4];
     };
 
-    enum GfxBlend
+    enum GfxBlend : unsigned int
     {
         GFXS_BLEND_DISABLED = 0x0,
         GFXS_BLEND_ZERO = 0x1,
@@ -696,7 +696,7 @@ namespace IW4
         GFXS_BLEND_MASK = 0xF,
     };
 
-    enum GfxBlendOp
+    enum GfxBlendOp : unsigned int
     {
         GFXS_BLENDOP_DISABLED = 0x0,
         GFXS_BLENDOP_ADD = 0x1,
@@ -707,7 +707,7 @@ namespace IW4
         GFXS_BLENDOP_MASK = 0x7,
     };
 
-    enum GfxStencilFunc
+    enum GfxStencilFunc : unsigned int
     {
         GFXS_STENCILFUNC_NEVER = 0x0,
         GFXS_STENCILFUNC_LESS = 0x1,
@@ -722,7 +722,7 @@ namespace IW4
         GFXS_STENCILFUNC_MASK = 0x7
     };
 
-    enum GfxStencilOp
+    enum GfxStencilOp : unsigned int
     {
         GFXS_STENCILOP_KEEP = 0x0,
         GFXS_STENCILOP_ZERO = 0x1,

src/Common/StateMap/StateMapLayout.cpp

@@ -2,13 +2,41 @@
 
 using namespace state_map;
 
-StateMapLayoutEntry::StateMapLayoutEntry(std::string name, const size_t resultCount)
+
+StateMapLayoutEntry::StateMapLayoutEntry(std::string name, const size_t stateBitsIndex, const size_t stateBitsMask, std::vector<std::string> resultVars)
     : m_name(std::move(name)),
-      m_result_count(resultCount)
+      m_state_bits_index(stateBitsIndex),
+      m_state_bits_mask(stateBitsMask),
+      m_result_vars(std::move(resultVars))
 {
 }
 
-StateMapLayout::StateMapLayout(std::vector<StateMapLayoutEntry> layoutEntries)
+StateMapLayoutEntries::StateMapLayoutEntries(std::vector<StateMapLayoutEntry> entryList)
-    : m_layout_entries(std::move(layoutEntries))
+    : m_entries(std::move(entryList))
+{
+}
+
+StateMapLayoutVarValue::StateMapLayoutVarValue(std::string name, const size_t stateBitsMask)
+    : m_name(std::move(name)),
+      m_state_bits_mask(stateBitsMask)
+{
+}
+
+StateMapLayoutVar::StateMapLayoutVar(std::string name, const size_t stateBitsIndex, std::vector<StateMapLayoutVarValue> values)
+    : m_name(std::move(name)),
+      m_state_bits_index(stateBitsIndex),
+      m_values(std::move(values))
+{
+}
+
+StateMapLayoutVars::StateMapLayoutVars(std::vector<StateMapLayoutVar> varList)
+    : m_vars(std::move(varList))
+{
+}
+
+StateMapLayout::StateMapLayout(const size_t stateBitsCount, const StateMapLayoutEntries& entryLayout, const StateMapLayoutVars& varLayout)
+    : m_state_bits_count(stateBitsCount),
+      m_entry_layout(entryLayout),
+      m_var_layout(varLayout)
 {
 }

src/Common/StateMap/StateMapLayout.h

@@ -8,17 +8,56 @@ namespace state_map
     class StateMapLayoutEntry
     {
     public:
-        StateMapLayoutEntry(std::string name, size_t resultCount);
+        StateMapLayoutEntry(std::string name, size_t stateBitsIndex, size_t stateBitsMask, std::vector<std::string> resultVars);
 
         std::string m_name;
-        size_t m_result_count;
+        size_t m_state_bits_index;
+        size_t m_state_bits_mask;
+        std::vector<std::string> m_result_vars;
+    };
+
+    class StateMapLayoutEntries
+    {
+    public:
+        explicit StateMapLayoutEntries(std::vector<StateMapLayoutEntry> entryList);
+
+        std::vector<StateMapLayoutEntry> m_entries;
+    };
+
+    class StateMapLayoutVarValue
+    {
+    public:
+        StateMapLayoutVarValue(std::string name, size_t stateBitsMask);
+
+        std::string m_name;
+        size_t m_state_bits_mask;
+    };
+
+    class StateMapLayoutVar
+    {
+    public:
+        StateMapLayoutVar(std::string name, size_t stateBitsIndex, std::vector<StateMapLayoutVarValue> values);
+
+        std::string m_name;
+        size_t m_state_bits_index;
+        std::vector<StateMapLayoutVarValue> m_values;
+    };
+
+    class StateMapLayoutVars
+    {
+    public:
+        explicit StateMapLayoutVars(std::vector<StateMapLayoutVar> varList);
+
+        std::vector<StateMapLayoutVar> m_vars;
     };
 
     class StateMapLayout
     {
     public:
-        explicit StateMapLayout(std::vector<StateMapLayoutEntry> layoutEntries);
+        StateMapLayout(size_t stateBitsCount, const StateMapLayoutEntries& entryLayout, const StateMapLayoutVars& varLayout);
 
-        std::vector<StateMapLayoutEntry> m_layout_entries;
+        size_t m_state_bits_count;
+        const StateMapLayoutEntries& m_entry_layout;
+        const StateMapLayoutVars& m_var_layout;
     };
 }

src/ObjCommon/Game/IW4/TechsetConstantsIW4.h

@@ -577,17 +577,322 @@ namespace IW4
         WIREFRAME
     };
 
-    inline state_map::StateMapLayout stateMapLayout({
+
-        {"alphaTest", 1u},
+    inline state_map::StateMapLayoutEntries stateMapEntryLayout({
-        {"blendFunc", 3u},
+        {
-        {"separateAlphaBlendFunc", 3u},
+            "alphaTest", 0, GFXS0_ATEST_MASK, {
-        {"cullFace", 1u},
+                "mtlAlphaTest"
-        {"depthTest", 1u},
+            }
-        {"depthWrite", 1u},
+        },
-        {"colorWrite", 2u},
+        {
-        {"gammaWrite", 1u},
+            "blendFunc", 0, GFXS0_BLEND_RGB_MASK, {
-        {"polygonOffset", 1u},
+                "mtlBlendOp",
-        {"stencil", 9u},
+                "mtlSrcBlend",
-        {"wireframe", 1u},
+                "mtlDestBlend"
+            }
+        },
+        {
+            "separateAlphaBlendFunc", 0, GFXS0_BLEND_ALPHA_MASK, {
+                "mtlBlendOpAlpha",
+                "mtlSrcBlendAlpha",
+                "mtlDestBlendAlpha"
+            }
+        },
+        {
+            "cullFace", 0, GFXS0_CULL_MASK, {
+                "mtlCullFace"
+            }
+        },
+        {
+            "depthTest", 1, GFXS1_DEPTHTEST_MASK, {
+                "mtlDepthTest"
+            }
+        },
+        {
+            "depthWrite", 1, GFXS1_DEPTHWRITE, {
+                "mtlDepthWrite"
+            }
+        },
+        {
+            "colorWrite", 0, GFXS0_COLORWRITE_MASK, {
+                "mtlColorWriteRgb",
+                "mtlColorWriteAlpha"
+            }
+        },
+        {
+            "gammaWrite", 0, GFXS0_GAMMAWRITE, {
+                "mtlGammaWrite",
+            }
+        },
+        {
+            "polygonOffset", 1, GFXS1_POLYGON_OFFSET_MASK, {
+                "mtlPolygonOffset",
+            }
+        },
+        {
+            "stencil", 1, GFXS1_STENCILFUNC_FRONTBACK_MASK | GFXS1_STENCILOP_FRONTBACK_MASK, {
+                "mtlStencil",
+                "mtlStencilFuncFront",
+                "mtlStencilOpFrontPass",
+                "mtlStencilOpFrontFail",
+                "mtlStencilOpFrontZFail",
+                "mtlStencilFuncBack",
+                "mtlStencilOpBackPass",
+                "mtlStencilOpBackFail",
+                "mtlStencilOpBackZFail",
+            }
+        },
+        {
+            "wireframe", 1, GFXS0_POLYMODE_LINE, {
+                "mtlWireframe",
+            }
+        }
     });
+
+    inline state_map::StateMapLayoutVars stateMapVarLayout({
+        {
+            "mtlAlphaTest", 0, {
+                {"Always", GFXS0_ATEST_DISABLE},
+                {"GE128", GFXS0_ATEST_GE_128},
+                {"GT0", GFXS0_ATEST_GT_0},
+                {"LT128", GFXS0_ATEST_LT_128},
+            }
+        },
+        {
+            "mtlBlendOp", 0, {
+                {"Add", GFXS_BLENDOP_ADD << GFXS0_BLENDOP_RGB_SHIFT},
+                {"Subtract", GFXS_BLENDOP_SUBTRACT << GFXS0_BLENDOP_RGB_SHIFT},
+                {"RevSubtract", GFXS_BLENDOP_REVSUBTRACT << GFXS0_BLENDOP_RGB_SHIFT},
+                {"Min", GFXS_BLENDOP_MIN << GFXS0_BLENDOP_RGB_SHIFT},
+                {"Max", GFXS_BLENDOP_MAX << GFXS0_BLENDOP_RGB_SHIFT},
+                {"Disable", GFXS_BLENDOP_DISABLED << GFXS0_BLENDOP_RGB_SHIFT},
+            }
+        },
+        {
+            "mtlSrcBlend", 0, {
+                {"Zero", GFXS_BLEND_ZERO << GFXS0_SRCBLEND_RGB_SHIFT},
+                {"One", GFXS_BLEND_ONE << GFXS0_SRCBLEND_RGB_SHIFT},
+                {"SrcColor", GFXS_BLEND_SRCCOLOR << GFXS0_SRCBLEND_RGB_SHIFT},
+                {"InvSrcColor", GFXS_BLEND_INVSRCCOLOR << GFXS0_SRCBLEND_RGB_SHIFT},
+                {"SrcAlpha", GFXS_BLEND_SRCALPHA << GFXS0_SRCBLEND_RGB_SHIFT},
+                {"InvSrcAlpha", GFXS_BLEND_INVSRCALPHA << GFXS0_SRCBLEND_RGB_SHIFT},
+                {"DestAlpha", GFXS_BLEND_DESTALPHA << GFXS0_SRCBLEND_RGB_SHIFT},
+                {"InvDestAlpha", GFXS_BLEND_INVDESTALPHA << GFXS0_SRCBLEND_RGB_SHIFT},
+                {"DestColor", GFXS_BLEND_DESTCOLOR << GFXS0_SRCBLEND_RGB_SHIFT},
+                {"InvDestColor", GFXS_BLEND_INVDESTCOLOR << GFXS0_SRCBLEND_RGB_SHIFT},
+            }
+        },
+        {
+            "mtlDestBlend", 0, {
+                {"Zero", GFXS_BLEND_ZERO << GFXS0_DSTBLEND_RGB_SHIFT},
+                {"One", GFXS_BLEND_ONE << GFXS0_DSTBLEND_RGB_SHIFT},
+                {"SrcColor", GFXS_BLEND_SRCCOLOR << GFXS0_DSTBLEND_RGB_SHIFT},
+                {"InvSrcColor", GFXS_BLEND_INVSRCCOLOR << GFXS0_DSTBLEND_RGB_SHIFT},
+                {"SrcAlpha", GFXS_BLEND_SRCALPHA << GFXS0_DSTBLEND_RGB_SHIFT},
+                {"InvSrcAlpha", GFXS_BLEND_INVSRCALPHA << GFXS0_DSTBLEND_RGB_SHIFT},
+                {"DestAlpha", GFXS_BLEND_DESTALPHA << GFXS0_DSTBLEND_RGB_SHIFT},
+                {"InvDestAlpha", GFXS_BLEND_INVDESTALPHA << GFXS0_DSTBLEND_RGB_SHIFT},
+                {"DestColor", GFXS_BLEND_DESTCOLOR << GFXS0_DSTBLEND_RGB_SHIFT},
+                {"InvDestColor", GFXS_BLEND_INVDESTCOLOR << GFXS0_DSTBLEND_RGB_SHIFT},
+            }
+        },
+        {
+            "mtlBlendOpAlpha", 0, {
+                {"Add", GFXS_BLENDOP_ADD << GFXS0_BLENDOP_ALPHA_SHIFT},
+                {"Subtract", GFXS_BLENDOP_SUBTRACT << GFXS0_BLENDOP_ALPHA_SHIFT},
+                {"RevSubtract", GFXS_BLENDOP_REVSUBTRACT << GFXS0_BLENDOP_ALPHA_SHIFT},
+                {"Min", GFXS_BLENDOP_MIN << GFXS0_BLENDOP_ALPHA_SHIFT},
+                {"Max", GFXS_BLENDOP_MAX << GFXS0_BLENDOP_ALPHA_SHIFT},
+                {"Disable", GFXS_BLENDOP_DISABLED << GFXS0_BLENDOP_ALPHA_SHIFT},
+            }
+        },
+        {
+            "mtlSrcBlendAlpha", 0, {
+                {"Zero", GFXS_BLEND_ZERO << GFXS0_SRCBLEND_ALPHA_SHIFT},
+                {"One", GFXS_BLEND_ONE << GFXS0_SRCBLEND_ALPHA_SHIFT},
+                {"SrcColor", GFXS_BLEND_SRCCOLOR << GFXS0_SRCBLEND_ALPHA_SHIFT},
+                {"InvSrcColor", GFXS_BLEND_INVSRCCOLOR << GFXS0_SRCBLEND_ALPHA_SHIFT},
+                {"SrcAlpha", GFXS_BLEND_SRCALPHA << GFXS0_SRCBLEND_ALPHA_SHIFT},
+                {"InvSrcAlpha", GFXS_BLEND_INVSRCALPHA << GFXS0_SRCBLEND_ALPHA_SHIFT},
+                {"DestAlpha", GFXS_BLEND_DESTALPHA << GFXS0_SRCBLEND_ALPHA_SHIFT},
+                {"InvDestAlpha", GFXS_BLEND_INVDESTALPHA << GFXS0_SRCBLEND_ALPHA_SHIFT},
+                {"DestColor", GFXS_BLEND_DESTCOLOR << GFXS0_SRCBLEND_ALPHA_SHIFT},
+                {"InvDestColor", GFXS_BLEND_INVDESTCOLOR << GFXS0_SRCBLEND_ALPHA_SHIFT},
+            }
+        },
+        {
+            "mtlDestBlendAlpha", 0, {
+                {"Zero", GFXS_BLEND_ZERO << GFXS0_DSTBLEND_ALPHA_SHIFT},
+                {"One", GFXS_BLEND_ONE << GFXS0_DSTBLEND_ALPHA_SHIFT},
+                {"SrcColor", GFXS_BLEND_SRCCOLOR << GFXS0_DSTBLEND_ALPHA_SHIFT},
+                {"InvSrcColor", GFXS_BLEND_INVSRCCOLOR << GFXS0_DSTBLEND_ALPHA_SHIFT},
+                {"SrcAlpha", GFXS_BLEND_SRCALPHA << GFXS0_DSTBLEND_ALPHA_SHIFT},
+                {"InvSrcAlpha", GFXS_BLEND_INVSRCALPHA << GFXS0_DSTBLEND_ALPHA_SHIFT},
+                {"DestAlpha", GFXS_BLEND_DESTALPHA << GFXS0_DSTBLEND_ALPHA_SHIFT},
+                {"InvDestAlpha", GFXS_BLEND_INVDESTALPHA << GFXS0_DSTBLEND_ALPHA_SHIFT},
+                {"DestColor", GFXS_BLEND_DESTCOLOR << GFXS0_DSTBLEND_ALPHA_SHIFT},
+                {"InvDestColor", GFXS_BLEND_INVDESTCOLOR << GFXS0_DSTBLEND_ALPHA_SHIFT},
+            }
+        },
+        {
+            "mtlCullFace", 0, {
+                {"None", GFXS0_CULL_NONE},
+                {"Back", GFXS0_CULL_BACK},
+                {"Front", GFXS0_CULL_FRONT},
+            }
+        },
+        {
+            "mtlColorWriteRgb", 0, {
+                {"Enable", GFXS0_COLORWRITE_RGB},
+                {"Disable", 0},
+            }
+        },
+        {
+            "mtlColorWriteAlpha", 0, {
+                {"Enable", GFXS0_COLORWRITE_ALPHA},
+                {"Disable", 0},
+            }
+        },
+        {
+            "mtlGammaWrite", 0, {
+                {"Enable", GFXS0_GAMMAWRITE},
+                {"Disable", 0},
+            }
+        },
+        {
+            "mtlWireframe", 0, {
+                {"Enable", GFXS0_POLYMODE_LINE},
+                {"Disable", 0},
+            }
+        },
+        {
+            "mtlDepthTest", 1, {
+                {"Disable", GFXS1_DEPTHTEST_DISABLE},
+                {"Less", GFXS1_DEPTHTEST_LESS},
+                {"LessEqual", GFXS1_DEPTHTEST_LESSEQUAL},
+                {"Equal", GFXS1_DEPTHTEST_EQUAL},
+                {"Always", GFXS1_DEPTHTEST_ALWAYS},
+            }
+        },
+        {
+            "mtlDepthWrite", 1, {
+                {"Enable", GFXS1_DEPTHWRITE},
+                {"Disable", 0},
+            }
+        },
+        {
+            "mtlPolygonOffset", 1, {
+                {"1", GFXS1_POLYGON_OFFSET_1},
+                {"2", GFXS1_POLYGON_OFFSET_2},
+                {"shadowmap", GFXS1_POLYGON_OFFSET_SHADOWMAP},
+                {"0", GFXS1_POLYGON_OFFSET_0},
+            }
+        },
+        {
+            "mtlStencil", 1, {
+                {"Disable", 0},
+                {"OneSided", GFXS1_STENCIL_FRONT_ENABLE},
+                {"TwoSided", GFXS1_STENCIL_FRONT_ENABLE | GFXS1_STENCIL_BACK_ENABLE},
+                {"0", GFXS1_POLYGON_OFFSET_0},
+            }
+        },
+        {
+            "mtlStencilFuncFront", 1, {
+                {"Less", GFXS_STENCILFUNC_LESS << GFXS1_STENCIL_FRONT_FUNC_SHIFT},
+                {"Equal", GFXS_STENCILFUNC_EQUAL << GFXS1_STENCIL_FRONT_FUNC_SHIFT},
+                {"LessEqual", GFXS_STENCILFUNC_LESSEQUAL << GFXS1_STENCIL_FRONT_FUNC_SHIFT},
+                {"Greater", GFXS_STENCILFUNC_GREATER << GFXS1_STENCIL_FRONT_FUNC_SHIFT},
+                {"NotEqual", GFXS_STENCILFUNC_NOTEQUAL << GFXS1_STENCIL_FRONT_FUNC_SHIFT},
+                {"GreaterEqual", GFXS_STENCILFUNC_GREATEREQUAL << GFXS1_STENCIL_FRONT_FUNC_SHIFT},
+                {"Always", GFXS_STENCILFUNC_ALWAYS << GFXS1_STENCIL_FRONT_FUNC_SHIFT},
+                {"Never", GFXS_STENCILFUNC_NEVER << GFXS1_STENCIL_FRONT_FUNC_SHIFT},
+            }
+        },
+        {
+            "mtlStencilOpFrontPass", 1, {
+                {"Zero", GFXS_STENCILOP_ZERO << GFXS1_STENCIL_FRONT_PASS_SHIFT},
+                {"Replace", GFXS_STENCILOP_REPLACE << GFXS1_STENCIL_FRONT_PASS_SHIFT},
+                {"IncrSat", GFXS_STENCILOP_INCRSAT << GFXS1_STENCIL_FRONT_PASS_SHIFT},
+                {"DecrSat", GFXS_STENCILOP_DECRSAT << GFXS1_STENCIL_FRONT_PASS_SHIFT},
+                {"Invert", GFXS_STENCILOP_INVERT << GFXS1_STENCIL_FRONT_PASS_SHIFT},
+                {"Incr", GFXS_STENCILOP_INCR << GFXS1_STENCIL_FRONT_PASS_SHIFT},
+                {"Decr", GFXS_STENCILOP_DECR << GFXS1_STENCIL_FRONT_PASS_SHIFT},
+                {"Keep", GFXS_STENCILOP_KEEP << GFXS1_STENCIL_FRONT_PASS_SHIFT},
+            }
+        },
+        {
+            "mtlStencilOpFrontFail", 1, {
+                {"Zero", GFXS_STENCILOP_ZERO << GFXS1_STENCIL_FRONT_FAIL_SHIFT},
+                {"Replace", GFXS_STENCILOP_REPLACE << GFXS1_STENCIL_FRONT_FAIL_SHIFT},
+                {"IncrSat", GFXS_STENCILOP_INCRSAT << GFXS1_STENCIL_FRONT_FAIL_SHIFT},
+                {"DecrSat", GFXS_STENCILOP_DECRSAT << GFXS1_STENCIL_FRONT_FAIL_SHIFT},
+                {"Invert", GFXS_STENCILOP_INVERT << GFXS1_STENCIL_FRONT_FAIL_SHIFT},
+                {"Incr", GFXS_STENCILOP_INCR << GFXS1_STENCIL_FRONT_FAIL_SHIFT},
+                {"Decr", GFXS_STENCILOP_DECR << GFXS1_STENCIL_FRONT_FAIL_SHIFT},
+                {"Keep", GFXS_STENCILOP_KEEP << GFXS1_STENCIL_FRONT_FAIL_SHIFT},
+            }
+        },
+        {
+            "mtlStencilOpFrontZFail", 1, {
+                {"Zero", GFXS_STENCILOP_ZERO << GFXS1_STENCIL_FRONT_ZFAIL_SHIFT},
+                {"Replace", GFXS_STENCILOP_REPLACE << GFXS1_STENCIL_FRONT_ZFAIL_SHIFT},
+                {"IncrSat", GFXS_STENCILOP_INCRSAT << GFXS1_STENCIL_FRONT_ZFAIL_SHIFT},
+                {"DecrSat", GFXS_STENCILOP_DECRSAT << GFXS1_STENCIL_FRONT_ZFAIL_SHIFT},
+                {"Invert", GFXS_STENCILOP_INVERT << GFXS1_STENCIL_FRONT_ZFAIL_SHIFT},
+                {"Incr", GFXS_STENCILOP_INCR << GFXS1_STENCIL_FRONT_ZFAIL_SHIFT},
+                {"Decr", GFXS_STENCILOP_DECR << GFXS1_STENCIL_FRONT_ZFAIL_SHIFT},
+                {"Keep", GFXS_STENCILOP_KEEP << GFXS1_STENCIL_FRONT_ZFAIL_SHIFT},
+            }
+        },
+        {
+            "mtlStencilFuncBack", 1, {
+                {"Less", GFXS_STENCILFUNC_LESS << GFXS1_STENCIL_BACK_FUNC_SHIFT},
+                {"Equal", GFXS_STENCILFUNC_EQUAL << GFXS1_STENCIL_BACK_FUNC_SHIFT},
+                {"LessEqual", GFXS_STENCILFUNC_LESSEQUAL << GFXS1_STENCIL_BACK_FUNC_SHIFT},
+                {"Greater", GFXS_STENCILFUNC_GREATER << GFXS1_STENCIL_BACK_FUNC_SHIFT},
+                {"NotEqual", GFXS_STENCILFUNC_NOTEQUAL << GFXS1_STENCIL_BACK_FUNC_SHIFT},
+                {"GreaterEqual", GFXS_STENCILFUNC_GREATEREQUAL << GFXS1_STENCIL_BACK_FUNC_SHIFT},
+                {"Always", GFXS_STENCILFUNC_ALWAYS << GFXS1_STENCIL_BACK_FUNC_SHIFT},
+                {"Never", GFXS_STENCILFUNC_NEVER << GFXS1_STENCIL_BACK_FUNC_SHIFT},
+            }
+        },
+        {
+            "mtlStencilOpBackPass", 1, {
+                {"Zero", GFXS_STENCILOP_ZERO << GFXS1_STENCIL_BACK_PASS_SHIFT},
+                {"Replace", GFXS_STENCILOP_REPLACE << GFXS1_STENCIL_BACK_PASS_SHIFT},
+                {"IncrSat", GFXS_STENCILOP_INCRSAT << GFXS1_STENCIL_BACK_PASS_SHIFT},
+                {"DecrSat", GFXS_STENCILOP_DECRSAT << GFXS1_STENCIL_BACK_PASS_SHIFT},
+                {"Invert", GFXS_STENCILOP_INVERT << GFXS1_STENCIL_BACK_PASS_SHIFT},
+                {"Incr", GFXS_STENCILOP_INCR << GFXS1_STENCIL_BACK_PASS_SHIFT},
+                {"Decr", GFXS_STENCILOP_DECR << GFXS1_STENCIL_BACK_PASS_SHIFT},
+                {"Keep", GFXS_STENCILOP_KEEP << GFXS1_STENCIL_BACK_PASS_SHIFT},
+            }
+        },
+        {
+            "mtlStencilOpBackFail", 1, {
+                {"Zero", GFXS_STENCILOP_ZERO << GFXS1_STENCIL_BACK_FAIL_SHIFT},
+                {"Replace", GFXS_STENCILOP_REPLACE << GFXS1_STENCIL_BACK_FAIL_SHIFT},
+                {"IncrSat", GFXS_STENCILOP_INCRSAT << GFXS1_STENCIL_BACK_FAIL_SHIFT},
+                {"DecrSat", GFXS_STENCILOP_DECRSAT << GFXS1_STENCIL_BACK_FAIL_SHIFT},
+                {"Invert", GFXS_STENCILOP_INVERT << GFXS1_STENCIL_BACK_FAIL_SHIFT},
+                {"Incr", GFXS_STENCILOP_INCR << GFXS1_STENCIL_BACK_FAIL_SHIFT},
+                {"Decr", GFXS_STENCILOP_DECR << GFXS1_STENCIL_BACK_FAIL_SHIFT},
+                {"Keep", GFXS_STENCILOP_KEEP << GFXS1_STENCIL_BACK_FAIL_SHIFT},
+            }
+        },
+        {
+            "mtlStencilOpBackZFail", 1, {
+                {"Zero", GFXS_STENCILOP_ZERO << GFXS1_STENCIL_BACK_ZFAIL_SHIFT},
+                {"Replace", GFXS_STENCILOP_REPLACE << GFXS1_STENCIL_BACK_ZFAIL_SHIFT},
+                {"IncrSat", GFXS_STENCILOP_INCRSAT << GFXS1_STENCIL_BACK_ZFAIL_SHIFT},
+                {"DecrSat", GFXS_STENCILOP_DECRSAT << GFXS1_STENCIL_BACK_ZFAIL_SHIFT},
+                {"Invert", GFXS_STENCILOP_INVERT << GFXS1_STENCIL_BACK_ZFAIL_SHIFT},
+                {"Incr", GFXS_STENCILOP_INCR << GFXS1_STENCIL_BACK_ZFAIL_SHIFT},
+                {"Decr", GFXS_STENCILOP_DECR << GFXS1_STENCIL_BACK_ZFAIL_SHIFT},
+                {"Keep", GFXS_STENCILOP_KEEP << GFXS1_STENCIL_BACK_ZFAIL_SHIFT},
+            }
+        },
+    });
+
+    inline state_map::StateMapLayout stateMapLayout(std::extent_v<decltype(GfxStateBits::loadBits)>, stateMapEntryLayout, stateMapVarLayout);
 }

src/ObjLoading/StateMap/Parsing/StateMapParserState.cpp

@@ -4,11 +4,11 @@ using namespace state_map;
 
 StateMapParserState::StateMapParserState(std::string stateMapName, const StateMapLayout& layout)
     : m_layout(layout),
-      m_definition(std::make_unique<StateMapDefinition>(std::move(stateMapName), layout.m_layout_entries.size())),
+      m_definition(std::make_unique<StateMapDefinition>(std::move(stateMapName), layout.m_entry_layout.m_entries.size())),
       m_in_entry(false),
       m_current_entry_index(0u),
       m_current_rule(nullptr)
 {
-    for (auto i = 0u; i < m_layout.m_layout_entries.size(); i++)
+    for (auto i = 0u; i < m_layout.m_entry_layout.m_entries.size(); i++)
-        m_valid_state_map_entry_names.emplace(m_layout.m_layout_entries[i].m_name, i);
+        m_valid_state_map_entry_names.emplace(m_layout.m_entry_layout.m_entries[i].m_name, i);
 }

src/ObjLoading/StateMap/StateMapReader.cpp

@@ -31,11 +31,11 @@ bool StateMapReader::IsValidEndState(const StateMapParserState* state) const
         return false;
     }
 
-    for (auto i = 0u; i < state->m_layout.m_layout_entries.size(); i++)
+    for (auto i = 0u; i < state->m_layout.m_entry_layout.m_entries.size(); i++)
     {
         if (state->m_definition->m_state_map_entries[i].m_rules.empty())
         {
-            std::cerr << "In \"" << m_file_name << "\": State map must define a rule for \"" << state->m_layout.m_layout_entries[i].m_name << "\"!\n";
+            std::cerr << "In \"" << m_file_name << "\": State map must define a rule for \"" << state->m_layout.m_entry_layout.m_entries[i].m_name << "\"!\n";
             return false;
         }
     }