feat: add templated iw4 material loading

src/Common/Game/IW4/IW4_Assets.h

@@ -674,7 +674,7 @@ namespace IW4
         water_t* water;
     };
 
-    enum MaterialTextureFilter
+    enum TextureFilter
     {
         TEXTURE_FILTER_DISABLED = 0x0,
         TEXTURE_FILTER_NEAREST = 0x1,
@@ -685,6 +685,15 @@ namespace IW4
         TEXTURE_FILTER_COUNT
     };
 
+    enum SamplerStateBitsMipMap_e
+    {
+        SAMPLER_MIPMAP_ENUM_DISABLED,
+        SAMPLER_MIPMAP_ENUM_NEAREST,
+        SAMPLER_MIPMAP_ENUM_LINEAR,
+
+        SAMPLER_MIPMAP_ENUM_COUNT
+    };
+
     enum SamplerStateBits_e
     {
         SAMPLER_FILTER_SHIFT = 0x0,
@@ -710,13 +719,26 @@ namespace IW4
         SAMPLER_CLAMP_MASK = 0xE0,
     };
 
+    struct MaterialTextureDefSamplerState
+    {
+        unsigned char filter : 3;
+        unsigned char mipMap : 2;
+        unsigned char clampU : 1;
+        unsigned char clampV : 1;
+        unsigned char clampW : 1;
+    };
+
+#ifndef __zonecodegenerator
+    static_assert(sizeof(MaterialTextureDefSamplerState) == 1u);
+#endif
+
     struct MaterialTextureDef
     {
         unsigned int nameHash;
         char nameStart;
         char nameEnd;
-        unsigned char samplerState; // SamplerStateBits_e
+        MaterialTextureDefSamplerState samplerState; // SamplerStateBits_e
-        unsigned char semantic;     // TextureSemantic
+        unsigned char semantic;                      // TextureSemantic
         MaterialTextureDefInfo u;
     };
 
@@ -724,7 +746,7 @@ namespace IW4
     {
         unsigned int nameHash;
         char name[12];
-        float literal[4];
+        vec4_t literal;
     };
 
     enum GfxBlend : unsigned int
@@ -754,19 +776,36 @@ namespace IW4
         GFXS_BLENDOP_MASK = 0x7,
     };
 
-    enum GfxStencilFunc : unsigned int
+    enum GfxAlphaTest_e
     {
-        GFXS_STENCILFUNC_NEVER = 0x0,
+        GFXS_ALPHA_TEST_GT_0 = 1,
-        GFXS_STENCILFUNC_LESS = 0x1,
+        GFXS_ALPHA_TEST_LT_128 = 2,
-        GFXS_STENCILFUNC_EQUAL = 0x2,
+        GFXS_ALPHA_TEST_GE_128 = 3,
-        GFXS_STENCILFUNC_LESSEQUAL = 0x3,
-        GFXS_STENCILFUNC_GREATER = 0x4,
-        GFXS_STENCILFUNC_NOTEQUAL = 0x5,
-        GFXS_STENCILFUNC_GREATEREQUAL = 0x6,
-        GFXS_STENCILFUNC_ALWAYS = 0x7,
 
-        GFXS_STENCILFUNC_COUNT,
+        GFXS_ALPHA_TEST_COUNT
-        GFXS_STENCILFUNC_MASK = 0x7
+    };
+
+    enum GfxCullFace_e
+    {
+        GFXS_CULL_NONE = 1,
+        GFXS_CULL_BACK = 2,
+        GFXS_CULL_FRONT = 3,
+    };
+
+    enum GfxDepthTest_e
+    {
+        GFXS_DEPTHTEST_ALWAYS = 0,
+        GFXS_DEPTHTEST_LESS = 1,
+        GFXS_DEPTHTEST_EQUAL = 2,
+        GFXS_DEPTHTEST_LESSEQUAL = 3
+    };
+
+    enum GfxPolygonOffset_e
+    {
+        GFXS_POLYGON_OFFSET_0 = 0,
+        GFXS_POLYGON_OFFSET_1 = 1,
+        GFXS_POLYGON_OFFSET_2 = 2,
+        GFXS_POLYGON_OFFSET_SHADOWMAP = 3
     };
 
     enum GfxStencilOp : unsigned int
@@ -784,6 +823,21 @@ namespace IW4
         GFXS_STENCILOP_MASK = 0x7
     };
 
+    enum GfxStencilFunc : unsigned int
+    {
+        GFXS_STENCILFUNC_NEVER = 0x0,
+        GFXS_STENCILFUNC_LESS = 0x1,
+        GFXS_STENCILFUNC_EQUAL = 0x2,
+        GFXS_STENCILFUNC_LESSEQUAL = 0x3,
+        GFXS_STENCILFUNC_GREATER = 0x4,
+        GFXS_STENCILFUNC_NOTEQUAL = 0x5,
+        GFXS_STENCILFUNC_GREATEREQUAL = 0x6,
+        GFXS_STENCILFUNC_ALWAYS = 0x7,
+
+        GFXS_STENCILFUNC_COUNT,
+        GFXS_STENCILFUNC_MASK = 0x7
+    };
+
     enum GfxStateBitsEnum : unsigned int
     {
         GFXS0_SRCBLEND_RGB_SHIFT = 0x0,
@@ -876,9 +930,55 @@ namespace IW4
         GFXS1_STENCILOP_FRONTBACK_MASK = 0x1FF1FF00,
     };
 
+    struct GfxStateBitsLoadBitsStructured
+    {
+        // Byte 0
+        unsigned int srcBlendRgb : 4;       // 0-3
+        unsigned int dstBlendRgb : 4;       // 4-7
+        unsigned int blendOpRgb : 3;        // 8-10
+        unsigned int alphaTestDisabled : 1; // 11
+        unsigned int alphaTest : 2;         // 12-13
+        unsigned int cullFace : 2;          // 14-15
+        unsigned int srcBlendAlpha : 4;     // 16-19
+        unsigned int dstBlendAlpha : 4;     // 20-23
+        unsigned int blendOpAlpha : 3;      // 24-26
+        unsigned int colorWriteRgb : 1;     // 27
+        unsigned int colorWriteAlpha : 1;   // 28
+        unsigned int unused0 : 1;           // 29
+        unsigned int gammaWrite : 1;        // 30
+        unsigned int polymodeLine : 1;      // 31
+
+        // Byte 1
+        unsigned int depthWrite : 1;          // 0
+        unsigned int depthTestDisabled : 1;   // 1
+        unsigned int depthTest : 2;           // 2-3
+        unsigned int polygonOffset : 2;       // 4-5
+        unsigned int stencilFrontEnabled : 1; // 6
+        unsigned int stencilBackEnabled : 1;  // 7
+        unsigned int stencilFrontPass : 3;    // 8-10
+        unsigned int stencilFrontFail : 3;    // 11-13
+        unsigned int stencilFrontZFail : 3;   // 14-16
+        unsigned int stencilFrontFunc : 3;    // 17-19
+        unsigned int stencilBackPass : 3;     // 20-22
+        unsigned int stencilBackFail : 3;     // 23-25
+        unsigned int stencilBackZFail : 3;    // 26-28
+        unsigned int stencilBackFunc : 3;     // 29-31
+    };
+
+    union GfxStateBitsLoadBits
+    {
+        unsigned int raw[2];
+        GfxStateBitsLoadBitsStructured structured;
+    };
+
+#ifndef __zonecodegenerator
+    static_assert(sizeof(GfxStateBitsLoadBits) == 8);
+    static_assert(sizeof(GfxStateBitsLoadBitsStructured) == 8);
+#endif
+
     struct GfxStateBits
     {
-        unsigned int loadBits[2];
+        GfxStateBitsLoadBits loadBits;
     };
 
     struct infoParm_t

src/Common/Game/IW5/IW5_Assets.h

@@ -991,7 +991,7 @@ namespace IW5
         unsigned char constantCount;
         unsigned char stateBitsCount;
         unsigned char stateFlags;
-        unsigned char cameraRegion;
+        unsigned char cameraRegion; // GfxCameraRegionType
         MaterialTechniqueSet* techniqueSet;
         MaterialTextureDef* textureTable;
         MaterialConstantDef* constantTable;

src/ObjCommon/Material/JsonMaterial.h.template

@@ -1,8 +1,11 @@
-#options GAME (IW5, T6)
+#options GAME (IW4, IW5, T6)
 
 #filename "Game/" + GAME + "/Material/JsonMaterial" + GAME + ".h"
 
-#if GAME == "IW5"
+#if GAME == "IW4"
+#define FEATURE_IW4
+#define HAS_WATER
+#elif GAME == "IW5"
 #define FEATURE_IW5
 #define HAS_WATER
 #elif GAME == "T6"
@@ -19,6 +22,7 @@
 #include GAME_HEADER
 
 #include "Json/JsonExtension.h"
+
 #include <memory>
 #include <nlohmann/json.hpp>
 #include <optional>
@@ -71,7 +75,7 @@ namespace GAME
         INVALID,
         DISABLED,
         GT0,
-#ifdef FEATURE_IW5
+#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
         LT128,
 #endif
         GE128
@@ -81,7 +85,7 @@ namespace GAME
         {JsonAlphaTest::INVALID,  nullptr   },
         {JsonAlphaTest::DISABLED, "disabled"},
         {JsonAlphaTest::GT0,      "gt0"     },
-#ifdef FEATURE_IW5
+#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
         {JsonAlphaTest::LT128,    "lt128"   },
 #endif
         {JsonAlphaTest::GE128,    "ge128"   }
@@ -164,7 +168,7 @@ namespace GAME
         GfxBlendOp blendOpAlpha;
         bool colorWriteRgb;
         bool colorWriteAlpha;
-#ifdef FEATURE_IW5
+#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
         bool gammaWrite;
 #endif
         bool polymodeLine;
@@ -308,7 +312,7 @@ namespace GAME
 #endif
 
     NLOHMANN_JSON_SERIALIZE_ENUM(TextureSemantic, {
-#ifdef FEATURE_IW5
+#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
         {TS_2D,               "2D"             },
         {TS_FUNCTION,         "function"       },
         {TS_COLOR_MAP,        "colorMap"       },
@@ -321,7 +325,9 @@ namespace GAME
         {TS_UNUSED_5,         "unused5"        },
         {TS_UNUSED_6,         "unused6"        },
         {TS_WATER_MAP,        "waterMap"       },
+#ifdef FEATURE_IW5
         {TS_DISPLACEMENT_MAP, "displacementMap"},
+#endif
 #elif defined(FEATURE_T6)
         {TS_2D,            "2D"          },
         {TS_FUNCTION,      "function"    },
@@ -421,10 +427,14 @@ namespace GAME
         uint8_t columns;
     };
 
-    NLOHMANN_DEFINE_TYPE_EXTENSION(JsonTextureAtlas, rows, columns);
+    NLOHMANN_DEFINE_TYPE_EXTENSION(
+        JsonTextureAtlas,
+        rows,
+        columns
+    );
 
     NLOHMANN_JSON_SERIALIZE_ENUM(MaterialGameFlags, {
-#ifdef FEATURE_IW5
+#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
         {MTL_GAMEFLAG_1,    "1"   },
         {MTL_GAMEFLAG_2,    "2"   },
         {MTL_GAMEFLAG_4,    "4"   },
@@ -433,11 +443,13 @@ namespace GAME
         {MTL_GAMEFLAG_20,   "20"  },
         {MTL_GAMEFLAG_40,   "40"  },
         {MTL_GAMEFLAG_80,   "80"  },
+#ifdef FEATURE_IW5
         {MTL_GAMEFLAG_100,  "100" },
         {MTL_GAMEFLAG_200,  "200" },
         {MTL_GAMEFLAG_400,  "400" },
         {MTL_GAMEFLAG_800,  "800" },
         {MTL_GAMEFLAG_1000, "1000"},
+#endif
 #elif defined(FEATURE_T6)
         {MTL_GAMEFLAG_1,            "1"           },
         {MTL_GAMEFLAG_2,            "2"           },
@@ -458,12 +470,14 @@ namespace GAME
     });
 
     NLOHMANN_JSON_SERIALIZE_ENUM(GfxCameraRegionType, {
-#ifdef FEATURE_IW5
+#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
         {CAMERA_REGION_LIT_OPAQUE,       "litOpaque"     },
         {CAMERA_REGION_LIT_TRANS,        "litTrans"      },
         {CAMERA_REGION_EMISSIVE,         "emissive"      },
         {CAMERA_REGION_DEPTH_HACK,       "depthHack"     },
+#ifdef FEATURE_IW5
         {CAMERA_REGION_LIGHT_MAP_OPAQUE, "lightMapOpaque"},
+#endif
         {CAMERA_REGION_NONE,             "none"          },
 #elif defined(FEATURE_T6)
         {CAMERA_REGION_LIT_OPAQUE,       "litOpaque"     },

src/ObjLoading/Game/IW4/Material/CompilingMaterialLoad.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "Asset/IAssetCreator.h"
+#include "Game/IW4/IW4.h"
+#include "Gdt/IGdtQueryable.h"
+#include "SearchPath/ISearchPath.h"
+#include "Utils/MemoryManager.h"
+
+namespace IW4
+{
+    std::unique_ptr<AssetCreator<AssetMaterial>> CreateCompilingMaterialLoader(MemoryManager& memory, ISearchPath& searchPath, IGdtQueryable& gdt);
+} // namespace IW4

src/ObjLoading/Game/IW4/Material/LoaderMaterialIW4.h

@@ -8,5 +8,5 @@
 
 namespace IW4
 {
-    std::unique_ptr<AssetCreator<AssetMaterial>> CreateMaterialLoader(MemoryManager& memory, ISearchPath& searchPath, IGdtQueryable& gdt);
+    std::unique_ptr<AssetCreator<AssetMaterial>> CreateMaterialLoader(MemoryManager& memory, ISearchPath& searchPath);
 } // namespace IW4

src/ObjLoading/Game/IW4/ObjLoaderIW4.cpp

@@ -6,6 +6,7 @@
 #include "Leaderboard/LoaderLeaderboardIW4.h"
 #include "LightDef/LoaderLightDefIW4.h"
 #include "Localize/LoaderLocalizeIW4.h"
+#include "Material/CompilingMaterialLoad.h"
 #include "Material/LoaderMaterialIW4.h"
 #include "Menu/LoaderMenuListIW4.h"
 #include "ObjLoading.h"
@@ -126,7 +127,8 @@ namespace
         // collection.AddAssetCreator(std::make_unique<AssetLoaderXAnim>(memory));
         // collection.AddAssetCreator(std::make_unique<AssetLoaderXModelSurfs>(memory));
         // collection.AddAssetCreator(std::make_unique<AssetLoaderXModel>(memory));
-        collection.AddAssetCreator(CreateMaterialLoader(memory, searchPath, gdt));
+        collection.AddAssetCreator(CreateMaterialLoader(memory, searchPath));
+        collection.AddAssetCreator(CreateCompilingMaterialLoader(memory, searchPath, gdt));
         collection.AddAssetCreator(CreatePixelShaderLoader(memory, searchPath));
         collection.AddAssetCreator(CreateVertexShaderLoader(memory, searchPath));
         collection.AddAssetCreator(CreateVertexDeclLoader(memory));

src/ObjLoading/Material/JsonMaterialLoader.cpp.template

@@ -1,8 +1,12 @@
-#options GAME (IW5, T6)
+#options GAME (IW4, IW5, T6)
 
 #filename "Game/" + GAME + "/Material/JsonMaterialLoader" + GAME + ".cpp"
 
-#if GAME == "IW5"
+#if GAME == "IW4"
+#define FEATURE_IW4
+#define HAS_WATER
+#define GAME_LOWER "iw4"
+#elif GAME == "IW5"
 #define FEATURE_IW5
 #define HAS_WATER
 #define GAME_LOWER "iw5"
@@ -90,7 +94,7 @@ namespace
             std::cerr << std::format("Cannot load material \"{}\": {}\n", material.info.name, message);
         }
 
-#ifdef FEATURE_IW5
+#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
         static bool CreateGameFlagsFromJson(const JsonMaterial& jMaterial, unsigned char& gameFlags)
 #elif defined(FEATURE_T6)
         static bool CreateGameFlagsFromJson(const JsonMaterial& jMaterial, unsigned& gameFlags)
@@ -300,7 +304,7 @@ namespace
                 structured.alphaTestDisabled = 0;
                 structured.alphaTest = GFXS_ALPHA_TEST_GT_0;
             }
-#ifdef FEATURE_IW5
+#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
             else if (jStateBitsTableEntry.alphaTest == JsonAlphaTest::LT128)
             {
                 structured.alphaTestDisabled = 0;
@@ -335,7 +339,7 @@ namespace
             structured.blendOpAlpha = jStateBitsTableEntry.blendOpAlpha;
             structured.colorWriteRgb = jStateBitsTableEntry.colorWriteRgb;
             structured.colorWriteAlpha = jStateBitsTableEntry.colorWriteAlpha;
-#ifdef FEATURE_IW5
+#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
             structured.gammaWrite = jStateBitsTableEntry.gammaWrite;
 #endif
             structured.polymodeLine = jStateBitsTableEntry.polymodeLine;

src/ObjLoading/Material/JsonMaterialLoader.h.template

@@ -1,4 +1,4 @@
-#options GAME (IW5, T6)
+#options GAME (IW4, IW5, T6)
 
 #filename "Game/" + GAME + "/Material/JsonMaterialLoader" + GAME + ".h"
 

src/ObjWriting/Game/IW4/Material/AssetDumperMaterial.cpp

@@ -1,9 +1,22 @@
 #include "AssetDumperMaterial.h"
 
 #include "DecompilingMaterialDumperIW4.h"
+#include "Game/IW4/Material/JsonMaterialWriterIW4.h"
+#include "Game/IW4/Material/MaterialConstantZoneState.h"
+#include "Material/MaterialCommon.h"
+
+// #define EXPERIMENTAL_DECOMPILE_MATERIAL 1
 
 using namespace IW4;
 
+void AssetDumperMaterial::DumpPool(AssetDumpingContext& context, AssetPool<Material>* pool)
+{
+    auto* materialConstantState = context.GetZoneAssetDumperState<MaterialConstantZoneState>();
+    materialConstantState->ExtractNamesFromZone();
+
+    AbstractAssetDumper::DumpPool(context, pool);
+}
+
 bool AssetDumperMaterial::ShouldDump(XAssetInfo<Material>* asset)
 {
     return true;
@@ -11,10 +24,17 @@ bool AssetDumperMaterial::ShouldDump(XAssetInfo<Material>* asset)
 
 void AssetDumperMaterial::DumpAsset(AssetDumpingContext& context, XAssetInfo<Material>* asset)
 {
-    const auto* material = asset->Asset();
+#ifdef EXPERIMENTAL_DECOMPILE_MATERIAL
-
     if (context.m_gdt)
     {
-        DecompileMaterialToGdt(*context.m_gdt, *material, context);
+        DecompileMaterialToGdt(*context.m_gdt, *asset->Asset(), context);
     }
+#else
+    const auto assetFile = context.OpenAssetFile(material::GetFileNameForAssetName(asset->m_name));
+
+    if (!assetFile)
+        return;
+
+    DumpMaterialAsJson(*assetFile, *asset->Asset(), context);
+#endif
 }

src/ObjWriting/Game/IW4/Material/AssetDumperMaterial.h

@@ -7,6 +7,9 @@ namespace IW4
 {
     class AssetDumperMaterial final : public AbstractAssetDumper<Material>
     {
+    public:
+        void DumpPool(AssetDumpingContext& context, AssetPool<Material>* pool) override;
+
     protected:
         bool ShouldDump(XAssetInfo<Material>* asset) override;
         void DumpAsset(AssetDumpingContext& context, XAssetInfo<Material>* asset) override;

src/ObjWriting/Game/IW4/Material/DecompilingMaterialDumperIW4.cpp

@@ -564,7 +564,7 @@ namespace
         };
 
         static inline BlendFuncParameters knownBlendFuncs[]{
-            // Only considering passthrough statemap
+  // Only considering passthrough statemap
             {BlendFunc_e::ADD,
              BlendOp_e::ADD,
              CustomBlendFunc_e::ONE,
@@ -601,8 +601,8 @@ namespace
              CustomBlendFunc_e::UNKNOWN,
              CustomBlendFunc_e::UNKNOWN},
 
-            // TODO: Enable when using statemaps
+ // TODO: Enable when using statemaps
-            // Considering default statemap
+  // Considering default statemap
             {BlendFunc_e::ADD,
              BlendOp_e::ADD,
              CustomBlendFunc_e::ONE,
@@ -624,7 +624,7 @@ namespace
              BlendOp_e::ADD,
              CustomBlendFunc_e::INV_DST_ALPHA,
              CustomBlendFunc_e::ONE    },
-            // REPLACE matches passthrough statemap
+ // REPLACE matches passthrough statemap
             {BlendFunc_e::SCREEN_ADD,
              BlendOp_e::ADD,
              CustomBlendFunc_e::INV_DST_COLOR,
@@ -666,12 +666,6 @@ namespace
             m_state_bits_info.m_blend_func = BlendFunc_e::CUSTOM;
         }
 
-        template<typename T> T StateBitsToEnum(const unsigned input, const size_t mask, const size_t shift)
-        {
-            const unsigned value = (input & mask) >> shift;
-            return value >= (static_cast<unsigned>(T::COUNT) - 1) ? T::UNKNOWN : static_cast<T>(value + 1);
-        }
-
         void ExamineStateBitsInfo()
         {
             if (!m_material.stateBitsTable || m_material.stateBitsCount == 0)
@@ -695,37 +689,32 @@ namespace
             }
 
             if (m_state_bits_info.m_custom_blend_op_rgb == BlendOp_e::UNKNOWN)
-                m_state_bits_info.m_custom_blend_op_rgb = StateBitsToEnum<BlendOp_e>(stateBits.loadBits[0], GFXS0_BLENDOP_RGB_MASK, GFXS0_BLENDOP_RGB_SHIFT);
+                m_state_bits_info.m_custom_blend_op_rgb = static_cast<BlendOp_e>(stateBits.loadBits.structured.blendOpRgb);
 
             if (m_state_bits_info.m_custom_blend_op_alpha == BlendOp_e::UNKNOWN)
-                m_state_bits_info.m_custom_blend_op_alpha =
+                m_state_bits_info.m_custom_blend_op_alpha = static_cast<BlendOp_e>(stateBits.loadBits.structured.blendOpAlpha);
-                    StateBitsToEnum<BlendOp_e>(stateBits.loadBits[0], GFXS0_BLENDOP_ALPHA_MASK, GFXS0_BLENDOP_ALPHA_SHIFT);
 
             if (m_state_bits_info.m_custom_src_blend_func == CustomBlendFunc_e::UNKNOWN)
-                m_state_bits_info.m_custom_src_blend_func =
+                m_state_bits_info.m_custom_src_blend_func = static_cast<CustomBlendFunc_e>(stateBits.loadBits.structured.srcBlendRgb);
-                    StateBitsToEnum<CustomBlendFunc_e>(stateBits.loadBits[0], GFXS0_SRCBLEND_RGB_MASK, GFXS0_SRCBLEND_RGB_SHIFT);
 
             if (m_state_bits_info.m_custom_dst_blend_func == CustomBlendFunc_e::UNKNOWN)
-                m_state_bits_info.m_custom_dst_blend_func =
+                m_state_bits_info.m_custom_dst_blend_func = static_cast<CustomBlendFunc_e>(stateBits.loadBits.structured.dstBlendRgb);
-                    StateBitsToEnum<CustomBlendFunc_e>(stateBits.loadBits[0], GFXS0_DSTBLEND_RGB_MASK, GFXS0_DSTBLEND_RGB_SHIFT);
 
             if (m_state_bits_info.m_custom_src_blend_func_alpha == CustomBlendFunc_e::UNKNOWN)
-                m_state_bits_info.m_custom_src_blend_func_alpha =
+                m_state_bits_info.m_custom_src_blend_func_alpha = static_cast<CustomBlendFunc_e>(stateBits.loadBits.structured.srcBlendAlpha);
-                    StateBitsToEnum<CustomBlendFunc_e>(stateBits.loadBits[0], GFXS0_SRCBLEND_ALPHA_MASK, GFXS0_SRCBLEND_ALPHA_SHIFT);
 
             if (m_state_bits_info.m_custom_dst_blend_func_alpha == CustomBlendFunc_e::UNKNOWN)
-                m_state_bits_info.m_custom_dst_blend_func_alpha =
+                m_state_bits_info.m_custom_dst_blend_func_alpha = static_cast<CustomBlendFunc_e>(stateBits.loadBits.structured.dstBlendAlpha);
-                    StateBitsToEnum<CustomBlendFunc_e>(stateBits.loadBits[0], GFXS0_DSTBLEND_ALPHA_MASK, GFXS0_DSTBLEND_ALPHA_SHIFT);
 
             if (m_state_bits_info.m_alpha_test == AlphaTest_e::UNKNOWN)
             {
-                if (stateBits.loadBits[0] & GFXS0_ATEST_DISABLE)
+                if (stateBits.loadBits.structured.alphaTestDisabled)
                     m_state_bits_info.m_alpha_test = AlphaTest_e::ALWAYS;
-                else if ((stateBits.loadBits[0] & GFXS0_ATEST_MASK) == GFXS0_ATEST_GE_128)
+                else if (stateBits.loadBits.structured.alphaTest == GFXS_ALPHA_TEST_GE_128)
                     m_state_bits_info.m_alpha_test = AlphaTest_e::GE128;
-                else if ((stateBits.loadBits[0] & GFXS0_ATEST_MASK) == GFXS0_ATEST_GT_0)
+                else if (stateBits.loadBits.structured.alphaTest == GFXS_ALPHA_TEST_GT_0)
                     m_state_bits_info.m_alpha_test = AlphaTest_e::GT0;
-                else if ((stateBits.loadBits[0] & GFXS0_ATEST_MASK) == GFXS0_ATEST_LT_128)
+                else if (stateBits.loadBits.structured.alphaTest == GFXS_ALPHA_TEST_LT_128)
                     m_state_bits_info.m_alpha_test = AlphaTest_e::LT128;
                 else
                     assert(false);
@@ -733,13 +722,13 @@ namespace
 
             if (m_state_bits_info.m_depth_test == DepthTest_e::UNKNOWN)
             {
-                if (stateBits.loadBits[1] & GFXS1_DEPTHTEST_DISABLE)
+                if (stateBits.loadBits.structured.depthTestDisabled)
                     m_state_bits_info.m_depth_test = DepthTest_e::DISABLE;
-                else if (stateBits.loadBits[1] & GFXS1_DEPTHTEST_LESSEQUAL)
+                else if (stateBits.loadBits.structured.depthTest == GFXS_DEPTHTEST_LESSEQUAL)
                     m_state_bits_info.m_depth_test = DepthTest_e::LESS_EQUAL;
-                else if (stateBits.loadBits[1] & GFXS1_DEPTHTEST_LESS)
+                else if (stateBits.loadBits.structured.depthTest == GFXS_DEPTHTEST_LESS)
                     m_state_bits_info.m_depth_test = DepthTest_e::LESS;
-                else if (stateBits.loadBits[1] & GFXS1_DEPTHTEST_EQUAL)
+                else if (stateBits.loadBits.structured.depthTest == GFXS_DEPTHTEST_EQUAL)
                     m_state_bits_info.m_depth_test = DepthTest_e::EQUAL;
                 else
                     m_state_bits_info.m_depth_test = DepthTest_e::ALWAYS;
@@ -747,85 +736,82 @@ namespace
 
             if (m_state_bits_info.m_depth_write == StateBitsEnabledStatus_e::UNKNOWN)
                 m_state_bits_info.m_depth_write =
-                    (stateBits.loadBits[1] & GFXS1_DEPTHWRITE) ? StateBitsEnabledStatus_e::ENABLED : StateBitsEnabledStatus_e::DISABLED;
+                    stateBits.loadBits.structured.depthWrite ? StateBitsEnabledStatus_e::ENABLED : StateBitsEnabledStatus_e::DISABLED;
 
             if (m_state_bits_info.m_cull_face == CullFace_e::UNKNOWN)
             {
-                if (stateBits.loadBits[0] & GFXS0_CULL_NONE)
+                if (stateBits.loadBits.structured.cullFace == GFXS_CULL_NONE)
                     m_state_bits_info.m_cull_face = CullFace_e::NONE;
-                else if (stateBits.loadBits[0] & GFXS0_CULL_BACK)
+                else if (stateBits.loadBits.structured.cullFace == GFXS_CULL_BACK)
                     m_state_bits_info.m_cull_face = CullFace_e::BACK;
-                else if (stateBits.loadBits[0] & GFXS0_CULL_FRONT)
+                else if (stateBits.loadBits.structured.cullFace == GFXS_CULL_FRONT)
                     m_state_bits_info.m_cull_face = CullFace_e::FRONT;
                 else
                     assert(false);
             }
 
             if (m_state_bits_info.m_polygon_offset == PolygonOffset_e::UNKNOWN)
-                m_state_bits_info.m_polygon_offset =
+                m_state_bits_info.m_polygon_offset = static_cast<PolygonOffset_e>(stateBits.loadBits.structured.polygonOffset);
-                    StateBitsToEnum<PolygonOffset_e>(stateBits.loadBits[1], GFXS1_POLYGON_OFFSET_MASK, GFXS1_POLYGON_OFFSET_SHIFT);
 
             if (m_state_bits_info.m_color_write_rgb == StateBitsEnabledStatus_e::UNKNOWN)
+            {
                 m_state_bits_info.m_color_write_rgb =
-                    (stateBits.loadBits[0] & GFXS0_COLORWRITE_RGB) ? StateBitsEnabledStatus_e::ENABLED : StateBitsEnabledStatus_e::DISABLED;
+                    stateBits.loadBits.structured.colorWriteRgb ? StateBitsEnabledStatus_e::ENABLED : StateBitsEnabledStatus_e::DISABLED;
+            }
 
             if (m_state_bits_info.m_color_write_alpha == StateBitsEnabledStatus_e::UNKNOWN)
+            {
                 m_state_bits_info.m_color_write_alpha =
-                    (stateBits.loadBits[0] & GFXS0_COLORWRITE_ALPHA) ? StateBitsEnabledStatus_e::ENABLED : StateBitsEnabledStatus_e::DISABLED;
+                    stateBits.loadBits.structured.colorWriteAlpha ? StateBitsEnabledStatus_e::ENABLED : StateBitsEnabledStatus_e::DISABLED;
+            }
 
             if (m_state_bits_info.m_gamma_write == StateBitsEnabledStatus_e::UNKNOWN)
+            {
                 m_state_bits_info.m_gamma_write =
-                    (stateBits.loadBits[0] & GFXS0_GAMMAWRITE) ? StateBitsEnabledStatus_e::ENABLED : StateBitsEnabledStatus_e::DISABLED;
+                    stateBits.loadBits.structured.gammaWrite ? StateBitsEnabledStatus_e::ENABLED : StateBitsEnabledStatus_e::DISABLED;
+            }
 
             if (m_state_bits_info.m_stencil_mode == StencilMode_e::UNKNOWN)
             {
-                if ((stateBits.loadBits[1] & GFXS1_STENCIL_BACK_ENABLE) == 0 && (stateBits.loadBits[1] & GFXS1_STENCIL_FRONT_ENABLE) == 0)
+                if (stateBits.loadBits.structured.stencilBackEnabled == 0 && stateBits.loadBits.structured.stencilFrontEnabled == 0)
                 {
                     m_state_bits_info.m_stencil_mode = StencilMode_e::DISABLED;
                 }
-                else if (stateBits.loadBits[1] & GFXS1_STENCIL_BACK_ENABLE)
+                else if (stateBits.loadBits.structured.stencilBackEnabled)
                 {
-                    assert(stateBits.loadBits[1] & GFXS1_STENCIL_FRONT_ENABLE);
+                    assert(stateBits.loadBits.structured.stencilFrontEnabled);
                     m_state_bits_info.m_stencil_mode = StencilMode_e::TWO_SIDED;
                 }
                 else
                 {
-                    assert(stateBits.loadBits[1] & GFXS1_STENCIL_FRONT_ENABLE);
+                    assert(stateBits.loadBits.structured.stencilFrontEnabled);
                     m_state_bits_info.m_stencil_mode = StencilMode_e::ONE_SIDED;
                 }
             }
 
             if (m_state_bits_info.m_stencil_front_func == StencilFunc_e::UNKNOWN)
-                m_state_bits_info.m_stencil_front_func =
+                m_state_bits_info.m_stencil_front_func = static_cast<StencilFunc_e>(stateBits.loadBits.structured.stencilFrontFunc);
-                    StateBitsToEnum<StencilFunc_e>(stateBits.loadBits[1], GFXS1_STENCIL_FRONT_FUNC_MASK, GFXS1_STENCIL_FRONT_FUNC_SHIFT);
 
             if (m_state_bits_info.m_stencil_front_pass == StencilOp_e::UNKNOWN)
-                m_state_bits_info.m_stencil_front_pass =
+                m_state_bits_info.m_stencil_front_pass = static_cast<StencilOp_e>(stateBits.loadBits.structured.stencilFrontPass);
-                    StateBitsToEnum<StencilOp_e>(stateBits.loadBits[1], GFXS1_STENCIL_FRONT_PASS_MASK, GFXS1_STENCIL_FRONT_PASS_SHIFT);
 
             if (m_state_bits_info.m_stencil_front_fail == StencilOp_e::UNKNOWN)
-                m_state_bits_info.m_stencil_front_fail =
+                m_state_bits_info.m_stencil_front_fail = static_cast<StencilOp_e>(stateBits.loadBits.structured.stencilFrontFail);
-                    StateBitsToEnum<StencilOp_e>(stateBits.loadBits[1], GFXS1_STENCIL_FRONT_FAIL_MASK, GFXS1_STENCIL_FRONT_FAIL_SHIFT);
 
             if (m_state_bits_info.m_stencil_front_zfail == StencilOp_e::UNKNOWN)
-                m_state_bits_info.m_stencil_front_zfail =
+                m_state_bits_info.m_stencil_front_zfail = static_cast<StencilOp_e>(stateBits.loadBits.structured.stencilFrontZFail);
-                    StateBitsToEnum<StencilOp_e>(stateBits.loadBits[1], GFXS1_STENCIL_FRONT_ZFAIL_MASK, GFXS1_STENCIL_FRONT_ZFAIL_SHIFT);
 
             if (m_state_bits_info.m_stencil_back_func == StencilFunc_e::UNKNOWN)
-                m_state_bits_info.m_stencil_back_func =
+                m_state_bits_info.m_stencil_back_func = static_cast<StencilFunc_e>(stateBits.loadBits.structured.stencilBackFunc);
-                    StateBitsToEnum<StencilFunc_e>(stateBits.loadBits[1], GFXS1_STENCIL_BACK_FUNC_MASK, GFXS1_STENCIL_BACK_FUNC_SHIFT);
 
             if (m_state_bits_info.m_stencil_back_pass == StencilOp_e::UNKNOWN)
-                m_state_bits_info.m_stencil_back_pass =
+                m_state_bits_info.m_stencil_back_pass = static_cast<StencilOp_e>(stateBits.loadBits.structured.stencilBackPass);
-                    StateBitsToEnum<StencilOp_e>(stateBits.loadBits[1], GFXS1_STENCIL_BACK_PASS_MASK, GFXS1_STENCIL_BACK_PASS_SHIFT);
 
             if (m_state_bits_info.m_stencil_back_fail == StencilOp_e::UNKNOWN)
-                m_state_bits_info.m_stencil_back_fail =
+                m_state_bits_info.m_stencil_back_fail = static_cast<StencilOp_e>(stateBits.loadBits.structured.stencilBackFail);
-                    StateBitsToEnum<StencilOp_e>(stateBits.loadBits[1], GFXS1_STENCIL_BACK_FAIL_MASK, GFXS1_STENCIL_BACK_FAIL_SHIFT);
 
             if (m_state_bits_info.m_stencil_back_zfail == StencilOp_e::UNKNOWN)
-                m_state_bits_info.m_stencil_back_zfail =
+                m_state_bits_info.m_stencil_back_zfail = static_cast<StencilOp_e>(stateBits.loadBits.structured.stencilBackZFail);
-                    StateBitsToEnum<StencilOp_e>(stateBits.loadBits[1], GFXS1_STENCIL_BACK_ZFAIL_MASK, GFXS1_STENCIL_BACK_ZFAIL_SHIFT);
 
             ExamineBlendFunc();
         }
@@ -857,7 +843,7 @@ namespace
 
                 if (constant.nameHash == Common::R_HashString("colorTint"))
                 {
-                    m_constants_info.m_color_tint = Eigen::Vector4f(constant.literal);
+                    m_constants_info.m_color_tint = Eigen::Vector4f(constant.literal.v);
                 }
                 else if (constant.nameHash == Common::R_HashString("envMapParms"))
                 {
@@ -868,19 +854,19 @@ namespace
                 }
                 else if (constant.nameHash == Common::R_HashString("featherParms"))
                 {
-                    m_constants_info.m_zfeather_depth = constant.literal[1];
+                    m_constants_info.m_zfeather_depth = constant.literal.y;
                 }
                 else if (constant.nameHash == Common::R_HashString("falloffBeginColor"))
                 {
-                    m_constants_info.m_falloff_begin_color = Eigen::Vector4f(constant.literal);
+                    m_constants_info.m_falloff_begin_color = Eigen::Vector4f(constant.literal.v);
                 }
                 else if (constant.nameHash == Common::R_HashString("falloffEndColor"))
                 {
-                    m_constants_info.m_falloff_end_color = Eigen::Vector4f(constant.literal);
+                    m_constants_info.m_falloff_end_color = Eigen::Vector4f(constant.literal.v);
                 }
                 else if (constant.nameHash == Common::R_HashString("eyeOffsetParms"))
                 {
-                    m_constants_info.m_eye_offset_depth = constant.literal[0];
+                    m_constants_info.m_eye_offset_depth = constant.literal.x;
                 }
                 else if (constant.nameHash == Common::R_HashString("detailScale"))
                 {
@@ -901,21 +887,20 @@ namespace
                         {
                             const auto detailScaleFactorX = static_cast<float>(colorMapTexture->width) / static_cast<float>(detailMapTexture->width);
                             const auto detailScaleFactorY = static_cast<float>(colorMapTexture->height) / static_cast<float>(detailMapTexture->height);
-                            m_constants_info.m_detail_scale =
+                            m_constants_info.m_detail_scale = Eigen::Vector2f(constant.literal.x / detailScaleFactorX, constant.literal.y / detailScaleFactorY);
-                                Eigen::Vector2f(constant.literal[0] / detailScaleFactorX, constant.literal[1] / detailScaleFactorY);
                         }
                         else
-                            m_constants_info.m_detail_scale = Eigen::Vector2f(constant.literal[0], constant.literal[1]);
+                            m_constants_info.m_detail_scale = Eigen::Vector2f(constant.literal.x, constant.literal.y);
                     }
                     else
                     {
-                        m_constants_info.m_detail_scale = Eigen::Vector2f(constant.literal[0], constant.literal[1]);
+                        m_constants_info.m_detail_scale = Eigen::Vector2f(constant.literal.x, constant.literal.y);
                     }
                 }
                 else if (constant.nameHash == Common::R_HashString("flagParms"))
                 {
-                    m_constants_info.m_flag_speed = constant.literal[0];
+                    m_constants_info.m_flag_speed = constant.literal.x;
-                    m_constants_info.m_flag_phase = constant.literal[1];
+                    m_constants_info.m_flag_phase = constant.literal.y;
                 }
                 else if (constant.nameHash == Common::R_HashString("falloffParms"))
                 {
@@ -927,25 +912,25 @@ namespace
                 }
                 else if (constant.nameHash == Common::R_HashString("distortionScale"))
                 {
-                    m_constants_info.m_distortion_scale = Eigen::Vector2f(constant.literal[0], constant.literal[1]);
+                    m_constants_info.m_distortion_scale = Eigen::Vector2f(constant.literal.x, constant.literal.y);
                 }
                 else if (constant.nameHash == Common::R_HashString("uvAnimParms"))
                 {
-                    m_constants_info.m_uv_scroll_x = constant.literal[0];
+                    m_constants_info.m_uv_scroll_x = constant.literal.x;
-                    m_constants_info.m_uv_scroll_y = constant.literal[1];
+                    m_constants_info.m_uv_scroll_y = constant.literal.y;
-                    m_constants_info.m_uv_rotate = constant.literal[2];
+                    m_constants_info.m_uv_rotate = constant.literal.z;
                 }
                 else if (constant.nameHash == Common::R_HashString("colorObjMin"))
                 {
-                    m_constants_info.m_color_obj_min = Eigen::Vector4f(constant.literal);
+                    m_constants_info.m_color_obj_min = Eigen::Vector4f(constant.literal.v);
                 }
                 else if (constant.nameHash == Common::R_HashString("colorObjMax"))
                 {
-                    m_constants_info.m_color_obj_max = Eigen::Vector4f(constant.literal);
+                    m_constants_info.m_color_obj_max = Eigen::Vector4f(constant.literal.v);
                 }
                 else if (constant.nameHash == Common::R_HashString("waterColor"))
                 {
-                    m_constants_info.m_water_color = Eigen::Vector4f(constant.literal);
+                    m_constants_info.m_water_color = Eigen::Vector4f(constant.literal.v);
                 }
                 else
                 {
@@ -1064,45 +1049,45 @@ namespace
                 }
 
                 TileMode_e tileMode;
-                if (entry.samplerState & SAMPLER_CLAMP_U && entry.samplerState & SAMPLER_CLAMP_V && entry.samplerState & SAMPLER_CLAMP_W)
+                if (entry.samplerState.clampU && entry.samplerState.clampV && entry.samplerState.clampW)
                     tileMode = TileMode_e::TILE_BOTH;
-                else if (entry.samplerState & SAMPLER_CLAMP_U)
+                else if (entry.samplerState.clampU)
                     tileMode = TileMode_e::TILE_VERTICAL;
-                else if (entry.samplerState & SAMPLER_CLAMP_V)
+                else if (entry.samplerState.clampV)
                     tileMode = TileMode_e::TILE_HORIZONTAL;
                 else
                     tileMode = TileMode_e::NO_TILE;
 
                 auto filter = GdtFilter_e::UNKNOWN;
-                if ((entry.samplerState & SAMPLER_FILTER_MASK) == SAMPLER_FILTER_ANISO2X)
+                if (entry.samplerState.filter == TEXTURE_FILTER_ANISO2X)
                 {
-                    if (entry.samplerState & SAMPLER_MIPMAP_NEAREST)
+                    if (entry.samplerState.mipMap == SAMPLER_MIPMAP_ENUM_NEAREST)
                         filter = GdtFilter_e::MIP_2X_BILINEAR;
-                    else if (entry.samplerState & SAMPLER_MIPMAP_LINEAR)
+                    else if (entry.samplerState.mipMap == SAMPLER_MIPMAP_ENUM_LINEAR)
                         filter = GdtFilter_e::MIP_2X_TRILINEAR;
                 }
-                else if ((entry.samplerState & SAMPLER_FILTER_MASK) == SAMPLER_FILTER_ANISO4X)
+                else if (entry.samplerState.filter == TEXTURE_FILTER_ANISO4X)
                 {
-                    if (entry.samplerState & SAMPLER_MIPMAP_NEAREST)
+                    if (entry.samplerState.mipMap == SAMPLER_MIPMAP_ENUM_NEAREST)
                         filter = GdtFilter_e::MIP_4X_BILINEAR;
-                    else if (entry.samplerState & SAMPLER_MIPMAP_LINEAR)
+                    else if (entry.samplerState.mipMap == SAMPLER_MIPMAP_ENUM_LINEAR)
                         filter = GdtFilter_e::MIP_4X_TRILINEAR;
                 }
-                else if ((entry.samplerState & SAMPLER_FILTER_MASK) == SAMPLER_FILTER_NEAREST)
+                else if (entry.samplerState.filter == TEXTURE_FILTER_NEAREST)
                 {
-                    assert((entry.samplerState & SAMPLER_MIPMAP_MASK) == SAMPLER_MIPMAP_DISABLED);
+                    assert(entry.samplerState.mipMap == SAMPLER_MIPMAP_ENUM_DISABLED);
                     filter = GdtFilter_e::NOMIP_NEAREST;
                 }
-                else if ((entry.samplerState & SAMPLER_FILTER_MASK) == SAMPLER_FILTER_LINEAR)
+                else if (entry.samplerState.filter == TEXTURE_FILTER_LINEAR)
                 {
-                    assert((entry.samplerState & SAMPLER_MIPMAP_MASK) == SAMPLER_MIPMAP_DISABLED);
+                    assert(entry.samplerState.mipMap == SAMPLER_MIPMAP_ENUM_DISABLED);
                     filter = GdtFilter_e::NOMIP_BILINEAR;
                 }
 
                 assert(filter != GdtFilter_e::UNKNOWN);
                 if (filter == GdtFilter_e::UNKNOWN)
                 {
-                    std::cout << "Unknown filter/mipmap combination: " << entry.samplerState << "\n";
+                    std::cout << std::format("Unknown filter/mipmap combination: {} {}\n", entry.samplerState.filter, entry.samplerState.mipMap);
                     continue;
                 }
 

src/ObjWriting/Game/IW4/Material/MaterialConstantZoneState.cpp

@@ -0,0 +1,236 @@
+#include "MaterialConstantZoneState.h"
+
+#include "Game/IW4/CommonIW4.h"
+#include "Game/IW4/GameAssetPoolIW4.h"
+#include "Game/IW4/GameIW4.h"
+#include "ObjWriting.h"
+
+namespace IW4
+{
+    const char* KNOWN_CONSTANT_NAMES[]{
+        "worldViewProjectionMatrix",
+        "worldViewMatrix2",
+        "worldViewMatrix1",
+        "worldViewMatrix",
+        "worldOutdoorLookupMatrix",
+        "worldMatrix",
+        "waterColor",
+        "viewportDimensions",
+        "viewProjectionMatrix",
+        "uvScale",
+        "uvAnimParms",
+        "thermalColorOffset",
+        "sunShadowmapPixelAdjust",
+        "ssaoParms",
+        "spotShadowmapPixelAdjust",
+        "shadowmapSwitchPartition",
+        "shadowmapScale",
+        "shadowmapPolygonOffset",
+        "shadowLookupMatrix",
+        "renderTargetSize",
+        "renderSourceSize",
+        "projectionMatrix",
+        "playlistPopulationParams",
+        "pixelCostFracs",
+        "pixelCostDecode",
+        "particleCloudSparkColor2",
+        "particleCloudSparkColor1",
+        "particleCloudSparkColor0",
+        "particleCloudMatrix2",
+        "particleCloudMatrix1",
+        "particleCloudMatrix",
+        "particleCloudColor",
+        "outdoorFeatherParms",
+        "oceanUVAnimParmPaintedFoam",
+        "oceanUVAnimParmOctave2",
+        "oceanUVAnimParmOctave1",
+        "oceanUVAnimParmOctave0",
+        "oceanUVAnimParmFoam",
+        "oceanUVAnimParmDetail1",
+        "oceanUVAnimParmDetail0",
+        "oceanScrollParms",
+        "oceanMiscParms",
+        "oceanFoamParms",
+        "oceanAmplitude",
+        "materialColor",
+        "lightprobeAmbient",
+        "lightingLookupScale",
+        "lightSpotFactors",
+        "lightSpotDir",
+        "lightSpecular",
+        "lightPosition",
+        "lightFalloffPlacement",
+        "lightDiffuse",
+        "inverseWorldViewMatrix",
+        "inverseViewProjectionMatrix",
+        "inverseTransposeWorldViewMatrix",
+        "heatMapDetail",
+        "glowSetup",
+        "glowApply",
+        "gameTime",
+        "fullscreenDistortion",
+        "fogSunDir",
+        "fogSunConsts",
+        "fogSunColorLinear",
+        "fogSunColorGamma",
+        "fogConsts",
+        "fogColorLinear",
+        "fogColorGamma",
+        "flagParms",
+        "filterTap",
+        "featherParms",
+        "falloffParms",
+        "falloffEndColor",
+        "falloffBeginColor",
+        "fadeEffect",
+        "eyeOffsetParms",
+        "eyeOffset",
+        "envMapParms",
+        "dustTint",
+        "dustParms",
+        "dustEyeParms",
+        "dofRowDelta",
+        "dofLerpScale",
+        "dofLerpBias",
+        "dofEquationViewModelAndFarBlur",
+        "dofEquationScene",
+        "distortionScale",
+        "detailScale",
+        "depthFromClip",
+        "debugBumpmap",
+        "colorTintQuadraticDelta",
+        "colorTintDelta",
+        "colorTintBase",
+        "colorSaturationR",
+        "colorSaturationG",
+        "colorSaturationB",
+        "colorObjMin",
+        "colorObjMax",
+        "colorMatrixR",
+        "colorMatrixG",
+        "colorMatrixB",
+        "colorBias",
+        "codeMeshArg",
+        "clipSpaceLookupScale",
+        "clipSpaceLookupOffset",
+        "baseLightingCoords",
+    };
+
+    const char* KNOWN_TEXTURE_DEF_NAMES[]{
+        "attenuation",
+        "attenuationSampler",
+        "cinematicA",
+        "cinematicASampler",
+        "cinematicCb",
+        "cinematicCbSampler",
+        "cinematicCr",
+        "cinematicCrSampler",
+        "cinematicY",
+        "cinematicYSampler",
+        "colorMap",
+        "colorMap1",
+        "colorMap2",
+        "colorMapPostSun",
+        "colorMapPostSunSampler",
+        "colorMapSampler",
+        "colorMapSampler1",
+        "colorMapSampler2",
+        "cucoloris",
+        "cucolorisSampler",
+        "detailMap",
+        "detailMapSampler",
+        "dust",
+        "dustSampler",
+        "fadeMap",
+        "fadeMapSampler",
+        "floatZ",
+        "floatZSampler",
+        "grainMap",
+        "grainMapSampler",
+        "halfParticleColor",
+        "halfParticleColorSampler",
+        "halfParticleDepth",
+        "halfParticleDepthSampler",
+        "heatmap",
+        "heatmapSampler",
+        "lightmapPrimary",
+        "lightmapSamplerPrimary",
+        "lightmapSamplerSecondary",
+        "lightmapSecondary",
+        "lookupMap",
+        "lookupMapSampler",
+        "modelLighting",
+        "modelLightingSampler",
+        "normalMap",
+        "normalMapSampler",
+        "oceanColorRamp",
+        "oceanColorRampSampler",
+        "oceanDetailNormal",
+        "oceanDetailNormalSampler",
+        "oceanDisplacement",
+        "oceanDisplacementSampler",
+        "oceanEnv",
+        "oceanEnvSampler",
+        "oceanFoam",
+        "oceanFoamSampler",
+        "oceanHeightNormal",
+        "oceanHeightNormalSampler",
+        "oceanPaintedFoam",
+        "oceanPaintedFoamSampler",
+        "outdoorMap",
+        "outdoorMapSampler",
+        "population",
+        "populationSampler",
+        "reflectionProbe",
+        "reflectionProbeSampler",
+        "shadowmapSamplerSpot",
+        "shadowmapSamplerSun",
+        "shadowmapSpot",
+        "shadowmapSun",
+        "skyMap",
+        "skyMapSampler",
+        "specularMap",
+        "specularMapSampler",
+        "ssao",
+        "ssaoSampler",
+        "worldMap",
+        "worldMapSampler",
+    };
+
+    void MaterialConstantZoneState::ExtractNamesFromZoneInternal()
+    {
+        for (const auto* zone : IGame::GetGameById(GameId::IW5)->GetZones())
+        {
+            const auto* iw5AssetPools = dynamic_cast<const GameAssetPoolIW4*>(zone->m_pools.get());
+            if (!iw5AssetPools)
+                return;
+
+            for (const auto* vertexShaderAsset : *iw5AssetPools->m_material_vertex_shader)
+            {
+                const auto* vertexShader = vertexShaderAsset->Asset();
+                if (ShouldDumpFromStruct(vertexShader))
+                    ExtractNamesFromShader(vertexShader->prog.loadDef.program, static_cast<size_t>(vertexShader->prog.loadDef.programSize) * sizeof(uint32_t));
+            }
+
+            for (const auto* pixelShaderAsset : *iw5AssetPools->m_material_pixel_shader)
+            {
+                const auto* pixelShader = pixelShaderAsset->Asset();
+                if (ShouldDumpFromStruct(pixelShader))
+                    ExtractNamesFromShader(pixelShader->prog.loadDef.program, static_cast<size_t>(pixelShader->prog.loadDef.programSize) * sizeof(uint32_t));
+            }
+        }
+    }
+
+    void MaterialConstantZoneState::AddStaticKnownNames()
+    {
+        for (const auto* knownConstantName : KNOWN_CONSTANT_NAMES)
+            AddConstantName(knownConstantName);
+        for (const auto* knownTextureDefName : KNOWN_TEXTURE_DEF_NAMES)
+            AddTextureDefName(knownTextureDefName);
+    }
+
+    unsigned MaterialConstantZoneState::HashString(const std::string& str)
+    {
+        return Common::R_HashString(str.c_str());
+    }
+} // namespace IW4

src/ObjWriting/Game/IW4/Material/MaterialConstantZoneState.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "Material/AbstractMaterialConstantZoneState.h"
+
+#include <string>
+
+namespace IW4
+{
+    class MaterialConstantZoneState final : public AbstractMaterialConstantZoneStateDx9
+    {
+    protected:
+        void ExtractNamesFromZoneInternal() override;
+        void AddStaticKnownNames() override;
+        unsigned HashString(const std::string& str) override;
+    };
+} // namespace IW4

src/ObjWriting/Material/JsonMaterialWriter.cpp.template

@@ -1,8 +1,12 @@
-#options GAME (IW5, T6)
+#options GAME (IW4, IW5, T6)
 
 #filename "Game/" + GAME + "/Material/JsonMaterialWriter" + GAME + ".cpp"
 
-#if GAME == "IW5"
+#if GAME == "IW4"
+#define FEATURE_IW4
+#define HAS_WATER
+#define GAME_LOWER "iw4"
+#elif GAME == "IW5"
 #define FEATURE_IW5
 #define HAS_WATER
 #define GAME_LOWER "iw5"
@@ -214,7 +218,7 @@ namespace
 
             assert(structured.alphaTestDisabled
                     || structured.alphaTest == GFXS_ALPHA_TEST_GT_0
-#ifdef FEATURE_IW5
+#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
                     || structured.alphaTest == GFXS_ALPHA_TEST_LT_128
 #endif
                     || structured.alphaTest == GFXS_ALPHA_TEST_GE_128);
@@ -222,7 +226,7 @@ namespace
                 jStateBitsTableEntry.alphaTest = JsonAlphaTest::DISABLED;
             else if (structured.alphaTest == GFXS_ALPHA_TEST_GT_0)
                 jStateBitsTableEntry.alphaTest = JsonAlphaTest::GT0;
-#ifdef FEATURE_IW5
+#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
             else if (structured.alphaTest == GFXS_ALPHA_TEST_LT_128)
                 jStateBitsTableEntry.alphaTest = JsonAlphaTest::LT128;
 #endif
@@ -246,7 +250,7 @@ namespace
             jStateBitsTableEntry.blendOpAlpha = static_cast<GfxBlendOp>(structured.blendOpAlpha);
             jStateBitsTableEntry.colorWriteRgb = structured.colorWriteRgb;
             jStateBitsTableEntry.colorWriteAlpha = structured.colorWriteAlpha;
-#ifdef FEATURE_IW5
+#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
             jStateBitsTableEntry.gammaWrite = structured.gammaWrite;
 #endif
             jStateBitsTableEntry.polymodeLine = structured.polymodeLine;

src/ObjWriting/Material/JsonMaterialWriter.h.template

@@ -1,4 +1,4 @@
-#options GAME (IW5, T6)
+#options GAME (IW4, IW5, T6)
 
 #filename "Game/" + GAME + "/Material/JsonMaterialWriter" + GAME + ".h"