Merge pull request #716 from Laupetin/feature/techset-iw5

feat: add techset dumping for iw5

src/Common/Game/IW4/IW4_Assets.h

@@ -1327,15 +1327,6 @@ namespace IW4
         CUSTOM_SAMPLER_COUNT
     };
 
-    struct CodeSamplerSource
-    {
-        const char* name;
-        MaterialTextureSource source;
-        CodeSamplerSource* subtable;
-        int arrayCount;
-        int arrayStride;
-    };
-
     enum MaterialType
     {
         MTL_TYPE_DEFAULT = 0x0,

src/Common/Game/IW5/IW5.h

@@ -237,6 +237,8 @@ namespace IW5
     using AssetTracer = Asset<ASSET_TYPE_TRACER, TracerDef>;
     using AssetVehicle = Asset<ASSET_TYPE_VEHICLE, VehicleDef>;
     using AssetAddonMapEnts = Asset<ASSET_TYPE_ADDON_MAP_ENTS, AddonMapEnts>;
+
+    using SubAssetTechnique = SubAsset<SUB_ASSET_TYPE_TECHNIQUE, MaterialTechnique>;
 } // namespace IW5
 
 DEFINE_ASSET_NAME_ACCESSOR(IW5::AssetPhysPreset, name);

src/Common/Game/IW5/IW5_Assets.h

@@ -967,10 +967,261 @@ namespace IW5
         MaterialVertexShaderProgram prog;
     };
 
+    enum MaterialTextureSource
+    {
+        TEXTURE_SRC_CODE_BLACK = 0x0,
+        TEXTURE_SRC_CODE_WHITE = 0x1,
+        TEXTURE_SRC_CODE_IDENTITY_NORMAL_MAP = 0x2,
+        TEXTURE_SRC_CODE_MODEL_LIGHTING = 0x3,
+        TEXTURE_SRC_CODE_LIGHTMAP_PRIMARY = 0x4,
+        TEXTURE_SRC_CODE_LIGHTMAP_SECONDARY = 0x5,
+        TEXTURE_SRC_CODE_SHADOWMAP_SUN = 0x6,
+        TEXTURE_SRC_CODE_SHADOWMAP_SPOT = 0x7,
+        TEXTURE_SRC_CODE_FEEDBACK = 0x8,
+        TEXTURE_SRC_CODE_RESOLVED_POST_SUN = 0x9,
+        TEXTURE_SRC_CODE_RESOLVED_SCENE = 0xA,
+        TEXTURE_SRC_CODE_POST_EFFECT_0 = 0xB,
+        TEXTURE_SRC_CODE_POST_EFFECT_1 = 0xC,
+        TEXTURE_SRC_CODE_LIGHT_ATTENUATION = 0xD,
+        TEXTURE_SRC_CODE_LIGHT_CUCOLORIS = 0xE,
+        TEXTURE_SRC_CODE_OUTDOOR = 0xF,
+        TEXTURE_SRC_CODE_FLOATZ = 0x10,
+        TEXTURE_SRC_CODE_PROCESSED_FLOATZ = 0x11,
+        TEXTURE_SRC_CODE_RAW_FLOATZ = 0x12,
+        TEXTURE_SRC_CODE_HALF_PARTICLES = 0x13,
+        TEXTURE_SRC_CODE_HALF_PARTICLES_Z = 0x14,
+        TEXTURE_SRC_CODE_CASE_TEXTURE = 0x15,
+        TEXTURE_SRC_CODE_CINEMATIC_Y = 0x16,
+        TEXTURE_SRC_CODE_CINEMATIC_CR = 0x17,
+        TEXTURE_SRC_CODE_CINEMATIC_CB = 0x18,
+        TEXTURE_SRC_CODE_CINEMATIC_A = 0x19,
+        TEXTURE_SRC_CODE_REFLECTION_PROBE = 0x1A,
+        TEXTURE_SRC_CODE_PIP_SCENE = 0x1B,
+        TEXTURE_SRC_CODE_COLOR_MANIPULATION = 0x1C,
+        TEXTURE_SRC_CODE_STREAMING_LOADING = 0x1D,
+
+        TEXTURE_SRC_CODE_COUNT
+    };
+
+    enum CustomSamplers
+    {
+        CUSTOM_SAMPLER_REFLECTION_PROBE = 0x0,
+        CUSTOM_SAMPLER_LIGHTMAP_PRIMARY = 0x1,
+        CUSTOM_SAMPLER_LIGHTMAP_SECONDARY = 0x2,
+        CUSTOM_SAMPLER_COUNT = 0x3,
+    };
+
+    enum MaterialConstantSource
+    {
+        CONST_SRC_CODE_MAYBE_DIRTY_PS_BEGIN = 0x0,
+
+        CONST_SRC_CODE_LIGHT_POSITION = 0x0,
+        CONST_SRC_CODE_LIGHT_DIFFUSE = 0x1,
+        CONST_SRC_CODE_LIGHT_SPECULAR = 0x2,
+        CONST_SRC_CODE_LIGHT_SPOTDIR = 0x3,
+        CONST_SRC_CODE_LIGHT_SPOTFACTORS = 0x4,
+        CONST_SRC_CODE_LIGHT_FALLOFF_PLACEMENT = 0x5,
+        CONST_SRC_CODE_PARTICLE_CLOUD_COLOR = 0x6,
+        CONST_SRC_CODE_GAMETIME = 0x7,
+        CONST_SRC_CODE_EYEOFFSET = 0x8,
+        CONST_SRC_CODE_COLOR_SATURATION_R = 0x9,
+        CONST_SRC_CODE_COLOR_SATURATION_G = 0xA,
+        CONST_SRC_CODE_COLOR_SATURATION_B = 0xB,
+
+        CONST_SRC_CODE_MAYBE_DIRTY_PS_END = 0xC,
+        CONST_SRC_CODE_ALWAYS_DIRTY_PS_BEGIN = 0xC,
+
+        CONST_SRC_CODE_SSAO_PARMS = 0xC,
+        CONST_SRC_CODE_PIXEL_COST_FRACS = 0xD,
+        CONST_SRC_CODE_PIXEL_COST_DECODE = 0xE,
+        CONST_SRC_CODE_FILTER_TAP_0 = 0xF,
+        CONST_SRC_CODE_FILTER_TAP_1 = 0x10,
+        CONST_SRC_CODE_FILTER_TAP_2 = 0x11,
+        CONST_SRC_CODE_FILTER_TAP_3 = 0x12,
+        CONST_SRC_CODE_FILTER_TAP_4 = 0x13,
+        CONST_SRC_CODE_FILTER_TAP_5 = 0x14,
+        CONST_SRC_CODE_FILTER_TAP_6 = 0x15,
+        CONST_SRC_CODE_FILTER_TAP_7 = 0x16,
+        CONST_SRC_CODE_COLOR_MATRIX_R = 0x17,
+        CONST_SRC_CODE_COLOR_MATRIX_G = 0x18,
+        CONST_SRC_CODE_COLOR_MATRIX_B = 0x19,
+        CONST_SRC_CODE_SHADOWMAP_POLYGON_OFFSET = 0x1A,
+        CONST_SRC_CODE_RENDER_TARGET_SIZE = 0x1B,
+        CONST_SRC_CODE_RENDER_SOURCE_SIZE = 0x1C,
+
+        CONST_SRC_CODE_ALWAYS_DIRTY_PS_END = 0x1D,
+        CONST_SRC_CODE_FIXED_PS_BEGIN = 0x1D,
+
+        CONST_SRC_CODE_DOF_EQUATION_VIEWMODEL_AND_FAR_BLUR = 0x1D,
+        CONST_SRC_CODE_DOF_EQUATION_SCENE = 0x1E,
+        CONST_SRC_CODE_DOF_LERP_SCALE = 0x1F,
+        CONST_SRC_CODE_DOF_LERP_BIAS = 0x20,
+        CONST_SRC_CODE_DOF_ROW_DELTA = 0x21,
+        CONST_SRC_CODE_MOTION_MATRIX_X = 0x22,
+        CONST_SRC_CODE_MOTION_MATRIX_Y = 0x23,
+        CONST_SRC_CODE_MOTION_MATRIX_W = 0x24,
+        CONST_SRC_CODE_SHADOWMAP_SWITCH_PARTITION = 0x25,
+        CONST_SRC_CODE_SHADOWMAP_SCALE = 0x26,
+        CONST_SRC_CODE_ZNEAR = 0x27,
+        CONST_SRC_CODE_LIGHTING_LOOKUP_SCALE = 0x28,
+        CONST_SRC_CODE_DEBUG_BUMPMAP = 0x29,
+        CONST_SRC_CODE_MATERIAL_COLOR = 0x2A,
+        CONST_SRC_CODE_FOG = 0x2B,
+        CONST_SRC_CODE_FOG_COLOR_LINEAR = 0x2C,
+        CONST_SRC_CODE_FOG_COLOR_GAMMA = 0x2D,
+        CONST_SRC_CODE_FOG_SUN_CONSTS = 0x2E,
+        CONST_SRC_CODE_FOG_SUN_COLOR_LINEAR = 0x2F,
+        CONST_SRC_CODE_FOG_SUN_COLOR_GAMMA = 0x30,
+        CONST_SRC_CODE_FOG_SUN_DIR = 0x31,
+        CONST_SRC_CODE_GLOW_SETUP = 0x32,
+        CONST_SRC_CODE_GLOW_APPLY = 0x33,
+        CONST_SRC_CODE_COLOR_BIAS = 0x34,
+        CONST_SRC_CODE_COLOR_TINT_BASE = 0x35,
+        CONST_SRC_CODE_COLOR_TINT_DELTA = 0x36,
+        CONST_SRC_CODE_COLOR_TINT_QUADRATIC_DELTA = 0x37,
+        CONST_SRC_CODE_OUTDOOR_FEATHER_PARMS = 0x38,
+        CONST_SRC_CODE_ENVMAP_PARMS = 0x39,
+        CONST_SRC_CODE_SUN_SHADOWMAP_PIXEL_ADJUST = 0x3A,
+        CONST_SRC_CODE_SPOT_SHADOWMAP_PIXEL_ADJUST = 0x3B,
+        CONST_SRC_CODE_COMPOSITE_FX_DISTORTION = 0x3C,
+        CONST_SRC_CODE_POSTFX_FADE_EFFECT = 0x3D,
+        CONST_SRC_CODE_VIEWPORT_DIMENSIONS = 0x3E,
+        CONST_SRC_CODE_FRAMEBUFFER_READ = 0x3F,
+        CONST_SRC_CODE_THERMAL_COLOR_OFFSET = 0x40,
+        CONST_SRC_CODE_PLAYLIST_POPULATION_PARAMS = 0x41,
+
+        CONST_SRC_CODE_FIXED_PS_END = 0x42,
+        CONST_SRC_CODE_NON_PS_BEGIN = 0x42,
+
+        CONST_SRC_CODE_BASE_LIGHTING_COORDS = 0x42,
+        CONST_SRC_CODE_LIGHT_PROBE_AMBIENT = 0x43,
+        CONST_SRC_CODE_NEARPLANE_ORG = 0x44,
+        CONST_SRC_CODE_NEARPLANE_DX = 0x45,
+        CONST_SRC_CODE_NEARPLANE_DY = 0x46,
+        CONST_SRC_CODE_CLIP_SPACE_LOOKUP_SCALE = 0x47,
+        CONST_SRC_CODE_CLIP_SPACE_LOOKUP_OFFSET = 0x48,
+        CONST_SRC_CODE_PARTICLE_CLOUD_MATRIX0 = 0x49,
+        CONST_SRC_CODE_PARTICLE_CLOUD_MATRIX1 = 0x4A,
+        CONST_SRC_CODE_PARTICLE_CLOUD_MATRIX2 = 0x4B,
+        CONST_SRC_CODE_PARTICLE_CLOUD_SPARK_COLOR0 = 0x4C,
+        CONST_SRC_CODE_PARTICLE_CLOUD_SPARK_COLOR1 = 0x4D,
+        CONST_SRC_CODE_PARTICLE_CLOUD_SPARK_COLOR2 = 0x4E,
+        CONST_SRC_CODE_PARTICLE_FOUNTAIN_PARM0 = 0x4F,
+        CONST_SRC_CODE_PARTICLE_FOUNTAIN_PARM1 = 0x50,
+        CONST_SRC_CODE_DEPTH_FROM_CLIP = 0x51,
+        CONST_SRC_CODE_CODE_MESH_ARG_0 = 0x52,
+        CONST_SRC_CODE_CODE_MESH_ARG_1 = 0x53,
+
+        CONST_SRC_CODE_CODE_MESH_ARG_LAST = 0x53,
+        CONST_SRC_CODE_NON_PS_END = 0x54,
+        CONST_SRC_CODE_COUNT_FLOAT4 = 0x54,
+        CONST_SRC_FIRST_CODE_MATRIX = 0x54,
+
+        CONST_SRC_CODE_VIEW_MATRIX = 0x54,
+        CONST_SRC_CODE_INVERSE_VIEW_MATRIX = 0x55,
+        CONST_SRC_CODE_TRANSPOSE_VIEW_MATRIX = 0x56,
+        CONST_SRC_CODE_INVERSE_TRANSPOSE_VIEW_MATRIX = 0x57,
+        CONST_SRC_CODE_PROJECTION_MATRIX = 0x58,
+        CONST_SRC_CODE_INVERSE_PROJECTION_MATRIX = 0x59,
+        CONST_SRC_CODE_TRANSPOSE_PROJECTION_MATRIX = 0x5A,
+        CONST_SRC_CODE_INVERSE_TRANSPOSE_PROJECTION_MATRIX = 0x5B,
+        CONST_SRC_CODE_VIEW_PROJECTION_MATRIX = 0x5C,
+        CONST_SRC_CODE_INVERSE_VIEW_PROJECTION_MATRIX = 0x5D,
+        CONST_SRC_CODE_TRANSPOSE_VIEW_PROJECTION_MATRIX = 0x5E,
+        CONST_SRC_CODE_INVERSE_TRANSPOSE_VIEW_PROJECTION_MATRIX = 0x5F,
+        CONST_SRC_CODE_SHADOW_LOOKUP_MATRIX = 0x60,
+        CONST_SRC_CODE_INVERSE_SHADOW_LOOKUP_MATRIX = 0x61,
+        CONST_SRC_CODE_TRANSPOSE_SHADOW_LOOKUP_MATRIX = 0x62,
+        CONST_SRC_CODE_INVERSE_TRANSPOSE_SHADOW_LOOKUP_MATRIX = 0x63,
+        CONST_SRC_CODE_WORLD_OUTDOOR_LOOKUP_MATRIX = 0x64,
+        CONST_SRC_CODE_INVERSE_WORLD_OUTDOOR_LOOKUP_MATRIX = 0x65,
+        CONST_SRC_CODE_TRANSPOSE_WORLD_OUTDOOR_LOOKUP_MATRIX = 0x66,
+        CONST_SRC_CODE_INVERSE_TRANSPOSE_WORLD_OUTDOOR_LOOKUP_MATRIX = 0x67,
+        CONST_SRC_CODE_WORLD_MATRIX0 = 0x68,
+        CONST_SRC_CODE_INVERSE_WORLD_MATRIX0 = 0x69,
+        CONST_SRC_CODE_TRANSPOSE_WORLD_MATRIX0 = 0x6A,
+        CONST_SRC_CODE_INVERSE_TRANSPOSE_WORLD_MATRIX0 = 0x6B,
+        CONST_SRC_CODE_WORLD_VIEW_MATRIX0 = 0x6C,
+        CONST_SRC_CODE_INVERSE_WORLD_VIEW_MATRIX0 = 0x6D,
+        CONST_SRC_CODE_TRANSPOSE_WORLD_VIEW_MATRIX0 = 0x6E,
+        CONST_SRC_CODE_INVERSE_TRANSPOSE_WORLD_VIEW_MATRIX0 = 0x6F,
+        CONST_SRC_CODE_WORLD_VIEW_PROJECTION_MATRIX0 = 0x70,
+        CONST_SRC_CODE_INVERSE_WORLD_VIEW_PROJECTION_MATRIX0 = 0x71,
+        CONST_SRC_CODE_TRANSPOSE_WORLD_VIEW_PROJECTION_MATRIX0 = 0x72,
+        CONST_SRC_CODE_INVERSE_TRANSPOSE_WORLD_VIEW_PROJECTION_MATRIX0 = 0x73,
+        CONST_SRC_CODE_WORLD_MATRIX1 = 0x74,
+        CONST_SRC_CODE_INVERSE_WORLD_MATRIX1 = 0x75,
+        CONST_SRC_CODE_TRANSPOSE_WORLD_MATRIX1 = 0x76,
+        CONST_SRC_CODE_INVERSE_TRANSPOSE_WORLD_MATRIX1 = 0x77,
+        CONST_SRC_CODE_WORLD_VIEW_MATRIX1 = 0x78,
+        CONST_SRC_CODE_INVERSE_WORLD_VIEW_MATRIX1 = 0x79,
+        CONST_SRC_CODE_TRANSPOSE_WORLD_VIEW_MATRIX1 = 0x7A,
+        CONST_SRC_CODE_INVERSE_TRANSPOSE_WORLD_VIEW_MATRIX1 = 0x7B,
+        CONST_SRC_CODE_WORLD_VIEW_PROJECTION_MATRIX1 = 0x7C,
+        CONST_SRC_CODE_INVERSE_WORLD_VIEW_PROJECTION_MATRIX1 = 0x7D,
+        CONST_SRC_CODE_TRANSPOSE_WORLD_VIEW_PROJECTION_MATRIX1 = 0x7E,
+        CONST_SRC_CODE_INVERSE_TRANSPOSE_WORLD_VIEW_PROJECTION_MATRIX1 = 0x7F,
+        CONST_SRC_CODE_WORLD_MATRIX2 = 0x80,
+        CONST_SRC_CODE_INVERSE_WORLD_MATRIX2 = 0x81,
+        CONST_SRC_CODE_TRANSPOSE_WORLD_MATRIX2 = 0x82,
+        CONST_SRC_CODE_INVERSE_TRANSPOSE_WORLD_MATRIX2 = 0x83,
+        CONST_SRC_CODE_WORLD_VIEW_MATRIX2 = 0x84,
+        CONST_SRC_CODE_INVERSE_WORLD_VIEW_MATRIX2 = 0x85,
+        CONST_SRC_CODE_TRANSPOSE_WORLD_VIEW_MATRIX2 = 0x86,
+        CONST_SRC_CODE_INVERSE_TRANSPOSE_WORLD_VIEW_MATRIX2 = 0x87,
+        CONST_SRC_CODE_WORLD_VIEW_PROJECTION_MATRIX2 = 0x88,
+        CONST_SRC_CODE_INVERSE_WORLD_VIEW_PROJECTION_MATRIX2 = 0x89,
+        CONST_SRC_CODE_TRANSPOSE_WORLD_VIEW_PROJECTION_MATRIX2 = 0x8A,
+        CONST_SRC_CODE_INVERSE_TRANSPOSE_WORLD_VIEW_PROJECTION_MATRIX2 = 0x8B,
+
+        CONST_SRC_TOTAL_COUNT,
+        CONST_SRC_NONE,
+    };
+
+    enum MaterialStreamStreamSource_e
+    {
+        STREAM_SRC_POSITION = 0x0,
+        STREAM_SRC_COLOR = 0x1,
+        STREAM_SRC_TEXCOORD_0 = 0x2,
+        STREAM_SRC_NORMAL = 0x3,
+
+        STREAM_SRC_PRE_OPTIONAL_BEGIN = 0x4,
+
+        STREAM_SRC_TANGENT = 0x4,
+
+        STREAM_SRC_OPTIONAL_BEGIN = 0x5,
+
+        STREAM_SRC_TEXCOORD_1 = 0x5,
+        STREAM_SRC_TEXCOORD_2 = 0x6,
+        STREAM_SRC_NORMAL_TRANSFORM_0 = 0x7,
+        STREAM_SRC_NORMAL_TRANSFORM_1 = 0x8,
+
+        STREAM_SRC_COUNT
+    };
+
+    enum MaterialStreamDestination_e
+    {
+        STREAM_DST_POSITION = 0x0,
+        STREAM_DST_NORMAL = 0x1,
+        STREAM_DST_COLOR_0 = 0x2,
+        STREAM_DST_COLOR_1 = 0x3,
+        STREAM_DST_DEPTH = 0x4,
+        STREAM_DST_TEXCOORD_0 = 0x5,
+        STREAM_DST_TEXCOORD_1 = 0x6,
+        STREAM_DST_TEXCOORD_2 = 0x7,
+        STREAM_DST_TEXCOORD_3 = 0x8,
+        STREAM_DST_TEXCOORD_4 = 0x9,
+        STREAM_DST_TEXCOORD_5 = 0xA,
+        STREAM_DST_TEXCOORD_6 = 0xB,
+        STREAM_DST_TEXCOORD_7 = 0xC,
+
+        STREAM_DST_COUNT
+    };
+
     struct MaterialStreamRouting
     {
-        char source;
+        unsigned char source;
-        char dest;
+        unsigned char dest;
     };
 
     struct MaterialVertexStreamRouting
@@ -993,11 +1244,15 @@ namespace IW5
         MTL_ARG_LITERAL_VERTEX_CONST = 0x1,
         MTL_ARG_MATERIAL_VERTEX_SAMPLER = 0x2,
         MTL_ARG_MATERIAL_PIXEL_SAMPLER = 0x3,
+
         MTL_ARG_CODE_PRIM_BEGIN = 0x4,
+
         MTL_ARG_CODE_VERTEX_CONST = 0x4,
         MTL_ARG_CODE_PIXEL_SAMPLER = 0x5,
         MTL_ARG_CODE_PIXEL_CONST = 0x6,
+
         MTL_ARG_CODE_PRIM_END = 0x7,
+
         MTL_ARG_MATERIAL_PIXEL_CONST = 0x7,
         MTL_ARG_LITERAL_PIXEL_CONST = 0x8,
 
@@ -1038,6 +1293,24 @@ namespace IW5
         MaterialShaderArgument* args;
     };
 
+    enum TechniqueFlags
+    {
+        MTL_TECHFLAG_NEEDS_RESOLVED_POST_SUN = 0x1,
+        MTL_TECHFLAG_NEEDS_RESOLVED_SCENE = 0x2,
+
+        // These 3 are set so rare, it seems like they are just based on name just like other games do
+        MTL_TECHFLAG_ZPREPASS = 0x4,
+        MTL_TECHFLAG_BUILD_FLOATZ = 0x8,
+        MTL_TECHFLAG_BUILD_SHADOW_MAP_DEPTH_OR_MODEL = 0x10,
+
+        MTL_TECHFLAG_DECL_HAS_OPTIONAL_SOURCE = 0x20,
+
+        MTL_TECHFLAG_USES_LIGHT_SPOT_FACTORS = 0x40,
+        MTL_TECHFLAG_USES_FLOATZ = 0x80,             // uses floatZ sampler and does not have 0x100 flag
+        MTL_TECHFLAG_USES_DISTORTION_FLOATZ = 0x100, // distortion_scale_zfeather_dtex + distortion_scale_ua_zfeather + distortion_scale_zfeather
+        TECHNIQUE_FLAG_200 = 0x200,                  // ?
+    };
+
     struct MaterialTechnique
     {
         const char* name;
@@ -1046,6 +1319,73 @@ namespace IW5
         MaterialPass passArray[1];
     };
 
+    enum MaterialTechniqueType
+    {
+        TECHNIQUE_DEPTH_PREPASS = 0x0,
+        TECHNIQUE_BUILD_FLOAT_Z = 0x1,
+        TECHNIQUE_BUILD_SHADOWMAP_DEPTH = 0x2,
+        TECHNIQUE_BUILD_SHADOWMAP_COLOR = 0x3,
+        TECHNIQUE_UNLIT = 0x4,
+        TECHNIQUE_EMISSIVE = 0x5,
+        TECHNIQUE_EMISSIVE_DFOG = 0x6,
+        TECHNIQUE_EMISSIVE_SHADOW = 0x7,
+        TECHNIQUE_EMISSIVE_SHADOW_DFOG = 0x8,
+
+        TECHNIQUE_LIT_BEGIN = 0x9,
+
+        TECHNIQUE_LIT = 0x9,
+        TECHNIQUE_LIT_DFOG = 0xA,
+        TECHNIQUE_LIT_SUN = 0xB,
+        TECHNIQUE_LIT_SUN_DFOG = 0xC,
+        TECHNIQUE_LIT_SUN_SHADOW = 0xD,
+        TECHNIQUE_LIT_SUN_SHADOW_DFOG = 0xE,
+        TECHNIQUE_LIT_SPOT = 0xF,
+        TECHNIQUE_LIT_SPOT_DFOG = 0x10,
+        TECHNIQUE_LIT_SPOT_SHADOW = 0x11,
+        TECHNIQUE_LIT_SPOT_SHADOW_DFOG = 0x12,
+        TECHNIQUE_LIT_SPOT_SHADOW_CUCOLORIS = 0x13,
+        TECHNIQUE_LIT_SPOT_SHADOW_CUCOLORIS_DFOG = 0x14,
+        TECHNIQUE_LIT_OMNI = 0x15,
+        TECHNIQUE_LIT_OMNI_DFOG = 0x16,
+        TECHNIQUE_LIT_OMNI_SHADOW = 0x17,
+        TECHNIQUE_LIT_OMNI_SHADOW_DFOG = 0x18,
+
+        TECHNIQUE_LIT_INSTANCED = 0x19,
+        TECHNIQUE_LIT_INSTANCED_DFOG = 0x1A,
+        TECHNIQUE_LIT_INSTANCED_SUN = 0x1B,
+        TECHNIQUE_LIT_INSTANCED_SUN_DFOG = 0x1C,
+        TECHNIQUE_LIT_INSTANCED_SUN_SHADOW = 0x1D,
+        TECHNIQUE_LIT_INSTANCED_SUN_SHADOW_DFOG = 0x1E,
+        TECHNIQUE_LIT_INSTANCED_SPOT = 0x1F,
+        TECHNIQUE_LIT_INSTANCED_SPOT_DFOG = 0x20,
+        TECHNIQUE_LIT_INSTANCED_SPOT_SHADOW = 0x21,
+        TECHNIQUE_LIT_INSTANCED_SPOT_SHADOW_DFOG = 0x22,
+        TECHNIQUE_LIT_INSTANCED_SPOT_SHADOW_CUCOLORIS = 0x23,
+        TECHNIQUE_LIT_INSTANCED_SPOT_SHADOW_CUCOLORIS_DFOG = 0x24,
+        TECHNIQUE_LIT_INSTANCED_OMNI = 0x25,
+        TECHNIQUE_LIT_INSTANCED_OMNI_DFOG = 0x26,
+        TECHNIQUE_LIT_INSTANCED_OMNI_SHADOW = 0x27,
+        TECHNIQUE_LIT_INSTANCED_OMNI_SHADOW_DFOG = 0x28,
+
+        TECHNIQUE_LIT_END = 0x29,
+
+        TECHNIQUE_LIGHT_SPOT = 0x29,
+        TECHNIQUE_LIGHT_OMNI = 0x2A,
+        TECHNIQUE_LIGHT_SPOT_SHADOW = 0x2B,
+        TECHNIQUE_LIGHT_SPOT_SHADOW_CUCOLORIS = 0x2C,
+        TECHNIQUE_FAKELIGHT_NORMAL = 0x2D,
+        TECHNIQUE_FAKELIGHT_VIEW = 0x2E,
+        TECHNIQUE_SUNLIGHT_PREVIEW = 0x2F,
+        TECHNIQUE_CASE_TEXTURE = 0x30,
+        TECHNIQUE_WIREFRAME_SOLID = 0x31,
+        TECHNIQUE_WIREFRAME_SHADED = 0x32,
+        TECHNIQUE_THERMAL = 0x33,
+        TECHNIQUE_DEBUG_BUMPMAP = 0x34,
+        TECHNIQUE_DEBUG_BUMPMAP_INSTANCED = 0x35,
+
+        TECHNIQUE_COUNT
+    };
+
     enum MaterialWorldVertexFormat : unsigned char
     {
         MTL_WORLDVERT_TEX_1_NRM_1 = 0x0,

src/ObjCommon/Techset/CommonTechnique.h

@@ -33,7 +33,9 @@ namespace techset
     enum class CommonTechniqueShaderType : std::uint8_t
     {
         VERTEX,
-        PIXEL
+        PIXEL,
+
+        COUNT
     };
 
     enum class CommonShaderValueType : std::uint8_t
@@ -47,7 +49,9 @@ namespace techset
         // Value is set to a sampler from the material
         MATERIAL_SAMPLER,
         // Value is set to a sampler generated in code
-        CODE_SAMPLER
+        CODE_SAMPLER,
+
+        COUNT
     };
 
     constexpr bool IsConstValueType(const CommonShaderValueType valueType)

src/ObjCompiling/Game/IW5/ObjCompilerIW5.cpp

@@ -1,6 +1,9 @@
 #include "ObjCompilerIW5.h"
 
 #include "Game/IW5/IW5.h"
+#include "Game/IW5/Techset/TechniqueCompilerIW5.h"
+#include "Game/IW5/Techset/TechsetCompilerIW5.h"
+#include "Game/IW5/Techset/VertexDeclCompilerIW5.h"
 #include "Image/ImageIwdPostProcessor.h"
 
 #include <memory>
@@ -13,7 +16,10 @@ namespace
     {
         auto& memory = zone.Memory();
 
-        // No compilers yet
+        collection.AddAssetCreator(techset::CreateVertexDeclCompilerIW5(memory));
+        collection.AddAssetCreator(techset::CreateTechsetCompilerIW5(memory, searchPath));
+
+        collection.AddSubAssetCreator(techset::CreateTechniqueCompilerIW5(memory, zone, searchPath));
     }
 
     void ConfigurePostProcessors(AssetCreatorCollection& collection,
@@ -39,5 +45,6 @@ void ObjCompiler::ConfigureCreatorCollection(AssetCreatorCollection& collection,
                                              IOutputPath& outDir,
                                              IOutputPath& cacheDir) const
 {
+    ConfigureCompilers(collection, zone, searchPath);
     ConfigurePostProcessors(collection, zone, zoneDefinition, searchPath, zoneStates, outDir);
 }

src/ObjCompiling/Techset/CommonShaderArgCreator.cpp

@@ -12,6 +12,16 @@
 
 namespace
 {
+    enum class ArgumentType : std::uint8_t
+    {
+        VERTEX_CONSTANT,
+        VERTEX_SAMPLER,
+        PIXEL_CONSTANT,
+        PIXEL_SAMPLER,
+
+        COUNT
+    };
+
     const char* ShaderTypeName(const techset::CommonTechniqueShaderType shaderType)
     {
         switch (shaderType)
@@ -20,6 +30,9 @@ namespace
             return "vertex";
         case techset::CommonTechniqueShaderType::PIXEL:
             return "pixel";
+        case techset::CommonTechniqueShaderType::COUNT:
+            assert(false);
+            break;
         }
 
         return "<unknown>";
@@ -36,6 +49,9 @@ namespace
         case techset::CommonShaderValueType::CODE_SAMPLER:
         case techset::CommonShaderValueType::MATERIAL_SAMPLER:
             return "sampler";
+        case techset::CommonShaderValueType::COUNT:
+            assert(false);
+            break;
         }
 
         return "<unknown>";
@@ -47,11 +63,13 @@ namespace
         explicit BaseCommonShaderArgCreator(techset::ITechniqueShaderLoader& shaderLoader, techset::CommonCodeSourceInfos& commonCodeSourceInfos)
             : m_shader_loader(shaderLoader),
               m_common_code_source_infos(commonCodeSourceInfos),
+              m_supported_argument_types(0),
               m_shader_type(techset::CommonTechniqueShaderType::VERTEX),
               m_bin{},
               m_tech_flags(0),
               m_sampler_flags(0)
         {
+            DetermineSupportedArgumentTypes();
         }
 
         result::Expected<NoResult, std::string> EnterShader(const techset::CommonTechniqueShaderType shaderType, const std::string& name) override
@@ -307,21 +325,36 @@ namespace
             return NoResult{};
         }
 
-        static bool IsArgumentTypeSupported(const techset::CommonShaderArgumentType& argumentType)
+        [[nodiscard]] bool IsArgumentTypeSupported(const techset::CommonShaderArgumentType& argumentType) const
         {
-            if (argumentType.m_shader_type == techset::CommonTechniqueShaderType::PIXEL)
+            const auto mask = 1 << (std::to_underlying(argumentType.m_shader_type) * std::to_underlying(techset::CommonShaderValueType::COUNT)
-                return true;
+                                    + std::to_underlying(argumentType.m_value_type));
 
-            switch (argumentType.m_value_type)
+            return m_supported_argument_types & mask;
+        }
+
+        void DetermineSupportedArgumentTypes()
         {
-            case techset::CommonShaderValueType::LITERAL_CONST:
+            // Ensure we have enough bits for the flags
-            case techset::CommonShaderValueType::MATERIAL_CONST:
+            static_assert(std::to_underlying(techset::CommonTechniqueShaderType::COUNT) * std::to_underlying(techset::CommonShaderValueType::COUNT)
-            case techset::CommonShaderValueType::CODE_CONST:
+                          <= sizeof(m_supported_argument_types) * 8);
-                return true;
+
-            case techset::CommonShaderValueType::MATERIAL_SAMPLER:
+            m_supported_argument_types = 0;
-            case techset::CommonShaderValueType::CODE_SAMPLER:
+            for (auto shaderType = 0u; shaderType < std::to_underlying(techset::CommonTechniqueShaderType::COUNT); shaderType++)
-            default:
+            {
-                return false;
+                for (auto valueType = 0u; valueType < std::to_underlying(techset::CommonShaderValueType::COUNT); valueType++)
+                {
+                    techset::CommonShaderArgumentType argumentType{
+                        .m_shader_type = static_cast<techset::CommonTechniqueShaderType>(shaderType),
+                        .m_value_type = static_cast<techset::CommonShaderValueType>(valueType),
+                    };
+
+                    if (m_common_code_source_infos.GetArgumentTypeNumericValue(argumentType).has_value())
+                    {
+                        const auto flag = 1 << (shaderType * std::to_underlying(techset::CommonShaderValueType::COUNT) + valueType);
+                        m_supported_argument_types |= flag;
+                    }
+                }
             }
         }
 
@@ -340,6 +373,7 @@ namespace
 
         techset::ITechniqueShaderLoader& m_shader_loader;
         techset::CommonCodeSourceInfos& m_common_code_source_infos;
+        std::uint16_t m_supported_argument_types;
 
         techset::CommonTechniqueShaderType m_shader_type;
         std::string m_shader_name;

src/ObjCompiling/Techset/TechniqueCompiler.cpp.template

@@ -1,4 +1,4 @@
-#options GAME(IW3, IW4, T5, T6)
+#options GAME(IW3, IW4, IW5, T5, T6)
 
 #filename "Game/" + GAME + "/Techset/TechniqueCompiler" + GAME + ".cpp"
 
@@ -70,6 +70,9 @@ namespace
             case techset::CommonShaderValueType::CODE_CONST:
                 return MTL_ARG_CODE_VERTEX_CONST;
             case techset::CommonShaderValueType::MATERIAL_SAMPLER:
+#if defined(FEATURE_IW5)
+                return MTL_ARG_MATERIAL_VERTEX_SAMPLER;
+#endif
             case techset::CommonShaderValueType::CODE_SAMPLER:
             default:
                 assert(false);
@@ -119,6 +122,9 @@ namespace
         case techset::CommonShaderValueType::MATERIAL_SAMPLER:
             argValue.nameHash = static_cast<decltype(MaterialArgumentDef::nameHash)>(commonArg.m_value.name_hash);
             break;
+        case techset::CommonShaderValueType::COUNT:
+            assert(false);
+            break;
         }
     }
 
@@ -213,7 +219,7 @@ namespace
         pass.customSamplerFlags = static_cast<decltype(MaterialPass::customSamplerFlags)>(commonPass.m_sampler_flags);
     }
 
-#ifdef FEATURE_IW4
+#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
     // Not sure if this is actually how this is calculated.
     // It produces identical results at least though.
     constexpr MaterialConstantSource ALLOWED_PIXEL_CONSTANTS_FOR_FLAG_200[]{
@@ -282,7 +288,7 @@ namespace
 #if defined(FEATURE_IW3)
         if (lowerTechniqueName == "zprepass")
             technique.flags |= MTL_TECHFLAG_ZPREPASS;
-#elif defined(FEATURE_IW4)
+#elif defined(FEATURE_IW4) || defined(FEATURE_IW5)
         // Not a particularly cool way to do this but...
         // the game actually does this :shrug:
         if (lowerTechniqueName == "zprepass")

src/ObjCompiling/Techset/TechniqueCompiler.h.template

@@ -1,4 +1,4 @@
-#options GAME(IW3, IW4, T5, T6)
+#options GAME(IW3, IW4, IW5, T5, T6)
 
 #filename "Game/" + GAME + "/Techset/TechniqueCompiler" + GAME + ".h"
 

src/ObjCompiling/Techset/TechsetCompiler.cpp.template

@@ -1,4 +1,4 @@
-#options GAME(IW3, IW4, T5, T6)
+#options GAME(IW3, IW4, IW5, T5, T6)
 
 #filename "Game/" + GAME + "/Techset/TechsetCompiler" + GAME + ".cpp"
 

src/ObjCompiling/Techset/TechsetCompiler.h.template

@@ -1,4 +1,4 @@
-#options GAME(IW3, IW4, T5, T6)
+#options GAME(IW3, IW4, IW5, T5, T6)
 
 #filename "Game/" + GAME + "/Techset/TechsetCompiler" + GAME + ".h"
 

src/ObjCompiling/Techset/VertexDeclCompiler.cpp.template

@@ -1,4 +1,4 @@
-#options GAME(IW3, IW4, T5, T6)
+#options GAME(IW3, IW4, IW5, T5, T6)
 
 #filename "Game/" + GAME + "/Techset/VertexDeclCompiler" + GAME + ".cpp"
 

src/ObjCompiling/Techset/VertexDeclCompiler.h.template

@@ -1,4 +1,4 @@
-#options GAME(IW3, IW4, T5, T6)
+#options GAME(IW3, IW4, IW5, T5, T6)
 
 #filename "Game/" + GAME + "/Techset/VertexDeclCompiler" + GAME + ".h"
 

src/ObjLoading/Game/IW5/ObjLoaderIW5.cpp

@@ -6,6 +6,8 @@
 #include "Game/IW5/IW5.h"
 #include "Game/IW5/Image/ImageLoaderEmbeddedIW5.h"
 #include "Game/IW5/Image/ImageLoaderExternalIW5.h"
+#include "Game/IW5/Techset/PixelShaderLoaderIW5.h"
+#include "Game/IW5/Techset/VertexShaderLoaderIW5.h"
 #include "Game/IW5/XModel/LoaderXModelIW5.h"
 #include "Leaderboard/LoaderLeaderboardIW5.h"
 #include "Localize/LoaderLocalizeIW5.h"
@@ -129,9 +131,8 @@ namespace
         // collection.AddAssetCreator(std::make_unique<AssetLoaderXModelSurfs>(memory));
         collection.AddAssetCreator(xmodel::CreateLoaderIW5(memory, searchPath, zone));
         collection.AddAssetCreator(material::CreateLoaderIW5(memory, searchPath));
-        // collection.AddAssetCreator(std::make_unique<AssetLoaderPixelShader>(memory));
+        collection.AddAssetCreator(techset::CreateVertexShaderLoaderIW5(memory, searchPath));
-        // collection.AddAssetCreator(std::make_unique<AssetLoaderVertexShader>(memory));
+        collection.AddAssetCreator(techset::CreatePixelShaderLoaderIW5(memory, searchPath));
-        // collection.AddAssetCreator(std::make_unique<AssetLoaderVertexDecl>(memory));
         // collection.AddAssetCreator(std::make_unique<AssetLoaderTechniqueSet>(memory));
         collection.AddAssetCreator(image::CreateLoaderEmbeddedIW5(memory, searchPath));
         collection.AddAssetCreator(image::CreateLoaderExternalIW5(memory, searchPath));

src/ObjLoading/Techset/PixelShaderLoader.cpp.template

@@ -1,4 +1,4 @@
-#options GAME(IW3, IW4, T5, T6)
+#options GAME(IW3, IW4, IW5, T5, T6)
 
 #filename "Game/" + GAME + "/Techset/PixelShaderLoader" + GAME + ".cpp"
 

src/ObjLoading/Techset/PixelShaderLoader.h.template

@@ -1,4 +1,4 @@
-#options GAME(IW3, IW4, T5, T6)
+#options GAME(IW3, IW4, IW5, T5, T6)
 
 #filename "Game/" + GAME + "/Techset/PixelShaderLoader" + GAME + ".h"
 

src/ObjLoading/Techset/VertexShaderLoader.cpp.template

@@ -1,4 +1,4 @@
-#options GAME(IW3, IW4, T5, T6)
+#options GAME(IW3, IW4, IW5, T5, T6)
 
 #filename "Game/" + GAME + "/Techset/VertexShaderLoader" + GAME + ".cpp"
 

src/ObjLoading/Techset/VertexShaderLoader.h.template

@@ -1,4 +1,4 @@
-#options GAME(IW3, IW4, T5, T6)
+#options GAME(IW3, IW4, IW5, T5, T6)
 
 #filename "Game/" + GAME + "/Techset/VertexShaderLoader" + GAME + ".h"
 

src/ObjWriting/Game/IW5/Material/MaterialConstantZoneStateIW5.cpp

@@ -140,6 +140,7 @@ namespace
         "detailMap",
         "detailMapSampler",
         "dust",
+        "dustMap",
         "dustSampler",
         "fadeMap",
         "fadeMapSampler",
@@ -160,22 +161,30 @@ namespace
         "lookupMap",
         "lookupMapSampler",
         "modelLighting",
+        "modelLightingMap",
         "modelLightingSampler",
         "normalMap",
         "normalMapSampler",
         "oceanColorRamp",
+        "oceanColorRampMap",
         "oceanColorRampSampler",
         "oceanDetailNormal",
+        "oceanDetailNormalMap",
         "oceanDetailNormalSampler",
         "oceanDisplacement",
+        "oceanDisplacementMap",
         "oceanDisplacementSampler",
         "oceanEnv",
+        "oceanEnvMap",
         "oceanEnvSampler",
         "oceanFoam",
+        "oceanFoamMap",
         "oceanFoamSampler",
         "oceanHeightNormal",
+        "oceanHeightNormalMap",
         "oceanHeightNormalSampler",
         "oceanPaintedFoam",
+        "oceanPaintedFoamMap",
         "oceanPaintedFoamSampler",
         "outdoorMap",
         "outdoorMapSampler",

src/ObjWriting/Game/IW5/ObjWriterIW5.cpp

@@ -1,6 +1,9 @@
 #include "ObjWriterIW5.h"
 
 #include "Game/IW5/Material/MaterialJsonDumperIW5.h"
+#include "Game/IW5/Techset/PixelShaderDumperIW5.h"
+#include "Game/IW5/Techset/TechsetDumperIW5.h"
+#include "Game/IW5/Techset/VertexShaderDumperIW5.h"
 #include "Game/IW5/XModel/XModelDumperIW5.h"
 #include "Image/ImageDumperIW5.h"
 #include "Leaderboard/LeaderboardJsonDumperIW5.h"
@@ -25,10 +28,15 @@ void ObjWriter::RegisterAssetDumpers(AssetDumpingContext& context)
     // REGISTER_DUMPER(AssetDumperXModelSurfs)
     RegisterAssetDumper(std::make_unique<xmodel::DumperIW5>());
     RegisterAssetDumper(std::make_unique<material::JsonDumperIW5>());
-    // REGISTER_DUMPER(AssetDumperMaterialPixelShader)
+    RegisterAssetDumper(std::make_unique<techset::PixelShaderDumperIW5>());
-    // REGISTER_DUMPER(AssetDumperMaterialVertexShader)
+    RegisterAssetDumper(std::make_unique<techset::VertexShaderDumperIW5>());
-    // REGISTER_DUMPER(AssetDumperMaterialVertexDeclaration)
+    RegisterAssetDumper(std::make_unique<techset::DumperIW5>(
-    // REGISTER_DUMPER(AssetDumperMaterialTechniqueSet)
+#ifdef TECHSET_DEBUG
+        true
+#else
+        false
+#endif
+        ));
     RegisterAssetDumper(std::make_unique<image::DumperIW5>());
     // REGISTER_DUMPER(AssetDumpersnd_alias_list_t)
     // REGISTER_DUMPER(AssetDumperSndCurve)

src/ObjWriting/Techset/PixelShaderDumper.cpp.template

@@ -1,4 +1,4 @@
-#options GAME(IW4)
+#options GAME(IW4, IW5)
 
 #filename "Game/" + GAME + "/Techset/PixelShaderDumper" + GAME + ".cpp"
 

src/ObjWriting/Techset/PixelShaderDumper.h.template

@@ -1,4 +1,4 @@
-#options GAME(IW4)
+#options GAME(IW4, IW5)
 
 #filename "Game/" + GAME + "/Techset/PixelShaderDumper" + GAME + ".h"
 

src/ObjWriting/Techset/TechsetDumper.cpp.template

@@ -1,4 +1,4 @@
-#options GAME(IW3, IW4, T5, T6)
+#options GAME(IW3, IW4, IW5, T5, T6)
 
 #filename "Game/" + GAME + "/Techset/TechsetDumper" + GAME + ".cpp"
 
@@ -110,7 +110,7 @@ namespace
     {
         std::vector<techset::CommonStreamRouting> commonRouting;
 
-#if defined(FEATURE_IW4)
+#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
         if (vertexDecl && vertexDecl->name && vertexDecl->name[0] != ',')
 #else
         if (vertexDecl)
@@ -124,7 +124,7 @@ namespace
                                            static_cast<techset::CommonStreamDestination>(routing.dest));
             }
         }
-#if defined(FEATURE_IW4)
+#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
         else if (vertexDecl && vertexDecl->name)
         {
             auto result = techset::CreateVertexDeclFromName(&vertexDecl->name[1], commonRoutingInfos);
@@ -213,6 +213,9 @@ namespace
             return techset::CommonShaderArg(commonArgumentTypes[arg.type], destination, value);
         }
 
+#if defined(FEATURE_IW5)
+        case MTL_ARG_MATERIAL_VERTEX_SAMPLER:
+#endif
         case MTL_ARG_MATERIAL_PIXEL_SAMPLER:
         {
             const techset::CommonShaderArgValue value{
@@ -235,7 +238,6 @@ namespace
             return techset::CommonShaderArg(commonArgumentTypes[arg.type], destination, value);
         }
 
-        default:
         case MTL_ARG_LITERAL_VERTEX_CONST:
         case MTL_ARG_LITERAL_PIXEL_CONST:
         {
@@ -265,15 +267,19 @@ namespace
 
             return techset::CommonShaderArg(commonArgumentTypes[arg.type], destination, value);
         }
+
+        default:
+            assert(false);
+            return techset::CommonShaderArg();
         }
     }
 
     techset::CommonTechniqueShader ConvertToCommonShader(const MaterialVertexShader* vertexShader)
     {
-#if defined(FEATURE_IW4)
+#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
         if (vertexShader && vertexShader->name && vertexShader->name[0] == ',')
         {
-            auto* globalAsset = GameGlobalAssetPools::GetGlobalPoolsForGame(GameId::IW4)->GetAsset<AssetVertexShader>(&vertexShader->name[1]);
+            auto* globalAsset = GameGlobalAssetPools::GetGlobalPoolsForGame(GameId::GAME)->GetAsset<AssetVertexShader>(&vertexShader->name[1]);
             if (globalAsset)
                 vertexShader = globalAsset->Asset();
         }
@@ -303,10 +309,10 @@ namespace
 
     techset::CommonTechniqueShader ConvertToCommonShader(const MaterialPixelShader* pixelShader)
     {
-#if defined(FEATURE_IW4)
+#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
         if (pixelShader && pixelShader->name && pixelShader->name[0] == ',')
         {
-            auto* globalAsset = GameGlobalAssetPools::GetGlobalPoolsForGame(GameId::IW4)->GetAsset<AssetPixelShader>(&pixelShader->name[1]);
+            auto* globalAsset = GameGlobalAssetPools::GetGlobalPoolsForGame(GameId::GAME)->GetAsset<AssetPixelShader>(&pixelShader->name[1]);
             if (globalAsset)
                 pixelShader = globalAsset->Asset();
         }

src/ObjWriting/Techset/TechsetDumper.h.template

@@ -1,4 +1,4 @@
-#options GAME(IW3, IW4, T5, T6)
+#options GAME(IW3, IW4, IW5, T5, T6)
 
 #filename "Game/" + GAME + "/Techset/TechsetDumper" + GAME + ".h"
 

src/ObjWriting/Techset/VertexShaderDumper.cpp.template

@@ -1,4 +1,4 @@
-#options GAME(IW4)
+#options GAME(IW4, IW5)
 
 #filename "Game/" + GAME + "/Techset/VertexShaderDumper" + GAME + ".cpp"
 

src/ObjWriting/Techset/VertexShaderDumper.h.template

@@ -1,4 +1,4 @@
-#options GAME(IW4)
+#options GAME(IW4, IW5)
 
 #filename "Game/" + GAME + "/Techset/VertexShaderDumper" + GAME + ".h"