From df7b25b85494944a79d5e803bd843b45b5f4a800 Mon Sep 17 00:00:00 2001 From: Jan Date: Wed, 3 Jan 2024 17:47:22 +0100 Subject: [PATCH] feat: dump t6 materials as json --- src/Common/Game/IW3/IW3_Assets.h | 18 + src/Common/Game/IW4/IW4_Assets.h | 2 +- src/Common/Game/T6/CommonT6.cpp | 10 - src/Common/Game/T6/CommonT6.h | 11 +- src/Common/Game/T6/T6_Assets.h | 762 +++++++++++++++--- src/ObjCommon/Game/IW4/TechsetConstantsIW4.h | 2 + src/ObjCommon/Game/T6/MaterialConstantsT6.h | 119 +++ src/ObjCommon/Game/T6/TechsetConstantsT6.h | 101 +++ .../T6/AssetDumpers/AssetDumperMaterial.cpp | 362 +++++++++ .../T6/AssetDumpers/AssetDumperMaterial.h | 18 + src/ObjWriting/Game/T6/ZoneDumperT6.cpp | 3 +- 11 files changed, 1294 insertions(+), 114 deletions(-) create mode 100644 src/ObjCommon/Game/T6/MaterialConstantsT6.h create mode 100644 src/ObjCommon/Game/T6/TechsetConstantsT6.h create mode 100644 src/ObjWriting/Game/T6/AssetDumpers/AssetDumperMaterial.cpp create mode 100644 src/ObjWriting/Game/T6/AssetDumpers/AssetDumperMaterial.h diff --git a/src/Common/Game/IW3/IW3_Assets.h b/src/Common/Game/IW3/IW3_Assets.h index 37fec044..a2007ba7 100644 --- a/src/Common/Game/IW3/IW3_Assets.h +++ b/src/Common/Game/IW3/IW3_Assets.h @@ -763,6 +763,24 @@ namespace IW3 SURF_TYPE_NUM }; + // Unknown if this is the right amount of flags + enum MaterialGameFlags + { + MTL_GAMEFLAG_1 = 0x1, + MTL_GAMEFLAG_2 = 0x2, + MTL_GAMEFLAG_4 = 0x4, + MTL_GAMEFLAG_8 = 0x8, + MTL_GAMEFLAG_10 = 0x10, + MTL_GAMEFLAG_20 = 0x20, + MTL_GAMEFLAG_CASTS_SHADOW = 0x40, + MTL_GAMEFLAG_80 = 0x80, + MTL_GAMEFLAG_100 = 0x100, + MTL_GAMEFLAG_200 = 0x200, + MTL_GAMEFLAG_400 = 0x400, + MTL_GAMEFLAG_800 = 0x800, + MTL_GAMEFLAG_1000 = 0x1000, + }; + struct MaterialInfo { const char* name; diff --git a/src/Common/Game/IW4/IW4_Assets.h b/src/Common/Game/IW4/IW4_Assets.h index 7714dd0a..c65a0018 100644 --- a/src/Common/Game/IW4/IW4_Assets.h +++ b/src/Common/Game/IW4/IW4_Assets.h @@ -931,7 +931,7 @@ namespace IW4 }; // Names unknown - // There's probably: MTL_GAMEFLAG_CASTS_SHADOW (part of iw3; 0x40 there) + // There's probably: MTL_GAMEFLAG_CASTS_SHADOW (part of iw3/t5; 0x40 there) enum MaterialGameFlags { MTL_GAMEFLAG_1 = 0x1, diff --git a/src/Common/Game/T6/CommonT6.cpp b/src/Common/Game/T6/CommonT6.cpp index 31d0d656..744a3270 100644 --- a/src/Common/Game/T6/CommonT6.cpp +++ b/src/Common/Game/T6/CommonT6.cpp @@ -58,16 +58,6 @@ int Common::Com_HashString(const char* str, const int len) return result; } -uint32_t Common::R_HashString(const char* str, uint32_t hash) -{ - for (const auto* pos = str; *pos; pos++) - { - hash = 33 * hash ^ (*pos | 0x20); - } - - return hash; -} - PackedTexCoords Common::Vec2PackTexCoords(const vec2_t* in) { return PackedTexCoords{Pack32::Vec2PackTexCoords(in->v)}; diff --git a/src/Common/Game/T6/CommonT6.h b/src/Common/Game/T6/CommonT6.h index 6580ccdf..9e939f30 100644 --- a/src/Common/Game/T6/CommonT6.h +++ b/src/Common/Game/T6/CommonT6.h @@ -10,7 +10,16 @@ namespace T6 static int Com_HashKey(const char* str, int maxLen); static int Com_HashString(const char* str); static int Com_HashString(const char* str, int len); - static uint32_t R_HashString(const char* str, uint32_t hash); + + static constexpr uint32_t R_HashString(const char* str, uint32_t hash) + { + for (const auto* pos = str; *pos; pos++) + { + hash = 33 * hash ^ (*pos | 0x20); + } + + return hash; + } static constexpr uint32_t SND_HashName(const char* str) { diff --git a/src/Common/Game/T6/T6_Assets.h b/src/Common/Game/T6/T6_Assets.h index 76948153..854e31fc 100644 --- a/src/Common/Game/T6/T6_Assets.h +++ b/src/Common/Game/T6/T6_Assets.h @@ -647,20 +647,77 @@ namespace T6 gcc_align(8) uint64_t packed; }; + // The sort key is translated to a numeric value inside the material templates + // when converting the material. + // TODO: Try to find out which value is which sort key by investigating on materials + enum SortKey_e + { + SORTKEY_DECAL = 24, + + SORTKEY_MAX = 64 + }; + + enum MaterialGameFlags + { + // Set when surfaceFlags has 0x80 or 0x80000 set + MTL_GAMEFLAG_1 = 0x1, + + // Cannot be set when material type is not "world" + // So not either 4,5,6,7 + MTL_GAMEFLAG_2 = 0x2, + + MTL_GAMEFLAG_NO_MARKS = 0x4, + MTL_GAMEFLAG_8 = 0x8, + MTL_GAMEFLAG_10 = 0x10, + MTL_GAMEFLAG_20 = 0x20, + + // Probably, seems to be this in T5 + MTL_GAMEFLAG_CASTS_SHADOW = 0x40, + + // Set when surface flags has 0x100 set + MTL_GAMEFLAG_80 = 0x80, + + // Seems to be related to the material being used for FX + MTL_GAMEFLAG_100 = 0x100, + + // Set when surface flags has 0x800 set + MTL_GAMEFLAG_200 = 0x200, + MTL_GAMEFLAG_400 = 0x400, + MTL_GAMEFLAG_800 = 0x800, + MTL_GAMEFLAG_1000 = 0x1000, + }; + struct type_align(8) MaterialInfo { const char* name; unsigned int gameFlags; char pad; - char sortKey; - char textureAtlasRowCount; - char textureAtlasColumnCount; + unsigned char sortKey; + unsigned char textureAtlasRowCount; + unsigned char textureAtlasColumnCount; GfxDrawSurf drawSurf; unsigned int surfaceTypeBits; unsigned int layeredSurfaceTypes; uint16_t hashIndex; - int surfaceFlags; - int contents; + unsigned int surfaceFlags; + unsigned int contents; + }; + + enum GfxCameraRegionType + { + CAMERA_REGION_LIT_OPAQUE = 0x0, + CAMERA_REGION_LIT_TRANS = 0x1, + CAMERA_REGION_LIT_QUASI_OPAQUE = 0x2, + CAMERA_REGION_EMISSIVE_OPAQUE = 0x3, + CAMERA_REGION_EMISSIVE_TRANS = 0x4, + CAMERA_REGION_EMISSIVE_FX = 0x5, + CAMERA_REGION_LIGHT_MAP_OPAQUE = 0x6, + CAMERA_REGION_DEPTH_HACK = 0x7, + CAMERA_REGION_UNUSED = 0x8, + CAMERA_REGION_SONAR = 0x9, + + CAMERA_REGION_COUNT, + CAMERA_REGION_NONE = CAMERA_REGION_COUNT, }; typedef tdef_align(8) GfxStateBits GfxStateBitsTable; @@ -672,9 +729,9 @@ namespace T6 unsigned char textureCount; unsigned char constantCount; unsigned char stateBitsCount; - char stateFlags; - char cameraRegion; - char probeMipBits; + unsigned char stateFlags; + unsigned char cameraRegion; + unsigned char probeMipBits; MaterialTechniqueSet* techniqueSet; MaterialTextureDef* textureTable; MaterialConstantDef* constantTable; @@ -718,6 +775,54 @@ namespace T6 MaterialVertexShaderProgram prog; }; + enum MaterialTechniqueType + { + TECHNIQUE_DEPTH_PREPASS = 0x0, + TECHNIQUE_BUILD_SHADOWMAP_DEPTH = 0x1, + TECHNIQUE_UNLIT = 0x2, + TECHNIQUE_EMISSIVE = 0x3, + + TECHNIQUE_LIT_BEGIN = 0x4, + + TECHNIQUE_LIT = 0x4, + TECHNIQUE_LIT_SUN = 0x5, + TECHNIQUE_LIT_SUN_SHADOW = 0x6, + TECHNIQUE_LIT_SPOT = 0x7, + TECHNIQUE_LIT_SPOT_SHADOW = 0x8, + TECHNIQUE_LIT_SPOT_SQUARE = 0x9, + TECHNIQUE_LIT_SPOT_SQUARE_SHADOW = 0xA, + TECHNIQUE_LIT_SPOT_ROUND = 0xB, + TECHNIQUE_LIT_SPOT_ROUND_SHADOW = 0xC, + TECHNIQUE_LIT_OMNI = 0xD, + TECHNIQUE_LIT_OMNI_SHADOW = 0xE, + TECHNIQUE_LIT_DLIGHT_GLIGHT = 0xF, + TECHNIQUE_LIT_SUN_DLIGHT_GLIGHT = 0x10, + TECHNIQUE_LIT_SUN_SHADOW_DLIGHT_GLIGHT = 0x11, + TECHNIQUE_LIT_SPOT_DLIGHT_GLIGHT = 0x12, + TECHNIQUE_LIT_SPOT_SHADOW_DLIGHT_GLIGHT = 0x13, + TECHNIQUE_LIT_SPOT_SQUARE_DLIGHT_GLIGHT = 0x14, + TECHNIQUE_LIT_SPOT_SQUARE_SHADOW_DLIGHT_GLIGHT = 0x15, + TECHNIQUE_LIT_SPOT_ROUND_DLIGHT_GLIGHT = 0x16, + TECHNIQUE_LIT_SPOT_ROUND_SHADOW_DLIGHT_GLIGHT = 0x17, + TECHNIQUE_LIT_OMNI_DLIGHT_GLIGHT = 0x18, + TECHNIQUE_LIT_OMNI_SHADOW_DLIGHT_GLIGHT = 0x19, + + TECHNIQUE_LIT_END = 0x1A, + + TECHNIQUE_LIGHT_SPOT = 0x1A, + TECHNIQUE_LIGHT_OMNI = 0x1B, + TECHNIQUE_FAKELIGHT_NORMAL = 0x1C, + TECHNIQUE_FAKELIGHT_VIEW = 0x1D, + TECHNIQUE_SUNLIGHT_PREVIEW = 0x1E, + TECHNIQUE_CASE_TEXTURE = 0x1F, + TECHNIQUE_WIREFRAME_SOLID = 0x20, + TECHNIQUE_WIREFRAME_SHADED = 0x21, + TECHNIQUE_DEBUG_BUMPMAP = 0x22, + TECHNIQUE_DEBUG_PERFORMANCE = 0x23, + + TECHNIQUE_COUNT + }; + struct MaterialTechniqueSet { const char* name; @@ -789,6 +894,8 @@ namespace T6 TS_COLOR14_MAP = 0x1A, TS_COLOR15_MAP = 0x1B, TS_THROW_MAP = 0x1C, + + TS_COUNT, }; enum ImageCategory @@ -2655,14 +2762,89 @@ namespace T6 PhysGeomList* geomList; }; + enum TextureFilter + { + TEXTURE_FILTER_DISABLED = 0x0, + TEXTURE_FILTER_NEAREST = 0x1, + TEXTURE_FILTER_LINEAR = 0x2, + TEXTURE_FILTER_ANISO2X = 0x3, + TEXTURE_FILTER_ANISO4X = 0x4, + TEXTURE_FILTER_COMPARE = 0x5, + + 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, + SAMPLER_FILTER_NEAREST = 0x1, + SAMPLER_FILTER_LINEAR = 0x2, + SAMPLER_FILTER_ANISO2X = 0x3, + SAMPLER_FILTER_ANISO4X = 0x4, + SAMPLER_FILTER_COMPARE = 0x5, + SAMPLER_FILTER_MASK = 0x7, + + SAMPLER_MIPMAP_SHIFT = 0x3, + SAMPLER_MIPMAP_DISABLED = 0x0, + SAMPLER_MIPMAP_NEAREST = 0x8, + SAMPLER_MIPMAP_LINEAR = 0x10, + SAMPLER_MIPMAP_COUNT = 0x3, + SAMPLER_MIPMAP_MASK = 0x18, + + SAMPLER_CLAMP_U_SHIFT = 0x5, + SAMPLER_CLAMP_V_SHIFT = 0x6, + SAMPLER_CLAMP_W_SHIFT = 0x7, + SAMPLER_CLAMP_U = 0x20, + SAMPLER_CLAMP_V = 0x40, + SAMPLER_CLAMP_W = 0x80, + SAMPLER_CLAMP_MASK = 0xE0, + + SAMPLER_ANISO_SHIFT = 0x8, + SAMPLER_ANISO_1X = 0x0, + SAMPLER_ANISO_2X = 0x100, + SAMPLER_ANISO_4X = 0x200, + SAMPLER_ANISO_6X = 0x300, + SAMPLER_ANISO_8X = 0x400, + SAMPLER_ANISO_10X = 0x500, + SAMPLER_ANISO_12X = 0x600, + SAMPLER_ANISO_16X = 0x700, + SAMPLER_ANISO_MASK = 0x700, + SAMPLER_CONVOLUTION = 0x20000, + SAMPLER_GAMMA = 0x40000, + SAMPLER_UNNORMALIZED_UV = 0x80000, + SAMPLER_DIRECT_FILTER_UNNORMALIZED = 0x80000, + }; + + 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; - char samplerState; - char semantic; - char isMatureContent; + MaterialTextureDefSamplerState samplerState; + unsigned char semantic; // TextureSemantic + bool isMatureContent; char pad[3]; GfxImage* image; }; @@ -2674,93 +2856,150 @@ namespace T6 vec4_t literal; }; - enum GfxStateBitsEnum : unsigned int + enum GfxBlend { - GFXS0_SRCBLEND_RGB_SHIFT = 0x0, - GFXS0_SRCBLEND_RGB_MASK = 0xF, - GFXS0_DSTBLEND_RGB_SHIFT = 0x4, - GFXS0_DSTBLEND_RGB_MASK = 0xF0, - GFXS0_BLENDOP_RGB_SHIFT = 0x8, - GFXS0_BLENDOP_RGB_MASK = 0x700, - GFXS0_BLEND_RGB_MASK = 0x7FF, - GFXS0_ATEST_SHIFT = 0xB, - GFXS0_ATEST_DISABLE = 0x800, - GFXS0_ATEST_GT_0 = 0x0, - GFXS0_ATEST_GE_128 = 0x1000, - GFXS0_ATEST_MASK = 0x1000, - GFXS0_CULL_SHIFT = 0xE, - GFXS0_CULL_NONE = 0x4000, - GFXS0_CULL_BACK = 0x8000, - GFXS0_CULL_FRONT = 0xC000, - GFXS0_CULL_MASK = 0xC000, - GFXS0_SRCBLEND_ALPHA_SHIFT = 0x10, - GFXS0_SRCBLEND_ALPHA_MASK = 0xF0000, - GFXS0_DSTBLEND_ALPHA_SHIFT = 0x14, - GFXS0_DSTBLEND_ALPHA_MASK = 0xF00000, - GFXS0_BLENDOP_ALPHA_SHIFT = 0x18, - GFXS0_BLENDOP_ALPHA_MASK = 0x7000000, - GFXS0_BLEND_ALPHA_MASK = 0x7FF0000, - GFXS0_COLORWRITE_RGB = 0x8000000, - GFXS0_COLORWRITE_ALPHA = 0x10000000, - GFXS0_COLORWRITE_MASK = 0x18000000, - GFXS0_POLYMODE_LINE = 0x80000000, - GFXS1_DEPTHWRITE = 0x1, - GFXS1_DEPTHTEST_DISABLE = 0x2, - GFXS1_DEPTHTEST_SHIFT = 0x2, - GFXS1_DEPTHTEST_ALWAYS = 0x0, - GFXS1_DEPTHTEST_LESS = 0x4, - GFXS1_DEPTHTEST_EQUAL = 0x8, - GFXS1_DEPTHTEST_LESSEQUAL = 0xC, - GFXS1_DEPTHTEST_MASK = 0xC, - GFXS1_DEPTHFUNC_MASK = 0xF, - GFXS1_POLYGON_OFFSET_SHIFT = 0x4, - GFXS1_POLYGON_OFFSET_0 = 0x0, - GFXS1_POLYGON_OFFSET_1 = 0x10, - GFXS1_POLYGON_OFFSET_2 = 0x20, - GFXS1_POLYGON_OFFSET_SHADOWMAP = 0x30, - GFXS1_POLYGON_OFFSET_MASK = 0x30, - GFXS1_STENCIL_FRONT_ENABLE = 0x40, - GFXS1_STENCIL_BACK_ENABLE = 0x80, - GFXS1_STENCIL_MASK = 0xC0, - GFXS1_STENCIL_FRONT_PASS_SHIFT = 0x8, - GFXS1_STENCIL_FRONT_FAIL_SHIFT = 0xB, - GFXS1_STENCIL_FRONT_ZFAIL_SHIFT = 0xE, - GFXS1_STENCIL_FRONT_FUNC_SHIFT = 0x11, - GFXS1_STENCIL_FRONT_MASK = 0xFFF00, - GFXS1_STENCIL_BACK_PASS_SHIFT = 0x14, - GFXS1_STENCIL_BACK_FAIL_SHIFT = 0x17, - GFXS1_STENCIL_BACK_ZFAIL_SHIFT = 0x1A, - GFXS1_STENCIL_BACK_FUNC_SHIFT = 0x1D, - GFXS1_STENCIL_BACK_MASK = 0xFFF00000, - GFXS1_STENCILFUNC_FRONTBACK_MASK = 0xE00E0000, - GFXS1_STENCILOP_FRONTBACK_MASK = 0x1FF1FF00, + GFXS_BLEND_DISABLED = 0x0, + GFXS_BLEND_ZERO = 0x1, + GFXS_BLEND_ONE = 0x2, + GFXS_BLEND_SRCCOLOR = 0x3, + GFXS_BLEND_INVSRCCOLOR = 0x4, + GFXS_BLEND_SRCALPHA = 0x5, + GFXS_BLEND_INVSRCALPHA = 0x6, + GFXS_BLEND_DESTALPHA = 0x7, + GFXS_BLEND_INVDESTALPHA = 0x8, + GFXS_BLEND_DESTCOLOR = 0x9, + GFXS_BLEND_INVDESTCOLOR = 0xA, + + GFXS_BLEND_COUNT }; + enum GfxBlendOp + { + GFXS_BLENDOP_DISABLED = 0x0, + GFXS_BLENDOP_ADD = 0x1, + GFXS_BLENDOP_SUBTRACT = 0x2, + GFXS_BLENDOP_REVSUBTRACT = 0x3, + GFXS_BLENDOP_MIN = 0x4, + GFXS_BLENDOP_MAX = 0x5, + + GFXS_BLENDOP_COUNT + }; + + enum GfxAlphaTest_e + { + GFXS_ALPHA_TEST_GT_0 = 0, + GFXS_ALPHA_TEST_GE_128 = 1, + + GFXS_ALPHA_TEST_COUNT + }; + + enum GfxCullFace_e + { + GFXS0_CULL_NONE = 1, + GFXS0_CULL_BACK = 2, + GFXS0_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, + + GFXS_POLYGON_OFFSET_COUNT + }; + + enum GfxStencilOp + { + GFXS_STENCILOP_KEEP = 0x0, + GFXS_STENCILOP_ZERO = 0x1, + GFXS_STENCILOP_REPLACE = 0x2, + GFXS_STENCILOP_INCRSAT = 0x3, + GFXS_STENCILOP_DECRSAT = 0x4, + GFXS_STENCILOP_INVERT = 0x5, + GFXS_STENCILOP_INCR = 0x6, + GFXS_STENCILOP_DECR = 0x7, + + GFXS_STENCILOP_COUNT, + }; + + enum GfxStencilFunc + { + 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, + }; + + 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 : 1; // 12 + unsigned int unused0 : 1; // 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 unused1 : 2; // 29-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; void /*ID3D11BlendState*/* blendState; void /*ID3D11DepthStencilState*/* depthStencilState; void /*ID3D11RasterizerState*/* rasterizerState; }; - /* struct IUnknown - { - IUnknownVtbl *vfptr; - };*/ - - /* struct __cppobj ID3D11DeviceChild : IUnknown - { - };*/ - - /* struct __cppobj ID3D11PixelShader : ID3D11DeviceChild - { - };*/ - - /* struct __cppobj ID3D11VertexShader : ID3D11DeviceChild - { - };*/ - struct MaterialPass { MaterialVertexDeclaration* vertexDecl; @@ -5489,24 +5728,50 @@ namespace T6 int contents; }; - /* struct __cppobj ID3D11BlendState : ID3D11DeviceChild + enum MaterialStreamStreamSource_e { - };*/ + STREAM_SRC_POSITION = 0x0, + STREAM_SRC_COLOR = 0x1, + STREAM_SRC_TEXCOORD_0 = 0x2, + STREAM_SRC_NORMAL = 0x3, + STREAM_SRC_TANGENT = 0x4, + STREAM_SRC_TEXCOORD_1 = 0x5, + STREAM_SRC_OPTIONAL_BEGIN = 0x6, + STREAM_SRC_PRE_OPTIONAL_BEGIN = 0x5, + STREAM_SRC_TEXCOORD_2 = 0x6, + STREAM_SRC_TEXCOORD_3 = 0x7, + STREAM_SRC_NORMAL_TRANSFORM_0 = 0x8, + STREAM_SRC_NORMAL_TRANSFORM_1 = 0x9, + STREAM_SRC_BLEND_WEIGHT = 0xA, - /* struct __cppobj ID3D11DepthStencilState : ID3D11DeviceChild - { - };*/ + STREAM_SRC_COUNT, + }; - /* struct __cppobj ID3D11RasterizerState : ID3D11DeviceChild + 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_TEXCOORD_8 = 0xD, + STREAM_DST_TEXCOORD_9 = 0xE, + STREAM_DST_TEXCOORD_10 = 0xF, + STREAM_DST_TEXCOORD_11 = 0x10, + STREAM_DST_TEXCOORD_12 = 0x11, + STREAM_DST_TEXCOORD_13 = 0x12, + STREAM_DST_BLENDWEIGHT = 0x13, - /* struct IUnknownVtbl - { - HRESULT (__stdcall *QueryInterface)(IUnknown *this, _GUID *, void **); - unsigned int (__stdcall *AddRef)(IUnknown *this); - unsigned int (__stdcall *Release)(IUnknown *this); - };*/ + STREAM_DST_COUNT, + }; struct MaterialStreamRouting { @@ -5539,6 +5804,301 @@ namespace T6 }; }; + enum MaterialType + { + MTL_TYPE_DEFAULT = 0x0, + MTL_TYPE_MODEL = 0x1, // m_ + MTL_TYPE_MODEL_VERTCOL = 0x2, // mc_ + MTL_TYPE_MODEL_LIGHTMAP_VC = 0x3, // ? + MTL_TYPE_WORLD_VERTCOL = 0x4, // wc_ + MTL_TYPE_PACKED_WORLD_VERTCOL = 0x5, // ? + MTL_TYPE_QUANT_WORLD = 0x6, // ? + MTL_TYPE_QUANT_WORLD_VERTCOL = 0x7, // ? + + MTL_TYPE_COUNT, + }; + + struct MaterialTypeInfo + { + const char* materialPrefix; + const char* techniqueSetPrefix; + }; + + 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_SPOTDIR = 0x2, + CONST_SRC_CODE_LIGHT_SPOTFACTORS = 0x3, + CONST_SRC_CODE_LIGHT_ATTENUATION = 0x4, + CONST_SRC_CODE_LIGHT_FALLOFF_A = 0x5, + CONST_SRC_CODE_LIGHT_FALLOFF_B = 0x6, + CONST_SRC_CODE_LIGHT_SPOT_MATRIX0 = 0x7, + CONST_SRC_CODE_LIGHT_SPOT_MATRIX1 = 0x8, + CONST_SRC_CODE_LIGHT_SPOT_MATRIX2 = 0x9, + CONST_SRC_CODE_LIGHT_SPOT_MATRIX3 = 0xA, + CONST_SRC_CODE_LIGHT_SPOT_AABB = 0xB, + CONST_SRC_CODE_LIGHT_CONE_CONTROL1 = 0xC, + CONST_SRC_CODE_LIGHT_CONE_CONTROL2 = 0xD, + CONST_SRC_CODE_LIGHT_SPOT_COOKIE_SLIDE_CONTROL = 0xE, + CONST_SRC_CODE_SHADOW_PARMS = 0xF, + CONST_SRC_CODE_SHADOWMAP_POLYGON_OFFSET = 0x10, + CONST_SRC_CODE_RENDER_TARGET_SIZE = 0x11, + CONST_SRC_CODE_UPSCALED_TARGET_SIZE = 0x12, + CONST_SRC_CODE_DOF_EQUATION_VIEWMODEL_AND_FAR_BLUR = 0x13, + CONST_SRC_CODE_DOF_EQUATION_SCENE = 0x14, + CONST_SRC_CODE_DOF_LERP_SCALE = 0x15, + CONST_SRC_CODE_DOF_LERP_BIAS = 0x16, + CONST_SRC_CODE_DOF_ROW_DELTA = 0x17, + CONST_SRC_CODE_PARTICLE_CLOUD_COLOR = 0x18, + CONST_SRC_CODE_GAMETIME = 0x19, + + CONST_SRC_CODE_MAYBE_DIRTY_PS_END = 0x1A, + CONST_SRC_CODE_ALWAYS_DIRTY_PS_BEGIN = 0x1A, + + CONST_SRC_CODE_FILTER_TAP_0 = 0x1A, + CONST_SRC_CODE_FILTER_TAP_1 = 0x1B, + CONST_SRC_CODE_FILTER_TAP_2 = 0x1C, + CONST_SRC_CODE_FILTER_TAP_3 = 0x1D, + CONST_SRC_CODE_FILTER_TAP_4 = 0x1E, + CONST_SRC_CODE_FILTER_TAP_5 = 0x1F, + CONST_SRC_CODE_FILTER_TAP_6 = 0x20, + CONST_SRC_CODE_FILTER_TAP_7 = 0x21, + CONST_SRC_CODE_COLOR_MATRIX_R = 0x22, + CONST_SRC_CODE_COLOR_MATRIX_G = 0x23, + CONST_SRC_CODE_COLOR_MATRIX_B = 0x24, + + CONST_SRC_CODE_ALWAYS_DIRTY_PS_END = 0x25, + CONST_SRC_CODE_NEVER_DIRTY_PS_BEGIN = 0x25, + + CONST_SRC_CODE_SHADOWMAP_SWITCH_PARTITION = 0x25, + CONST_SRC_CODE_SUNSHADOWMAP_PIXEL_SIZE = 0x26, + CONST_SRC_CODE_SHADOWMAP_SCALE = 0x27, + CONST_SRC_CODE_ZNEAR = 0x28, + CONST_SRC_CODE_SUN_POSITION = 0x29, + CONST_SRC_CODE_SUN_DIFFUSE = 0x2A, + CONST_SRC_CODE_LIGHTING_LOOKUP_SCALE = 0x2B, + CONST_SRC_CODE_DEBUG_BUMPMAP = 0x2C, + CONST_SRC_CODE_DEBUG_PERFORMANCE = 0x2D, + CONST_SRC_CODE_MATERIAL_COLOR = 0x2E, + CONST_SRC_CODE_FOG = 0x2F, + CONST_SRC_CODE_FOG2 = 0x30, + CONST_SRC_CODE_FOG_COLOR = 0x31, + CONST_SRC_CODE_SUN_FOG = 0x32, + CONST_SRC_CODE_SUN_FOG_DIR = 0x33, + CONST_SRC_CODE_SUN_FOG_COLOR = 0x34, + CONST_SRC_CODE_GLOW_SETUP = 0x35, + CONST_SRC_CODE_GLOW_APPLY = 0x36, + CONST_SRC_CODE_COLOR_BIAS = 0x37, + CONST_SRC_CODE_COLOR_TINT_BASE = 0x38, + CONST_SRC_CODE_COLOR_TINT_DELTA = 0x39, + CONST_SRC_CODE_OUTDOOR_FEATHER_PARMS = 0x3A, + CONST_SRC_CODE_SKY_TRANSITION = 0x3B, + CONST_SRC_CODE_SPOT_SHADOWMAP_PIXEL_ADJUST = 0x3C, + CONST_SRC_CODE_DLIGHT_SPOT_SHADOWMAP_PIXEL_ADJUST = 0x3D, + CONST_SRC_CODE_CLIP_SPACE_LOOKUP_SCALE = 0x3E, + CONST_SRC_CODE_CLIP_SPACE_LOOKUP_OFFSET = 0x3F, + CONST_SRC_CODE_PARTICLE_CLOUD_MATRIX = 0x40, + CONST_SRC_CODE_PARTICLE_CLOUD_VEL_WORLD = 0x41, + CONST_SRC_CODE_DEPTH_FROM_CLIP = 0x42, + CONST_SRC_CODE_CODE_MESH_ARG_0 = 0x43, + CONST_SRC_CODE_CODE_MESH_ARG_1 = 0x44, + CONST_SRC_CODE_CODE_MESH_ARG_LAST = 0x44, + CONST_SRC_CODE_GRID_LIGHTING_COORDS_AND_VIS = 0x45, + CONST_SRC_CODE_GRID_LIGHTING_SH_0 = 0x46, + CONST_SRC_CODE_GRID_LIGHTING_SH_1 = 0x47, + CONST_SRC_CODE_GRID_LIGHTING_SH_2 = 0x48, + CONST_SRC_CODE_REFLECTION_LIGHTING_SH_0 = 0x49, + CONST_SRC_CODE_REFLECTION_LIGHTING_SH_1 = 0x4A, + CONST_SRC_CODE_REFLECTION_LIGHTING_SH_2 = 0x4B, + CONST_SRC_CODE_WIND_DIRECTION = 0x4C, + CONST_SRC_CODE_MOTIONBLUR_DIRECTION_AND_MAGNITUDE = 0x4D, + CONST_SRC_CODE_COMPOSITE_FX_DISTORTION = 0x4E, + CONST_SRC_CODE_GLOW_BLOOM_SCALE = 0x4F, + CONST_SRC_CODE_COMPOSITE_FX_OVERLAY_TEXCOORD = 0x50, + CONST_SRC_CODE_COLOR_BIAS1 = 0x51, + CONST_SRC_CODE_COLOR_TINT_BASE1 = 0x52, + CONST_SRC_CODE_COLOR_TINT_DELTA1 = 0x53, + CONST_SRC_CODE_POSTFX_FADE_EFFECT = 0x54, + CONST_SRC_CODE_VIEWPORT_DIMENSIONS = 0x55, + CONST_SRC_CODE_FRAMEBUFFER_READ = 0x56, + CONST_SRC_CODE_RESIZE_PARAMS1 = 0x57, + CONST_SRC_CODE_RESIZE_PARAMS2 = 0x58, + CONST_SRC_CODE_RESIZE_PARAMS3 = 0x59, + CONST_SRC_CODE_VARIANT_WIND_SPRING_0 = 0x5A, + CONST_SRC_CODE_VARIANT_WIND_SPRING_1 = 0x5B, + CONST_SRC_CODE_VARIANT_WIND_SPRING_2 = 0x5C, + CONST_SRC_CODE_VARIANT_WIND_SPRING_3 = 0x5D, + CONST_SRC_CODE_VARIANT_WIND_SPRING_4 = 0x5E, + CONST_SRC_CODE_VARIANT_WIND_SPRING_5 = 0x5F, + CONST_SRC_CODE_VARIANT_WIND_SPRING_6 = 0x60, + CONST_SRC_CODE_VARIANT_WIND_SPRING_7 = 0x61, + CONST_SRC_CODE_VARIANT_WIND_SPRING_8 = 0x62, + CONST_SRC_CODE_VARIANT_WIND_SPRING_9 = 0x63, + CONST_SRC_CODE_VARIANT_WIND_SPRING_10 = 0x64, + CONST_SRC_CODE_VARIANT_WIND_SPRING_11 = 0x65, + CONST_SRC_CODE_VARIANT_WIND_SPRING_12 = 0x66, + CONST_SRC_CODE_VARIANT_WIND_SPRING_13 = 0x67, + CONST_SRC_CODE_VARIANT_WIND_SPRING_14 = 0x68, + CONST_SRC_CODE_VARIANT_WIND_SPRING_15 = 0x69, + CONST_SRC_CODE_CHARACTER_CHARRED_AMOUNT = 0x6A, + CONST_SRC_CODE_POSTFX_CONTROL0 = 0x6B, + CONST_SRC_CODE_POSTFX_CONTROL1 = 0x6C, + CONST_SRC_CODE_POSTFX_CONTROL2 = 0x6D, + CONST_SRC_CODE_POSTFX_CONTROL3 = 0x6E, + CONST_SRC_CODE_POSTFX_CONTROL4 = 0x6F, + CONST_SRC_CODE_POSTFX_CONTROL5 = 0x70, + CONST_SRC_CODE_POSTFX_CONTROL6 = 0x71, + CONST_SRC_CODE_POSTFX_CONTROL7 = 0x72, + CONST_SRC_CODE_POSTFX_CONTROL8 = 0x73, + CONST_SRC_CODE_POSTFX_CONTROL9 = 0x74, + CONST_SRC_CODE_POSTFX_CONTROLA = 0x75, + CONST_SRC_CODE_POSTFX_CONTROLB = 0x76, + CONST_SRC_CODE_POSTFX_CONTROLC = 0x77, + CONST_SRC_CODE_POSTFX_CONTROLD = 0x78, + CONST_SRC_CODE_POSTFX_CONTROLE = 0x79, + CONST_SRC_CODE_POSTFX_CONTROLF = 0x7A, + CONST_SRC_CODE_HDRCONTROL_0 = 0x7B, + CONST_SRC_CODE_HDRCONTROL_1 = 0x7C, + CONST_SRC_CODE_GLIGHT_POSXS = 0x7D, + CONST_SRC_CODE_GLIGHT_POSYS = 0x7E, + CONST_SRC_CODE_GLIGHT_POSZS = 0x7F, + CONST_SRC_CODE_GLIGHT_FALLOFFS = 0x80, + CONST_SRC_CODE_GLIGHT_REDS = 0x81, + CONST_SRC_CODE_GLIGHT_GREENS = 0x82, + CONST_SRC_CODE_GLIGHT_BLUES = 0x83, + CONST_SRC_CODE_DLIGHT_POSITION = 0x84, + CONST_SRC_CODE_DLIGHT_DIFFUSE = 0x85, + CONST_SRC_CODE_DLIGHT_ATTENUATION = 0x86, + CONST_SRC_CODE_DLIGHT_FALLOFF = 0x87, + CONST_SRC_CODE_DLIGHT_SPOT_MATRIX_0 = 0x88, + CONST_SRC_CODE_DLIGHT_SPOT_MATRIX_1 = 0x89, + CONST_SRC_CODE_DLIGHT_SPOT_MATRIX_2 = 0x8A, + CONST_SRC_CODE_DLIGHT_SPOT_MATRIX_3 = 0x8B, + CONST_SRC_CODE_DLIGHT_SPOT_DIR = 0x8C, + CONST_SRC_CODE_DLIGHT_SPOT_FACTORS = 0x8D, + CONST_SRC_CODE_DLIGHT_SHADOW_LOOKUP_MATRIX_0 = 0x8E, + CONST_SRC_CODE_DLIGHT_SHADOW_LOOKUP_MATRIX_1 = 0x8F, + CONST_SRC_CODE_DLIGHT_SHADOW_LOOKUP_MATRIX_2 = 0x90, + CONST_SRC_CODE_DLIGHT_SHADOW_LOOKUP_MATRIX_3 = 0x91, + CONST_SRC_CODE_CLOUD_LAYER_CONTROL0 = 0x92, + CONST_SRC_CODE_CLOUD_LAYER_CONTROL1 = 0x93, + CONST_SRC_CODE_CLOUD_LAYER_CONTROL2 = 0x94, + CONST_SRC_CODE_CLOUD_LAYER_CONTROL3 = 0x95, + CONST_SRC_CODE_CLOUD_LAYER_CONTROL4 = 0x96, + CONST_SRC_CODE_HERO_LIGHTING_R = 0x97, + CONST_SRC_CODE_HERO_LIGHTING_G = 0x98, + CONST_SRC_CODE_HERO_LIGHTING_B = 0x99, + CONST_SRC_CODE_LIGHT_HERO_SCALE = 0x9A, + CONST_SRC_CODE_CINEMATIC_BLUR_BOX = 0x9B, + CONST_SRC_CODE_CINEMATIC_BLUR_BOX2 = 0x9C, + CONST_SRC_CODE_ADSZSCALE = 0x9D, + CONST_SRC_CODE_UI3D_UV_SETUP_0 = 0x9E, + CONST_SRC_CODE_UI3D_UV_SETUP_1 = 0x9F, + CONST_SRC_CODE_UI3D_UV_SETUP_2 = 0xA0, + CONST_SRC_CODE_UI3D_UV_SETUP_3 = 0xA1, + CONST_SRC_CODE_UI3D_UV_SETUP_4 = 0xA2, + CONST_SRC_CODE_UI3D_UV_SETUP_5 = 0xA3, + CONST_SRC_CODE_CHARACTER_DISSOLVE_COLOR = 0xA4, + CONST_SRC_CODE_CAMERA_LOOK = 0xA5, + CONST_SRC_CODE_CAMERA_UP = 0xA6, + CONST_SRC_CODE_CAMERA_SIDE = 0xA7, + CONST_SRC_CODE_RIMINTENSITY = 0xA8, + CONST_SRC_CODE_GENERIC_PARAM0 = 0xA9, + CONST_SRC_CODE_GENERIC_PARAM1 = 0xAA, + CONST_SRC_CODE_GENERIC_PARAM2 = 0xAB, + CONST_SRC_CODE_GENERIC_PARAM3 = 0xAC, + CONST_SRC_CODE_GENERIC_PARAM4 = 0xAD, + CONST_SRC_CODE_GENERIC_PARAM5 = 0xAE, + CONST_SRC_CODE_GENERIC_PARAM6 = 0xAF, + CONST_SRC_CODE_GENERIC_PARAM7 = 0xB0, + CONST_SRC_CODE_GENERIC_EYEOFFSET = 0xB1, + CONST_SRC_CODE_GENERIC_QUADINTENSITY = 0xB2, + CONST_SRC_CODE_WEAPON_PARAM0 = 0xB3, + CONST_SRC_CODE_WEAPON_PARAM1 = 0xB4, + CONST_SRC_CODE_WEAPON_PARAM2 = 0xB5, + CONST_SRC_CODE_WEAPON_PARAM3 = 0xB6, + CONST_SRC_CODE_WEAPON_PARAM4 = 0xB7, + CONST_SRC_CODE_WEAPON_PARAM5 = 0xB8, + CONST_SRC_CODE_WEAPON_PARAM6 = 0xB9, + CONST_SRC_CODE_WEAPON_PARAM7 = 0xBA, + CONST_SRC_CODE_WEAPON_PARAM8 = 0xBB, + CONST_SRC_CODE_WEAPON_PARAM9 = 0xBC, + CONST_SRC_CODE_QRCODE_0 = 0xBD, + CONST_SRC_CODE_QRCODE_1 = 0xBE, + CONST_SRC_CODE_QRCODE_2 = 0xBF, + CONST_SRC_CODE_QRCODE_3 = 0xC0, + CONST_SRC_CODE_QRCODE_4 = 0xC1, + CONST_SRC_CODE_QRCODE_5 = 0xC2, + CONST_SRC_CODE_QRCODE_6 = 0xC3, + CONST_SRC_CODE_QRCODE_7 = 0xC4, + CONST_SRC_CODE_QRCODE_8 = 0xC5, + CONST_SRC_CODE_QRCODE_9 = 0xC6, + CONST_SRC_CODE_QRCODE_10 = 0xC7, + CONST_SRC_CODE_QRCODE_11 = 0xC8, + CONST_SRC_CODE_EYEOFFSET = 0xC9, + CONST_SRC_CODE_SKY_COLOR_MULTIPLIER = 0xCA, + CONST_SRC_CODE_EXTRA_CAM_PARAM = 0xCB, + CONST_SRC_CODE_EMBLEM_LUT_SELECTOR = 0xCC, + CONST_SRC_CODE_DEBUG_COLOR_OVERRIDE = 0xCD, + CONST_SRC_CODE_DEBUG_ALPHA_OVERRIDE = 0xCE, + CONST_SRC_CODE_DEBUG_NORMAL_OVERRIDE = 0xCF, + CONST_SRC_CODE_DEBUG_SPECULAR_OVERRIDE = 0xD0, + CONST_SRC_CODE_DEBUG_GLOSS_OVERRIDE = 0xD1, + CONST_SRC_CODE_DEBUG_OCCLUSION_OVERRIDE = 0xD2, + + CONST_SRC_CODE_NEVER_DIRTY_PS_END = 0xD3, + CONST_SRC_CODE_COUNT_FLOAT4 = 0xD3, + CONST_SRC_FIRST_CODE_MATRIX = 0xD3, + + CONST_SRC_CODE_WORLD_MATRIX = 0xD3, + CONST_SRC_CODE_INVERSE_WORLD_MATRIX = 0xD4, + CONST_SRC_CODE_TRANSPOSE_WORLD_MATRIX = 0xD5, + CONST_SRC_CODE_INVERSE_TRANSPOSE_WORLD_MATRIX = 0xD6, + CONST_SRC_CODE_VIEW_MATRIX = 0xD7, + CONST_SRC_CODE_INVERSE_VIEW_MATRIX = 0xD8, + CONST_SRC_CODE_TRANSPOSE_VIEW_MATRIX = 0xD9, + CONST_SRC_CODE_INVERSE_TRANSPOSE_VIEW_MATRIX = 0xDA, + CONST_SRC_CODE_PROJECTION_MATRIX = 0xDB, + CONST_SRC_CODE_INVERSE_PROJECTION_MATRIX = 0xDC, + CONST_SRC_CODE_TRANSPOSE_PROJECTION_MATRIX = 0xDD, + CONST_SRC_CODE_INVERSE_TRANSPOSE_PROJECTION_MATRIX = 0xDE, + CONST_SRC_CODE_WORLD_VIEW_MATRIX = 0xDF, + CONST_SRC_CODE_INVERSE_WORLD_VIEW_MATRIX = 0xE0, + CONST_SRC_CODE_TRANSPOSE_WORLD_VIEW_MATRIX = 0xE1, + CONST_SRC_CODE_INVERSE_TRANSPOSE_WORLD_VIEW_MATRIX = 0xE2, + CONST_SRC_CODE_VIEW_PROJECTION_MATRIX = 0xE3, + CONST_SRC_CODE_INVERSE_VIEW_PROJECTION_MATRIX = 0xE4, + CONST_SRC_CODE_TRANSPOSE_VIEW_PROJECTION_MATRIX = 0xE5, + CONST_SRC_CODE_INVERSE_TRANSPOSE_VIEW_PROJECTION_MATRIX = 0xE6, + CONST_SRC_CODE_WORLD_VIEW_PROJECTION_MATRIX = 0xE7, + CONST_SRC_CODE_INVERSE_WORLD_VIEW_PROJECTION_MATRIX = 0xE8, + CONST_SRC_CODE_TRANSPOSE_WORLD_VIEW_PROJECTION_MATRIX = 0xE9, + CONST_SRC_CODE_INVERSE_TRANSPOSE_WORLD_VIEW_PROJECTION_MATRIX = 0xEA, + CONST_SRC_CODE_SHADOW_LOOKUP_MATRIX = 0xEB, + CONST_SRC_CODE_INVERSE_SHADOW_LOOKUP_MATRIX = 0xEC, + CONST_SRC_CODE_TRANSPOSE_SHADOW_LOOKUP_MATRIX = 0xED, + CONST_SRC_CODE_INVERSE_TRANSPOSE_SHADOW_LOOKUP_MATRIX = 0xEE, + CONST_SRC_CODE_WORLD_OUTDOOR_LOOKUP_MATRIX = 0xEF, + CONST_SRC_CODE_INVERSE_WORLD_OUTDOOR_LOOKUP_MATRIX = 0xF0, + CONST_SRC_CODE_TRANSPOSE_WORLD_OUTDOOR_LOOKUP_MATRIX = 0xF1, + CONST_SRC_CODE_INVERSE_TRANSPOSE_WORLD_OUTDOOR_LOOKUP_MATRIX = 0xF2, + + CONST_SRC_TOTAL_COUNT, + CONST_SRC_NONE, + }; + + struct CodeConstantSource + { + const char* name; + char source; + CodeConstantSource* subtable; + int arrayCount; + int arrayStride; + }; + struct MaterialArgumentCodeConst { uint16_t index; diff --git a/src/ObjCommon/Game/IW4/TechsetConstantsIW4.h b/src/ObjCommon/Game/IW4/TechsetConstantsIW4.h index e2b55319..7453aded 100644 --- a/src/ObjCommon/Game/IW4/TechsetConstantsIW4.h +++ b/src/ObjCommon/Game/IW4/TechsetConstantsIW4.h @@ -77,6 +77,7 @@ namespace IW4 "texcoord[7]", }; static_assert(std::extent_v == STREAM_DST_COUNT); + static const char* materialStreamDestinationAbbreviation[]{ "p", "n", @@ -106,6 +107,7 @@ namespace IW4 "normalTransform[1]", }; static_assert(std::extent_v == STREAM_SRC_COUNT); + static const char* materialStreamSourceAbbreviation[]{ "p", "c", diff --git a/src/ObjCommon/Game/T6/MaterialConstantsT6.h b/src/ObjCommon/Game/T6/MaterialConstantsT6.h new file mode 100644 index 00000000..393d5178 --- /dev/null +++ b/src/ObjCommon/Game/T6/MaterialConstantsT6.h @@ -0,0 +1,119 @@ +#pragma once + +#include "Game/T6/CommonT6.h" +#include "Game/T6/T6.h" + +namespace T6 +{ + inline const char* textureSemanticNames[]{ + "2D", "function", "colorMap", "unused1", "unused2", "normalMap", "unused3", "unused4", "specularMap", "unused5", + "occlusionMap", "unused6", "color0Map", "color1Map", "color2Map", "color3Map", "color4Map", "color5Map", "color6Map", "color7Map", + "color8Map", "color9Map", "color10Map", "color11Map", "color12Map", "color13Map", "color14Map", "color15Map", "throwMap", + }; + static_assert(std::extent_v == TS_COUNT); + + inline const char* cameraRegionNames[]{ + "litOpaque", + "litTrans", + "litQuasiOpaque", + "emissiveOpaque", + "emissiveTrans", + "emissiveFx", + "lightMapOpaque", + "depthHack", + "unused", + "sonar", + "none", + }; + static_assert(std::extent_v == CAMERA_REGION_NONE + 1); + + static const char* textureFilterNames[]{ + "disabled", + "nearest", + "linear", + "aniso2x", + "aniso4x", + "compare", + }; + static_assert(std::extent_v == TEXTURE_FILTER_COUNT); + + static const char* samplerStateMipMapNames[]{ + "disabled", + "nearest", + "linear", + }; + static_assert(std::extent_v == SAMPLER_MIPMAP_ENUM_COUNT); + + static const char* gameFlagNames[]{ + "1", + "2", + "NO_MARKS", + "8", + "10", + "20", + "CASTS_SHADOW", + "80", + "100", + "200", + "400", + "800", + "1000", + }; + + inline const char* blendNames[]{ + "disabled", + "zero", + "one", + "srccolor", + "invsrccolor", + "srcalpha", + "invsrcalpha", + "destalpha", + "invdestalpha", + "destcolor", + "invdestcolor", + }; + static_assert(std::extent_v == GFXS_BLEND_COUNT); + + inline const char* blendOpNames[]{ + "disabled", + "add", + "subtract", + "revsubtract", + "min", + "max", + }; + static_assert(std::extent_v == GFXS_BLENDOP_COUNT); + + inline const char* polygonOffsetNames[]{ + "offset0", + "offset1", + "offset2", + "offsetShadowmap", + }; + static_assert(std::extent_v == GFXS_POLYGON_OFFSET_COUNT); + + inline const char* stencilOpNames[]{ + "keep", + "zero", + "replace", + "incrsat", + "decrsat", + "invert", + "incr", + "decr", + }; + static_assert(std::extent_v == GFXS_STENCILOP_COUNT); + + inline const char* stencilFuncNames[]{ + "never", + "less", + "equal", + "lessequal", + "greater", + "notequal", + "greaterequal", + "always", + }; + static_assert(std::extent_v == GFXS_STENCILFUNC_COUNT); +} // namespace T6 diff --git a/src/ObjCommon/Game/T6/TechsetConstantsT6.h b/src/ObjCommon/Game/T6/TechsetConstantsT6.h new file mode 100644 index 00000000..48f3be31 --- /dev/null +++ b/src/ObjCommon/Game/T6/TechsetConstantsT6.h @@ -0,0 +1,101 @@ +#pragma once + +#include "Game/T6/CommonT6.h" +#include "Game/T6/T6.h" + +namespace T6 +{ + inline const char* techniqueTypeNames[]{ + "depth prepass", + "build shadowmap depth", + "unlit", + "emissive", + "lit", + "lit sun", + "lit sun shadow", + "lit spot", + "lit spot shadow", + "lit spot square", + "lit spot square shadow", + "lit spot round", + "lit spot round shadow", + "lit omni", + "lit omni shadow", + "lit dlight glight", + "lit sun dlight glight", + "lit sun shadow dlight glight", + "lit spot dlight glight", + "lit spot shadow dlight glight", + "lit spot square dlight glight", + "lit spot square shadow dlight glight", + "lit spot round dlight glight", + "lit spot round shadow dlight glight", + "lit omni dlight glight", + "lit omni shadow dlight glight", + "light spot", + "light omni", + "fakelight normal", + "fakelight view", + "sunlight preview", + "case texture", + "solid wireframe", + "shaded wireframe", + "debug bumpmap", + "debug performance", + }; + static_assert(std::extent_v == TECHNIQUE_COUNT); + + static const char* materialStreamDestinationNames[]{ + "position", "normal", "color[0]", "color[1]", "depth", "texcoord[0]", "texcoord[1]", + "texcoord[2]", "texcoord[3]", "texcoord[4]", "texcoord[5]", "texcoord[6]", "texcoord[7]", "texcoord[8]", + "texcoord[9]", "texcoord[10]", "texcoord[11]", "texcoord[12]", "texcoord[13]", "blendWeight", + }; + static_assert(std::extent_v == STREAM_DST_COUNT); + + static const char* materialStreamDestinationAbbreviation[]{ + "p", "n", "c0", "c1", "d", "t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7", "t8", "t9", "t10", "t11", "t12", "t13", "b", + }; + static_assert(std::extent_v == STREAM_DST_COUNT); + + static const char* materialStreamSourceNames[]{ + "position", + "color", + "texcoord[0]", + "normal", + "tangent", + "texcoord[1]", + "texcoord[2]", + "texcoord[3]", + "normalTransform[0]", + "normalTransform[1]", + "blendWeight", + }; + static_assert(std::extent_v == STREAM_SRC_COUNT); + + static const char* materialStreamSourceAbbreviation[]{ + "p", + "c", + "t0", + "n", + "t", + "t1", + "t2", + "t3", + "n0", + "n1", + "b", + }; + static_assert(std::extent_v == STREAM_SRC_COUNT); + + inline MaterialTypeInfo g_materialTypeInfo[]{ + {"", "" }, + {"m/", "m_" }, + {"mc/", "mc_"}, + {"?", "?" }, + {"wc/", "wc_"}, + {"?", "?" }, + {"?", "?" }, + {"?", "?" }, + }; // TODO: Fill this + static_assert(std::extent_v == MTL_TYPE_COUNT); +} // namespace T6 diff --git a/src/ObjWriting/Game/T6/AssetDumpers/AssetDumperMaterial.cpp b/src/ObjWriting/Game/T6/AssetDumpers/AssetDumperMaterial.cpp new file mode 100644 index 00000000..bcdac91f --- /dev/null +++ b/src/ObjWriting/Game/T6/AssetDumpers/AssetDumperMaterial.cpp @@ -0,0 +1,362 @@ +#include "AssetDumperMaterial.h" + +#include "Game/T6/CommonT6.h" +#include "Game/T6/MaterialConstantsT6.h" +#include "Game/T6/TechsetConstantsT6.h" + +#include +#include +#include + +using namespace T6; +using namespace nlohmann; + +namespace T6::material +{ +#define KNOWN_HASH(strValue) \ + { \ + Common::R_HashString(strValue, 0), strValue \ + } + + std::unordered_map knownHashes{ + KNOWN_HASH("colorMap"), + KNOWN_HASH("normalMap"), + KNOWN_HASH("specularMap"), + }; + + class JsonDumper + { + public: + explicit JsonDumper(std::ostream& stream) + : m_stream(stream) + { + } + + void Dump(const Material* material) const + { + json jRoot; + + jRoot["_type"] = "material"; + jRoot["_version"] = 1; + + MaterialToJson(jRoot, material); + + m_stream << std::setw(4) << jRoot << "\n"; + } + + private: + template static void JsonEnumEntry(json& j, const char* key, const unsigned value, const char* (&enumValues)[SIZE]) + { + static_assert(SIZE > 0); + JsonEnumEntry(j, key, value, enumValues, SIZE); + } + + static void JsonEnumEntry(json& j, const char* key, const unsigned value, const char** enumValues, const size_t enumValueCount) + { + assert(value < enumValueCount); + + if (value < enumValueCount) + j[key] = enumValues[value]; + else + j[key] = nullptr; + } + + static void MaterialToJson(json& jRoot, const Material* material) + { + MaterialInfoToJson(jRoot, material); + StateBitsEntryToJson(jRoot, material); + jRoot["stateFlags"] = material->stateFlags; + JsonEnumEntry(jRoot, "cameraRegion", material->cameraRegion, cameraRegionNames); + jRoot["probeMipBits"] = material->probeMipBits; + TechniqueSetToJson(jRoot, material->techniqueSet); + TextureTableToJson(jRoot, material); + ConstantTableToJson(jRoot, material); + StateBitsTableToJson(jRoot, material); + ThermalMaterialToJson(jRoot, material->thermalMaterial); + } + + static void MaterialInfoToJson(json& jRoot, const Material* material) + { + const auto& info = material->info; + + json jGameFlags = json::array(); + for (auto bitIndex = 0u; bitIndex < sizeof(info.gameFlags) * 8u; bitIndex++) + { + if (info.gameFlags & (1 << bitIndex)) + { + if (bitIndex >= std::extent_v) + { + std::ostringstream ss; + ss << std::hex << (1 << bitIndex); + jGameFlags.push_back(ss.str()); + } + else + jGameFlags.push_back(gameFlagNames[bitIndex]); + } + } + jRoot["gameFlags"] = std::move(jGameFlags); + + jRoot["sortKey"] = info.sortKey; + + json jTextureAtlas; + jTextureAtlas["rows"] = info.textureAtlasRowCount; + jTextureAtlas["columns"] = info.textureAtlasColumnCount; + jRoot["textureAtlas"] = std::move(jTextureAtlas); + + jRoot["surfaceTypeBits"] = info.surfaceTypeBits; + jRoot["layeredSurfaceTypes"] = info.layeredSurfaceTypes; + jRoot["hashIndex"] = info.hashIndex; + jRoot["surfaceFlags"] = info.surfaceFlags; + jRoot["contents"] = info.contents; + } + + static void StateBitsEntryToJson(json& jRoot, const Material* material) + { + json jStateBitsEntry = json::array(); + + for (const char c : material->stateBitsEntry) + jStateBitsEntry.push_back(static_cast(c)); + + jRoot["stateBitsEntry"] = std::move(jStateBitsEntry); + } + + static void TechniqueSetToJson(json& jRoot, const MaterialTechniqueSet* techniqueSet) + { + if (techniqueSet && techniqueSet->name) + jRoot["techniqueSet"] = AssetName(techniqueSet->name); + else + jRoot["techniqueSet"] = nullptr; + } + + static void TextureTableToJson(json& jRoot, const Material* material) + { + json jTextures = json::array(); + if (material->textureTable) + { + for (auto textureIndex = 0u; textureIndex < material->textureCount; textureIndex++) + { + json jTexture; + TextureDefToJson(jTexture, &material->textureTable[textureIndex]); + jTextures.emplace_back(std::move(jTexture)); + } + } + jRoot["textures"] = std::move(jTextures); + } + + static void TextureDefToJson(json& jTexture, const MaterialTextureDef* textureDef) + { + const auto knownHash = knownHashes.find(textureDef->nameHash); + if (knownHash == knownHashes.end()) + { + jTexture["nameHash"] = textureDef->nameHash; + jTexture["nameStart"] = std::string(1u, textureDef->nameStart); + jTexture["nameEnd"] = std::string(1u, textureDef->nameEnd); + } + else + { + jTexture["name"] = knownHash->second; + } + + JsonEnumEntry(jTexture, "semantic", textureDef->semantic, textureSemanticNames); + jTexture["isMatureContent"] = textureDef->isMatureContent; + + json jSamplerState; + SamplerStateToJson(jSamplerState, textureDef->samplerState); + jTexture["samplerState"] = std::move(jSamplerState); + + if (textureDef->image && textureDef->image->name) + jTexture["image"] = AssetName(textureDef->image->name); + else + jTexture["image"] = nullptr; + } + + static void SamplerStateToJson(json& jSamplerState, const MaterialTextureDefSamplerState& samplerState) + { + JsonEnumEntry(jSamplerState, "filter", samplerState.filter, textureFilterNames); + JsonEnumEntry(jSamplerState, "mipMap", samplerState.mipMap, samplerStateMipMapNames); + jSamplerState["clampU"] = samplerState.clampU ? true : false; + jSamplerState["clampV"] = samplerState.clampV ? true : false; + jSamplerState["clampW"] = samplerState.clampW ? true : false; + } + + static void ConstantTableToJson(json& jRoot, const Material* material) + { + json jConstants = json::array(); + if (material->constantTable) + { + for (auto constantIndex = 0u; constantIndex < material->constantCount; constantIndex++) + { + json jConstant; + ConstantDefToJson(jConstant, &material->constantTable[constantIndex]); + jConstants.emplace_back(std::move(jConstant)); + } + } + jRoot["constants"] = std::move(jConstants); + } + + static void ConstantDefToJson(json& jConstant, const MaterialConstantDef* textureDef) + { + const auto fragmentLength = strnlen(textureDef->name, std::extent_v); + const std::string nameFragment(textureDef->name, fragmentLength); + + if (fragmentLength < std::extent_v || Common::R_HashString(nameFragment.c_str(), 0) == textureDef->nameHash) + { + jConstant["name"] = nameFragment; + } + else + { + jConstant["nameHash"] = textureDef->nameHash; + jConstant["nameFragment"] = nameFragment; + } + + json jLiteral; + jLiteral.push_back(textureDef->literal.v[0]); + jLiteral.push_back(textureDef->literal.v[1]); + jLiteral.push_back(textureDef->literal.v[2]); + jLiteral.push_back(textureDef->literal.v[3]); + jConstant["literal"] = std::move(jLiteral); + } + + static void StateBitsTableToJson(json& jRoot, const Material* material) + { + json jStateBits = json::array(); + if (material->stateBitsTable) + { + for (auto stateBitsEntryIndex = 0u; stateBitsEntryIndex < material->stateBitsCount; stateBitsEntryIndex++) + { + json jStateBitsEntry; + StateBitsEntryToJson(jStateBitsEntry, &material->stateBitsTable[stateBitsEntryIndex].loadBits.structured); + jStateBits.emplace_back(std::move(jStateBitsEntry)); + } + } + jRoot["stateBits"] = std::move(jStateBits); + } + + static void StateBitsEntryToJson(json& jStateBitsEntry, const GfxStateBitsLoadBitsStructured* structured) + { + JsonEnumEntry(jStateBitsEntry, "srcBlendRgb", std::min(structured->srcBlendRgb, std::extent_v - 1u), blendNames); + JsonEnumEntry(jStateBitsEntry, "dstBlendRgb", std::min(structured->dstBlendRgb, std::extent_v - 1u), blendNames); + JsonEnumEntry(jStateBitsEntry, "blendOpRgb", std::min(structured->blendOpRgb, std::extent_v - 1u), blendOpNames); + + assert(structured->alphaTestDisabled || structured->alphaTest == GFXS_ALPHA_TEST_GT_0 || structured->alphaTest == GFXS_ALPHA_TEST_GE_128); + if (structured->alphaTestDisabled) + jStateBitsEntry["alphaTest"] = "disabled"; + else if (structured->alphaTest == GFXS_ALPHA_TEST_GT_0) + jStateBitsEntry["alphaTest"] = "gt0"; + else if (structured->alphaTest == GFXS_ALPHA_TEST_GE_128) + jStateBitsEntry["alphaTest"] = "ge128"; + + assert(structured->cullFace == GFXS0_CULL_NONE || structured->cullFace == GFXS0_CULL_BACK || structured->cullFace == GFXS0_CULL_FRONT); + if (structured->cullFace == GFXS0_CULL_NONE) + jStateBitsEntry["cullFace"] = "none"; + else if (structured->cullFace == GFXS0_CULL_BACK) + jStateBitsEntry["cullFace"] = "back"; + else if (structured->cullFace == GFXS0_CULL_FRONT) + jStateBitsEntry["cullFace"] = "front"; + + JsonEnumEntry(jStateBitsEntry, "srcBlendRgb", std::min(structured->srcBlendAlpha, std::extent_v - 1u), blendNames); + JsonEnumEntry(jStateBitsEntry, "dstBlendRgb", std::min(structured->dstBlendAlpha, std::extent_v - 1u), blendNames); + JsonEnumEntry(jStateBitsEntry, "blendOpRgb", std::min(structured->blendOpAlpha, std::extent_v - 1u), blendOpNames); + jStateBitsEntry["colorWriteRgb"] = static_cast(structured->colorWriteRgb); + jStateBitsEntry["colorWriteAlpha"] = static_cast(structured->colorWriteAlpha); + jStateBitsEntry["polymodeLine"] = static_cast(structured->polymodeLine); + jStateBitsEntry["depthWrite"] = static_cast(structured->depthWrite); + + assert(structured->depthTestDisabled || structured->depthTest == GFXS_DEPTHTEST_ALWAYS || structured->depthTest == GFXS_DEPTHTEST_LESS + || structured->depthTest == GFXS_DEPTHTEST_EQUAL || structured->depthTest == GFXS_DEPTHTEST_LESSEQUAL); + if (structured->depthTestDisabled) + jStateBitsEntry["depthTest"] = "disabled"; + else if (structured->depthTest == GFXS_DEPTHTEST_ALWAYS) + jStateBitsEntry["depthTest"] = "always"; + else if (structured->depthTest == GFXS_DEPTHTEST_LESS) + jStateBitsEntry["depthTest"] = "less"; + else if (structured->depthTest == GFXS_DEPTHTEST_EQUAL) + jStateBitsEntry["depthTest"] = "equal"; + else if (structured->depthTest == GFXS_DEPTHTEST_LESSEQUAL) + jStateBitsEntry["depthTest"] = "lessequal"; + + JsonEnumEntry( + jStateBitsEntry, "polygonOffset", std::min(structured->polygonOffset, std::extent_v - 1u), polygonOffsetNames); + + if (structured->stencilFrontEnabled) + { + json jStencilFront; + StencilToJson( + jStencilFront, structured->stencilFrontPass, structured->stencilFrontFail, structured->stencilFrontZFail, structured->stencilFrontFunc); + jStateBitsEntry["stencilFront"] = std::move(jStencilFront); + } + else + jStateBitsEntry["stencilFront"] = json(); + + if (structured->stencilBackEnabled) + { + json jStencilBack; + StencilToJson( + jStencilBack, structured->stencilBackPass, structured->stencilBackFail, structured->stencilBackZFail, structured->stencilBackFunc); + jStateBitsEntry["stencilBack"] = std::move(jStencilBack); + } + else + jStateBitsEntry["stencilBack"] = json(); + } + + static void StencilToJson(json& jStencil, const unsigned pass, const unsigned fail, const unsigned zFail, const unsigned func) + { + JsonEnumEntry(jStencil, "pass", std::min(pass, std::extent_v - 1u), stencilOpNames); + JsonEnumEntry(jStencil, "fail", std::min(fail, std::extent_v - 1u), stencilOpNames); + JsonEnumEntry(jStencil, "zfail", std::min(zFail, std::extent_v - 1u), stencilOpNames); + JsonEnumEntry(jStencil, "func", std::min(func, std::extent_v - 1u), stencilFuncNames); + } + + static void ThermalMaterialToJson(json& jRoot, const Material* thermalMaterial) + { + if (thermalMaterial && thermalMaterial->info.name) + jRoot["thermalMaterial"] = AssetName(thermalMaterial->info.name); + else + jRoot["thermalMaterial"] = nullptr; + } + + static const char* AssetName(const char* input) + { + if (input && input[0] == ',') + return &input[1]; + + return input; + } + + std::ostream& m_stream; + }; +} // namespace T6::material + +std::string AssetDumperMaterial::GetFileNameForAsset(const std::string& assetName) +{ + std::string sanitizedFileName(assetName); + if (sanitizedFileName[0] == '*') + { + std::replace(sanitizedFileName.begin(), sanitizedFileName.end(), '*', '_'); + const auto parenthesisPos = sanitizedFileName.find('('); + if (parenthesisPos != std::string::npos) + sanitizedFileName.erase(parenthesisPos); + sanitizedFileName = "generated/" + sanitizedFileName; + } + + std::ostringstream ss; + ss << "materials/" << sanitizedFileName << ".json"; + + return ss.str(); +} + +bool AssetDumperMaterial::ShouldDump(XAssetInfo* asset) +{ + return true; +} + +void AssetDumperMaterial::DumpAsset(AssetDumpingContext& context, XAssetInfo* asset) +{ + const auto assetFile = context.OpenAssetFile(GetFileNameForAsset(asset->m_name)); + + if (!assetFile) + return; + + const material::JsonDumper dumper(*assetFile); + dumper.Dump(asset->Asset()); +} diff --git a/src/ObjWriting/Game/T6/AssetDumpers/AssetDumperMaterial.h b/src/ObjWriting/Game/T6/AssetDumpers/AssetDumperMaterial.h new file mode 100644 index 00000000..087f97c2 --- /dev/null +++ b/src/ObjWriting/Game/T6/AssetDumpers/AssetDumperMaterial.h @@ -0,0 +1,18 @@ +#pragma once + +#include "Dumping/AbstractAssetDumper.h" +#include "Game/T6/T6.h" + +#include + +namespace T6 +{ + class AssetDumperMaterial final : public AbstractAssetDumper + { + static std::string GetFileNameForAsset(const std::string& assetName); + + protected: + bool ShouldDump(XAssetInfo* asset) override; + void DumpAsset(AssetDumpingContext& context, XAssetInfo* asset) override; + }; +} // namespace T6 diff --git a/src/ObjWriting/Game/T6/ZoneDumperT6.cpp b/src/ObjWriting/Game/T6/ZoneDumperT6.cpp index ffb4113f..e4ac10dd 100644 --- a/src/ObjWriting/Game/T6/ZoneDumperT6.cpp +++ b/src/ObjWriting/Game/T6/ZoneDumperT6.cpp @@ -3,6 +3,7 @@ #include "AssetDumpers/AssetDumperFontIcon.h" #include "AssetDumpers/AssetDumperGfxImage.h" #include "AssetDumpers/AssetDumperLocalizeEntry.h" +#include "AssetDumpers/AssetDumperMaterial.h" #include "AssetDumpers/AssetDumperPhysConstraints.h" #include "AssetDumpers/AssetDumperPhysPreset.h" #include "AssetDumpers/AssetDumperQdb.h" @@ -46,7 +47,7 @@ bool ZoneDumper::DumpZone(AssetDumpingContext& context) const // DUMP_ASSET_POOL(AssetDumperDestructibleDef, m_destructible_def, ASSET_TYPE_DESTRUCTIBLEDEF) // DUMP_ASSET_POOL(AssetDumperXAnimParts, m_xanim_parts, ASSET_TYPE_XANIMPARTS) DUMP_ASSET_POOL(AssetDumperXModel, m_xmodel, ASSET_TYPE_XMODEL) - // DUMP_ASSET_POOL(AssetDumperMaterial, m_material, ASSET_TYPE_MATERIAL) + DUMP_ASSET_POOL(AssetDumperMaterial, m_material, ASSET_TYPE_MATERIAL) // DUMP_ASSET_POOL(AssetDumperTechniqueSet, m_technique_set, ASSET_TYPE_TECHNIQUE_SET) DUMP_ASSET_POOL(AssetDumperGfxImage, m_image, ASSET_TYPE_IMAGE) DUMP_ASSET_POOL(AssetDumperSndBank, m_sound_bank, ASSET_TYPE_SOUND)