zone/OpenAssetTools
zone/OpenAssetTools
2
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2025-04-20 00:02:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #122 from Laupetin/feature/simple-materials

Browse Source 
feat: dump t6 materials as json
This commit is contained in:
Jan 2024-02-18 23:00:47 +01:00 committed by GitHub
commit 7b8cd890ad
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
11 changed files with 1294 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/Common/Game/IW3/IW3_Assets.h
View File

@ -763,6 +763,24 @@ namespace IW3
SURF_TYPE_NUM 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 struct MaterialInfo
{ {
const char* name; const char* name;

2
src/Common/Game/IW4/IW4_Assets.h
View File

@ -931,7 +931,7 @@ namespace IW4
}; };
// Names unknown // 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 enum MaterialGameFlags
{ {
MTL_GAMEFLAG_1 = 0x1, MTL_GAMEFLAG_1 = 0x1,

10
src/Common/Game/T6/CommonT6.cpp
View File

@ -58,16 +58,6 @@ int Common::Com_HashString(const char* str, const int len)
return result; 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) PackedTexCoords Common::Vec2PackTexCoords(const vec2_t* in)
{ {
return PackedTexCoords{Pack32::Vec2PackTexCoords(in->v)}; return PackedTexCoords{Pack32::Vec2PackTexCoords(in->v)};

11
src/Common/Game/T6/CommonT6.h
View File

@ -10,7 +10,16 @@ namespace T6
static int Com_HashKey(const char* str, int maxLen); static int Com_HashKey(const char* str, int maxLen);
static int Com_HashString(const char* str); static int Com_HashString(const char* str);
static int Com_HashString(const char* str, int len); 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) static constexpr uint32_t SND_HashName(const char* str)
{ {

762
src/Common/Game/T6/T6_Assets.h
View File

@ -647,20 +647,77 @@ namespace T6
gcc_align(8) uint64_t packed; 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 struct type_align(8) MaterialInfo
{ {
const char* name; const char* name;
unsigned int gameFlags; unsigned int gameFlags;
char pad; char pad;
char sortKey; unsigned char sortKey;
char textureAtlasRowCount; unsigned char textureAtlasRowCount;
char textureAtlasColumnCount; unsigned char textureAtlasColumnCount;
GfxDrawSurf drawSurf; GfxDrawSurf drawSurf;
unsigned int surfaceTypeBits; unsigned int surfaceTypeBits;
unsigned int layeredSurfaceTypes; unsigned int layeredSurfaceTypes;
uint16_t hashIndex; uint16_t hashIndex;
int surfaceFlags; unsigned int surfaceFlags;
int contents; 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; typedef tdef_align(8) GfxStateBits GfxStateBitsTable;
@ -672,9 +729,9 @@ namespace T6
unsigned char textureCount; unsigned char textureCount;
unsigned char constantCount; unsigned char constantCount;
unsigned char stateBitsCount; unsigned char stateBitsCount;
char stateFlags; unsigned char stateFlags;
char cameraRegion; unsigned char cameraRegion;
char probeMipBits; unsigned char probeMipBits;
MaterialTechniqueSet* techniqueSet; MaterialTechniqueSet* techniqueSet;
MaterialTextureDef* textureTable; MaterialTextureDef* textureTable;
MaterialConstantDef* constantTable; MaterialConstantDef* constantTable;
@ -718,6 +775,54 @@ namespace T6
MaterialVertexShaderProgram prog; 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 struct MaterialTechniqueSet
{ {
const char* name; const char* name;
@ -789,6 +894,8 @@ namespace T6
TS_COLOR14_MAP = 0x1A, TS_COLOR14_MAP = 0x1A,
TS_COLOR15_MAP = 0x1B, TS_COLOR15_MAP = 0x1B,
TS_THROW_MAP = 0x1C, TS_THROW_MAP = 0x1C,
TS_COUNT,
}; };
enum ImageCategory enum ImageCategory
@ -2655,14 +2762,89 @@ namespace T6
PhysGeomList* geomList; 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 struct MaterialTextureDef
{ {
unsigned int nameHash; unsigned int nameHash;
char nameStart; char nameStart;
char nameEnd; char nameEnd;
char samplerState; MaterialTextureDefSamplerState samplerState;
char semantic; unsigned char semantic; // TextureSemantic
char isMatureContent; bool isMatureContent;
char pad[3]; char pad[3];
GfxImage* image; GfxImage* image;
}; };
@ -2674,93 +2856,150 @@ namespace T6
vec4_t literal; vec4_t literal;
}; };
enum GfxStateBitsEnum : unsigned int enum GfxBlend
{ {
GFXS0_SRCBLEND_RGB_SHIFT = 0x0, GFXS_BLEND_DISABLED = 0x0,
GFXS0_SRCBLEND_RGB_MASK = 0xF, GFXS_BLEND_ZERO = 0x1,
GFXS0_DSTBLEND_RGB_SHIFT = 0x4, GFXS_BLEND_ONE = 0x2,
GFXS0_DSTBLEND_RGB_MASK = 0xF0, GFXS_BLEND_SRCCOLOR = 0x3,
GFXS0_BLENDOP_RGB_SHIFT = 0x8, GFXS_BLEND_INVSRCCOLOR = 0x4,
GFXS0_BLENDOP_RGB_MASK = 0x700, GFXS_BLEND_SRCALPHA = 0x5,
GFXS0_BLEND_RGB_MASK = 0x7FF, GFXS_BLEND_INVSRCALPHA = 0x6,
GFXS0_ATEST_SHIFT = 0xB, GFXS_BLEND_DESTALPHA = 0x7,
GFXS0_ATEST_DISABLE = 0x800, GFXS_BLEND_INVDESTALPHA = 0x8,
GFXS0_ATEST_GT_0 = 0x0, GFXS_BLEND_DESTCOLOR = 0x9,
GFXS0_ATEST_GE_128 = 0x1000, GFXS_BLEND_INVDESTCOLOR = 0xA,
GFXS0_ATEST_MASK = 0x1000,
GFXS0_CULL_SHIFT = 0xE, GFXS_BLEND_COUNT
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,
}; };
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 struct GfxStateBits
{ {
unsigned int loadBits[2]; GfxStateBitsLoadBits loadBits;
void /*ID3D11BlendState*/* blendState; void /*ID3D11BlendState*/* blendState;
void /*ID3D11DepthStencilState*/* depthStencilState; void /*ID3D11DepthStencilState*/* depthStencilState;
void /*ID3D11RasterizerState*/* rasterizerState; void /*ID3D11RasterizerState*/* rasterizerState;
}; };
/* struct IUnknown
{
IUnknownVtbl *vfptr;
};*/
/* struct __cppobj ID3D11DeviceChild : IUnknown
{
};*/
/* struct __cppobj ID3D11PixelShader : ID3D11DeviceChild
{
};*/
/* struct __cppobj ID3D11VertexShader : ID3D11DeviceChild
{
};*/
struct MaterialPass struct MaterialPass
{ {
MaterialVertexDeclaration* vertexDecl; MaterialVertexDeclaration* vertexDecl;
@ -5489,24 +5728,50 @@ namespace T6
int contents; 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 STREAM_DST_COUNT,
{ };
HRESULT (__stdcall *QueryInterface)(IUnknown *this, _GUID *, void **);
unsigned int (__stdcall *AddRef)(IUnknown *this);
unsigned int (__stdcall *Release)(IUnknown *this);
};*/
struct MaterialStreamRouting 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 struct MaterialArgumentCodeConst
{ {
uint16_t index; uint16_t index;

2
src/ObjCommon/Game/IW4/TechsetConstantsIW4.h
View File

@ -77,6 +77,7 @@ namespace IW4
"texcoord[7]", "texcoord[7]",
}; };
static_assert(std::extent_v<decltype(materialStreamDestinationNames)> == STREAM_DST_COUNT); static_assert(std::extent_v<decltype(materialStreamDestinationNames)> == STREAM_DST_COUNT);
static const char* materialStreamDestinationAbbreviation[]{ static const char* materialStreamDestinationAbbreviation[]{
"p", "p",
"n", "n",
@ -106,6 +107,7 @@ namespace IW4
"normalTransform[1]", "normalTransform[1]",
}; };
static_assert(std::extent_v<decltype(materialStreamSourceNames)> == STREAM_SRC_COUNT); static_assert(std::extent_v<decltype(materialStreamSourceNames)> == STREAM_SRC_COUNT);
static const char* materialStreamSourceAbbreviation[]{ static const char* materialStreamSourceAbbreviation[]{
"p", "p",
"c", "c",

119
src/ObjCommon/Game/T6/MaterialConstantsT6.h Normal file
View File

@ -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<decltype(textureSemanticNames)> == TS_COUNT);
inline const char* cameraRegionNames[]{
"litOpaque",
"litTrans",
"litQuasiOpaque",
"emissiveOpaque",
"emissiveTrans",
"emissiveFx",
"lightMapOpaque",
"depthHack",
"unused",
"sonar",
"none",
};
static_assert(std::extent_v<decltype(cameraRegionNames)> == CAMERA_REGION_NONE + 1);
static const char* textureFilterNames[]{
"disabled",
"nearest",
"linear",
"aniso2x",
"aniso4x",
"compare",
};
static_assert(std::extent_v<decltype(textureFilterNames)> == TEXTURE_FILTER_COUNT);
static const char* samplerStateMipMapNames[]{
"disabled",
"nearest",
"linear",
};
static_assert(std::extent_v<decltype(samplerStateMipMapNames)> == 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<decltype(blendNames)> == GFXS_BLEND_COUNT);
inline const char* blendOpNames[]{
"disabled",
"add",
"subtract",
"revsubtract",
"min",
"max",
};
static_assert(std::extent_v<decltype(blendOpNames)> == GFXS_BLENDOP_COUNT);
inline const char* polygonOffsetNames[]{
"offset0",
"offset1",
"offset2",
"offsetShadowmap",
};
static_assert(std::extent_v<decltype(polygonOffsetNames)> == GFXS_POLYGON_OFFSET_COUNT);
inline const char* stencilOpNames[]{
"keep",
"zero",
"replace",
"incrsat",
"decrsat",
"invert",
"incr",
"decr",
};
static_assert(std::extent_v<decltype(stencilOpNames)> == GFXS_STENCILOP_COUNT);
inline const char* stencilFuncNames[]{
"never",
"less",
"equal",
"lessequal",
"greater",
"notequal",
"greaterequal",
"always",
};
static_assert(std::extent_v<decltype(stencilFuncNames)> == GFXS_STENCILFUNC_COUNT);
} // namespace T6

101
src/ObjCommon/Game/T6/TechsetConstantsT6.h Normal file
View File

@ -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<decltype(techniqueTypeNames)> == 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<decltype(materialStreamDestinationNames)> == 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<decltype(materialStreamDestinationAbbreviation)> == 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<decltype(materialStreamSourceNames)> == STREAM_SRC_COUNT);
static const char* materialStreamSourceAbbreviation[]{
"p",
"c",
"t0",
"n",
"t",
"t1",
"t2",
"t3",
"n0",
"n1",
"b",
};
static_assert(std::extent_v<decltype(materialStreamSourceAbbreviation)> == STREAM_SRC_COUNT);
inline MaterialTypeInfo g_materialTypeInfo[]{
{"", "" },
{"m/", "m_" },
{"mc/", "mc_"},
{"?", "?" },
{"wc/", "wc_"},
{"?", "?" },
{"?", "?" },
{"?", "?" },
}; // TODO: Fill this
static_assert(std::extent_v<decltype(g_materialTypeInfo)> == MTL_TYPE_COUNT);
} // namespace T6

362
src/ObjWriting/Game/T6/AssetDumpers/AssetDumperMaterial.cpp Normal file
View File

@ -0,0 +1,362 @@
#include "AssetDumperMaterial.h"
#include "Game/T6/CommonT6.h"
#include "Game/T6/MaterialConstantsT6.h"
#include "Game/T6/TechsetConstantsT6.h"
#include <cassert>
#include <nlohmann/json.hpp>
#include <sstream>
using namespace T6;
using namespace nlohmann;
namespace T6::material
{
#define KNOWN_HASH(strValue) \
{ \
Common::R_HashString(strValue, 0), strValue \
}
std::unordered_map<unsigned, std::string> 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<size_t SIZE> 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<decltype(gameFlagNames)>)
{
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<int>(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<decltype(MaterialConstantDef::name)>);
const std::string nameFragment(textureDef->name, fragmentLength);
if (fragmentLength < std::extent_v<decltype(MaterialConstantDef::name)> || 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<decltype(blendNames)> - 1u), blendNames);
JsonEnumEntry(jStateBitsEntry, "dstBlendRgb", std::min(structured->dstBlendRgb, std::extent_v<decltype(blendNames)> - 1u), blendNames);
JsonEnumEntry(jStateBitsEntry, "blendOpRgb", std::min(structured->blendOpRgb, std::extent_v<decltype(blendOpNames)> - 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<decltype(blendNames)> - 1u), blendNames);
JsonEnumEntry(jStateBitsEntry, "dstBlendRgb", std::min(structured->dstBlendAlpha, std::extent_v<decltype(blendNames)> - 1u), blendNames);
JsonEnumEntry(jStateBitsEntry, "blendOpRgb", std::min(structured->blendOpAlpha, std::extent_v<decltype(blendOpNames)> - 1u), blendOpNames);
jStateBitsEntry["colorWriteRgb"] = static_cast<bool>(structured->colorWriteRgb);
jStateBitsEntry["colorWriteAlpha"] = static_cast<bool>(structured->colorWriteAlpha);
jStateBitsEntry["polymodeLine"] = static_cast<bool>(structured->polymodeLine);
jStateBitsEntry["depthWrite"] = static_cast<bool>(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<decltype(polygonOffsetNames)> - 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<decltype(stencilOpNames)> - 1u), stencilOpNames);
JsonEnumEntry(jStencil, "fail", std::min(fail, std::extent_v<decltype(stencilOpNames)> - 1u), stencilOpNames);
JsonEnumEntry(jStencil, "zfail", std::min(zFail, std::extent_v<decltype(stencilOpNames)> - 1u), stencilOpNames);
JsonEnumEntry(jStencil, "func", std::min(func, std::extent_v<decltype(stencilFuncNames)> - 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<Material>* asset)
{
return true;
}
void AssetDumperMaterial::DumpAsset(AssetDumpingContext& context, XAssetInfo<Material>* asset)
{
const auto assetFile = context.OpenAssetFile(GetFileNameForAsset(asset->m_name));
if (!assetFile)
return;
const material::JsonDumper dumper(*assetFile);
dumper.Dump(asset->Asset());
}

18
src/ObjWriting/Game/T6/AssetDumpers/AssetDumperMaterial.h Normal file
View File

@ -0,0 +1,18 @@
#pragma once
#include "Dumping/AbstractAssetDumper.h"
#include "Game/T6/T6.h"
#include <string>
namespace T6
{
class AssetDumperMaterial final : public AbstractAssetDumper<Material>
{
static std::string GetFileNameForAsset(const std::string& assetName);
protected:
bool ShouldDump(XAssetInfo<Material>* asset) override;
void DumpAsset(AssetDumpingContext& context, XAssetInfo<Material>* asset) override;
};
} // namespace T6

3
src/ObjWriting/Game/T6/ZoneDumperT6.cpp
View File

@ -3,6 +3,7 @@
#include "AssetDumpers/AssetDumperFontIcon.h" #include "AssetDumpers/AssetDumperFontIcon.h"
#include "AssetDumpers/AssetDumperGfxImage.h" #include "AssetDumpers/AssetDumperGfxImage.h"
#include "AssetDumpers/AssetDumperLocalizeEntry.h" #include "AssetDumpers/AssetDumperLocalizeEntry.h"
#include "AssetDumpers/AssetDumperMaterial.h"
#include "AssetDumpers/AssetDumperPhysConstraints.h" #include "AssetDumpers/AssetDumperPhysConstraints.h"
#include "AssetDumpers/AssetDumperPhysPreset.h" #include "AssetDumpers/AssetDumperPhysPreset.h"
#include "AssetDumpers/AssetDumperQdb.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(AssetDumperDestructibleDef, m_destructible_def, ASSET_TYPE_DESTRUCTIBLEDEF)
// DUMP_ASSET_POOL(AssetDumperXAnimParts, m_xanim_parts, ASSET_TYPE_XANIMPARTS) // DUMP_ASSET_POOL(AssetDumperXAnimParts, m_xanim_parts, ASSET_TYPE_XANIMPARTS)
DUMP_ASSET_POOL(AssetDumperXModel, m_xmodel, ASSET_TYPE_XMODEL) 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(AssetDumperTechniqueSet, m_technique_set, ASSET_TYPE_TECHNIQUE_SET)
DUMP_ASSET_POOL(AssetDumperGfxImage, m_image, ASSET_TYPE_IMAGE) DUMP_ASSET_POOL(AssetDumperGfxImage, m_image, ASSET_TYPE_IMAGE)
DUMP_ASSET_POOL(AssetDumperSndBank, m_sound_bank, ASSET_TYPE_SOUND) DUMP_ASSET_POOL(AssetDumperSndBank, m_sound_bank, ASSET_TYPE_SOUND)