COD Engine Research - User contributions [en]

Category:LoadContext

2026-07-11T14:38:05Z

Jakes625: /* XAssetEntry */

= Load Context =

The relationship is:
<syntaxhighlight>
Global DB state
├── Zone registry
│ ├── patch_mp -> its own XZoneMemory
│ ├── common_mp -> its own XZoneMemory
│ ├── ui_mp -> its own XZoneMemory
│ ├── mp_boneyard_load -> its own XZoneMemory
│ └── mp_boneyard -> its own XZoneMemory
├── Current stream state
│ └── points at one zone's XZoneMemory while that zone is loading
└── Global XAsset registry
└── shared by assets from every loaded zone
</syntaxhighlight>

* XZoneMemory is per zone.
* Dependencies do not combine their blocks into one XZoneMemory.
* The global XAsset registry spans all loaded zones.
* Each XAssetEntry records its owning zoneIndex.
* Asset overrides and deduplication happen through the shared registry.
* Unloading a zone frees that zone’s XZoneMemory and removes or reveals its registry entries as appropriate.

Conceptually:
<syntaxhighlight lang="C">
void DB_LoadZone(XZone *zone, DBFile *file)
{
DB_AllocXZoneMemory(file->blockSizes, &zone->memory);
DB_InitStreams(&zone->memory);

// The global stream state now points into this zone's seven blocks.
DB_LoadXFile(&zone->memory, file);

// Loaded assets are registered into the shared global XAsset registry.
DB_PostLoadXZone(zone);
}
</syntaxhighlight>

== XZone ==
The encompassing live zone record appears shaped like:
<syntaxhighlight lang="C">
// PROVEN: PS3 DB_LoadXAssets and its callers use these five numeric bits as
// zone allocation/free categories. CORRELATED: Xbox IW4 symbols provide the
// DB_ZONE_* member names for those bits.
enum XZoneFlags : int
{
None = 0,
DB_ZONE_COMMON = 0x01,
DB_ZONE_UI = 0x02,
DB_ZONE_GAME = 0x04,
DB_ZONE_LOAD = 0x08,
DB_ZONE_DEV = 0x10
}

typedef struct XZone
{
uint32_t zoneId; // 0x00
uint32_t unknown04; // 0x04
char name[64]; // 0x08
uint32_t unknown48; // 0x48
XZoneFlags zoneFlags; // 0x4C
uint32_t unknown50; // 0x50
XZoneMemory memory; // 0x54
} XZone;
</syntaxhighlight>

=== XZoneInfo ===
PS3 function 0x0011B968, corresponding to DB_LoadXAssets, independently proves the field behavior:
* It iterates XZoneInfo using a 0x0C stride.
* +0x08 is intersected with each loaded XZone flag word at +0x4C.
* Every zone where (freeFlags & zoneFlags) != 0 is selected for unloading.
* +0x04 is copied into the internal queued request at +0x40 and becomes the loaded zone’s category/lifetime flags.
* Freeing happens before new named records from the same batch are queued.

{| class="wikitable"
! Value
! Meaning
! PS3 usage
|-
| <code>0x01</code>
| <code>COMMON</code>
| <code>code_post_gfx_mp</code>, <code>patch_mp</code>, <code>common_mp</code>
|-
| <code>0x02</code>
| <code>UI</code>
| <code>ui_mp</code>, DLC UI zones
|-
| <code>0x04</code>
| <code>GAME</code>
| Main map/game zone path
|-
| <code>0x08</code>
| <code>LOAD</code>
| <code><map>_load</code> path
|-
| <code>0x10</code>
| <code>DEV</code>
| Appears in free masks, but no standalone PS3 allocation observed yet
|}

Common combined masks include:
* 0x06 = UI | GAME
* 0x18 = LOAD | DEV
* 0x1E = every category except COMMON
The Xbox builds also contain the assertion !(freeFlags & DB_ZONE_COMMON). That prohibition is Xbox-proven and strongly PS3-correlated.
patch_mp and common_mp have 0x01, while ui_mp has 0x02.

<syntaxhighlight lang="C">
typedef struct XZoneInfo
{
char* Name,
XZoneFlags AllocFlags,
XZoneFlags FreeFlags
} XZoneInfo; // 0x0C
</syntaxhighlight>

== XZoneMemory ==
XZoneMemory is the memory-block allocation for one loaded zone/fastfile. It is only one component of the engine’s broader database loading state.

<syntaxhighlight lang="C">
typedef enum XFileBlockType
{
XFILE_BLOCK_TEMP = 0,
XFILE_BLOCK_PHYSICAL = 1,
XFILE_BLOCK_RUNTIME = 2,
XFILE_BLOCK_VIRTUAL = 3,
XFILE_BLOCK_LARGE = 4,
XFILE_BLOCK_CALLBACK = 5,
XFILE_BLOCK_VERTEX = 6,

XFILE_BLOCK_COUNT = 7
} XFileBlockType;

typedef struct XZoneMemoryBlock
{
void* address; // Live address; null when size is zero
uint32_t size; // Declared allocation size
} XZoneMemoryBlock;

typedef struct XZoneMemory
{
XZoneMemoryBlock blocks[XFILE_BLOCK_COUNT];
} XZoneMemory;
</syntaxhighlight>

== XAssetEntry ==
The engines load context keeps a record of semantic asset names to it's place in memory. The engine more or less does this:
<syntaxhighlight lang="C">
typedef struct XAssetEntry
{
uint32_t assetType; // 0x00: XAssetType
XAsset* headerPointer; // 0x04: canonical asset-header pointer

uint8_t zoneIndex; // 0x08: owning zone-record index
uint8_t flags09; // 0x09: bit 0 is tested by registry logic
uint8_t state0A; // 0x0A: initialized to zero; meaning OPEN
uint8_t pad0B; // 0x0B: no semantics proven

uint16_t nextHashIndex; // 0x0C: next entry in the name-hash chain
uint16_t nextOverrideIndex; // 0x0E: override/replacement chain
} XAssetEntry;
</syntaxhighlight>

Category:LoadContext

2026-07-11T14:35:11Z

Jakes625: /* XZone */

= Load Context =

The relationship is:
<syntaxhighlight>
Global DB state
├── Zone registry
│ ├── patch_mp -> its own XZoneMemory
│ ├── common_mp -> its own XZoneMemory
│ ├── ui_mp -> its own XZoneMemory
│ ├── mp_boneyard_load -> its own XZoneMemory
│ └── mp_boneyard -> its own XZoneMemory
├── Current stream state
│ └── points at one zone's XZoneMemory while that zone is loading
└── Global XAsset registry
└── shared by assets from every loaded zone
</syntaxhighlight>

* XZoneMemory is per zone.
* Dependencies do not combine their blocks into one XZoneMemory.
* The global XAsset registry spans all loaded zones.
* Each XAssetEntry records its owning zoneIndex.
* Asset overrides and deduplication happen through the shared registry.
* Unloading a zone frees that zone’s XZoneMemory and removes or reveals its registry entries as appropriate.

Conceptually:
<syntaxhighlight lang="C">
void DB_LoadZone(XZone *zone, DBFile *file)
{
DB_AllocXZoneMemory(file->blockSizes, &zone->memory);
DB_InitStreams(&zone->memory);

// The global stream state now points into this zone's seven blocks.
DB_LoadXFile(&zone->memory, file);

// Loaded assets are registered into the shared global XAsset registry.
DB_PostLoadXZone(zone);
}
</syntaxhighlight>

== XZone ==
The encompassing live zone record appears shaped like:
<syntaxhighlight lang="C">
// PROVEN: PS3 DB_LoadXAssets and its callers use these five numeric bits as
// zone allocation/free categories. CORRELATED: Xbox IW4 symbols provide the
// DB_ZONE_* member names for those bits.
enum XZoneFlags : int
{
None = 0,
DB_ZONE_COMMON = 0x01,
DB_ZONE_UI = 0x02,
DB_ZONE_GAME = 0x04,
DB_ZONE_LOAD = 0x08,
DB_ZONE_DEV = 0x10
}

typedef struct XZone
{
uint32_t zoneId; // 0x00
uint32_t unknown04; // 0x04
char name[64]; // 0x08
uint32_t unknown48; // 0x48
XZoneFlags zoneFlags; // 0x4C
uint32_t unknown50; // 0x50
XZoneMemory memory; // 0x54
} XZone;
</syntaxhighlight>

=== XZoneInfo ===
PS3 function 0x0011B968, corresponding to DB_LoadXAssets, independently proves the field behavior:
* It iterates XZoneInfo using a 0x0C stride.
* +0x08 is intersected with each loaded XZone flag word at +0x4C.
* Every zone where (freeFlags & zoneFlags) != 0 is selected for unloading.
* +0x04 is copied into the internal queued request at +0x40 and becomes the loaded zone’s category/lifetime flags.
* Freeing happens before new named records from the same batch are queued.

{| class="wikitable"
! Value
! Meaning
! PS3 usage
|-
| <code>0x01</code>
| <code>COMMON</code>
| <code>code_post_gfx_mp</code>, <code>patch_mp</code>, <code>common_mp</code>
|-
| <code>0x02</code>
| <code>UI</code>
| <code>ui_mp</code>, DLC UI zones
|-
| <code>0x04</code>
| <code>GAME</code>
| Main map/game zone path
|-
| <code>0x08</code>
| <code>LOAD</code>
| <code><map>_load</code> path
|-
| <code>0x10</code>
| <code>DEV</code>
| Appears in free masks, but no standalone PS3 allocation observed yet
|}

Common combined masks include:
* 0x06 = UI | GAME
* 0x18 = LOAD | DEV
* 0x1E = every category except COMMON
The Xbox builds also contain the assertion !(freeFlags & DB_ZONE_COMMON). That prohibition is Xbox-proven and strongly PS3-correlated.
patch_mp and common_mp have 0x01, while ui_mp has 0x02.

<syntaxhighlight lang="C">
typedef struct XZoneInfo
{
char* Name,
XZoneFlags AllocFlags,
XZoneFlags FreeFlags
} XZoneInfo; // 0x0C
</syntaxhighlight>

== XZoneMemory ==
XZoneMemory is the memory-block allocation for one loaded zone/fastfile. It is only one component of the engine’s broader database loading state.

<syntaxhighlight lang="C">
typedef enum XFileBlockType
{
XFILE_BLOCK_TEMP = 0,
XFILE_BLOCK_PHYSICAL = 1,
XFILE_BLOCK_RUNTIME = 2,
XFILE_BLOCK_VIRTUAL = 3,
XFILE_BLOCK_LARGE = 4,
XFILE_BLOCK_CALLBACK = 5,
XFILE_BLOCK_VERTEX = 6,

XFILE_BLOCK_COUNT = 7
} XFileBlockType;

typedef struct XZoneMemoryBlock
{
void* address; // Live address; null when size is zero
uint32_t size; // Declared allocation size
} XZoneMemoryBlock;

typedef struct XZoneMemory
{
XZoneMemoryBlock blocks[XFILE_BLOCK_COUNT];
} XZoneMemory;
</syntaxhighlight>

== XAssetEntry ==
The engines load context keeps a record of semantic asset names to it's place in memory. The engine more or less does this:
<syntaxhighlight lang="C">
typedef struct XAssetEntry
{
uint32_t assetType; // 0x00: XAssetType
uint32_t headerPointer; // 0x04: canonical asset-header pointer

uint8_t zoneIndex; // 0x08: owning zone-record index
uint8_t flags09; // 0x09: bit 0 is tested by registry logic
uint8_t state0A; // 0x0A: initialized to zero; meaning OPEN
uint8_t pad0B; // 0x0B: no semantics proven

uint16_t nextHashIndex; // 0x0C: next entry in the name-hash chain
uint16_t nextOverrideIndex; // 0x0E: override/replacement chain
} XAssetEntry;
</syntaxhighlight>

2026-07-05T18:34:30Z

Jakes625: /* Playstation 3 */

Pixel Shader Asset

2026-07-05T18:27:11Z

Jakes625: /* Structures */

__NOTOC__
[[Category:Assets]]
[[Category:CoD4]]
[[Category:WaW]]
[[Category:MW2]]
[[Category:BO1]]
[[Category:MW3]]
[[Category:BO2]]
[[Category:Ghosts]]
== Modern Warfare 3 & Ghosts ==
<source lang="cpp">
struct MaterialPixelShaderProgram
{
CgBinaryProgram *ps; // size = size
int size;
const char *data; // size = size2
int size2;
int unknown[2];
};

struct MaterialPixelShader
{
const char *name;
MaterialPixelShaderProgram prog;
};
</source>

== Call of Duty 4 & World at War & Modern Warfare 2 ==

=== Rendering ===
[[MW2_Rendering|Rendering]]

=== Structures ===
<source lang="cpp">
struct GfxPixelShaderLoadDef
{
CgBinaryProgram *ps; // serialized Cg/NV fragment program blob
int size; // byte size of ps payload
};

struct MaterialPixelShaderProgram
{
union
{
// Fastfile/source view, consumed by Load_GfxPixelShaderLoadDef.
struct
{
CgBinaryProgram *ps; // +0x00
int size; // +0x04
char runtime[0x0C]; // +0x08, overwritten/filled by runtime build, size 8 ifndef mw2
} load;

// Runtime view after EBOOT.elf:00361f38 builds the PS3 fragment program data.
struct
{
unsigned short *patchTable; // +0x00
int commandListOffset; // +0x04, offset to copied RSX command dwords
int commandDwordCount; // +0x08
unsigned short patchTableWords; // +0x0C
unsigned short uploadByteSize; // +0x0E
void *sharedUpload; // +0x10, default fragment upload image
} runtime;
};
};

struct MaterialPixelShader
{
const char *name; // +0x00, XString
MaterialPixelShaderProgram prog; // +0x04, total asset size 0x18
};
</source>

MaterialPixelShader is 0x18 bytes on PS3. EBOOT.elf:0x00107578 loads the name, then loads prog at +0x04. MaterialPixelShaderProgram itself is 0x14 bytes; EBOOT.elf:0x000fb128 copies those bytes, aliases the first 8 bytes as GfxPixelShaderLoadDef, and calls the pixel program loader.

ps is not the final RSX-bound shader address. It is the serialized Cg/NV fragment-program blob pointer. When inline, the loader consumes size bytes for that blob, then 0x004c7428 -> 0x00361f38 parses/builds runtime data from it.

At draw time the upload image is still patched. Shader arg kinds 5, 6, and 7 provide code/material/literal pixel constants; 00396e48 uses the runtime patch table to write those float4 values into the upload image, then 004a7bd4 copies it to a draw cache and 003abd08 binds it through RSX method 0x408e4.

== Black Ops ==
<source lang="cpp">
struct MaterialPixelShaderProgram
{
char *data; // size = size << 2
char unknown[2];
unsigned __int16 size;
};

struct MaterialPixelShader
{
const char *name;
MaterialPixelShaderProgram prog;
};
</source>
== Black Ops 2 ==
<source lang="cpp">
struct MaterialPixelShaderProgram
{
char *data1; // if flag2 & 0x80: size = (size1 << 4) + 0x10
// else: size = 0
char *data2; // if flag2 & 0x80:
// if flag1 & 0x80: size = size1 + 0x11
// else: size = (size1 << 2) + 0x14
// else: size = 0x10
unsigned __int16 size1;
char flag1;
char flag2;
};

struct MaterialPixelShader
{
const char *name;
MaterialPixelShaderProgram prog;
};
</source>

2026-06-12T03:48:18Z

Jakes625: /* Stream Blocks */

FastFiles are the CoD engine's way of storing Zone files. FastFiles (FFs) almost always have some sort of RSA2048 signature, a zlib compression along the way, and then on later CoDs some encryption. The Zones are a library of [[:Category:Assets|assets]]. Every FF in every CoD game starts the same way...
{| class="wikitable"
|-
! Name !! Offset !! Type !! Description
|-
| Magic || 0x0 || char[8] || "IWffu100" for unsigned fastfiles, "IWff0100" for signed fastfiles, "TAff0100" for treyarch's Black Ops 2 fastfile, and "S1ff0100" for Sledgehammer Advanced Warfare fastfiles.
|-
| Version || 0x8 || int || See below.
|}
So by reading the version of the input FF, you can tell what system and game the FF is from. Note that pre-alpha versions of Call of Duty 4 are missing the version integer, and must be handled specially. Also keep in mind that the Quantum of Solace FFs are missing the magic in the struct above.

{| class="wikitable"
| XFILE_VERSION || '''007:QoS''' ||'''CoD4'''||'''WaW'''||'''MW2'''||'''BO1'''||'''MW3'''||'''BO2'''||'''Ghosts'''||'''CoD: Online'''||'''Advanced Warfare'''||'''BO3 Beta'''||'''BO3'''
|-
|Xbox 360||0x1D6||0x1||0x183||0x10D||0x1D9||0x70||0x92||0x22E||n/a||0x72E||n/a||0x253
|-
|Playstation 3||0x1D6||0x1||0x183||0x10D||0x1D9||0x70||0x92||0x22E||n/a||0x72E||n/a||0x25E
|-
|Wii/Wii-U||0x1D2||0x1A2||0x19B||n/a||0x1DD||0x6B||0x94||0x22E||n/a||n/a||n/a||n/a
|-
|PC||0x1D6||0x5||0x183||0x114||0x1D9||0x1||0x93||0x135||0x13C||0x72E||0x1FB||n/a
|}

== Stream Blocks ==
After the Zone (XFile) is extracted from the fastfile, you read the block sizes of each g_streamBlock allocation. This determines how much memory to allocate to each stream to read data into. Each block stream has a specific role in the data that is read and it goes as follows:

{| class="wikitable"
| ||'''Temp'''||'''Physical'''||'''Runtime'''||'''Virtual'''||'''Large'''||'''Callback'''||'''Vertex'''
|-
|Purpose||Asset Pool Headers, Counts, Root Pointers||Sound Data||??||PC uses this for loading assets||Strings and Data Chunks (rawfiles)||Used in some loader methods||Material and Image data
|}

One distinction is that PC uses virtual for a load of loading where PS3 mainly uses large.

Stream blocks exist within a stack, when a loader is using a block, it pops the requested block onto the stack, reads data into it, then when complete, pops that block off the stack, and returns to the previous block at the block stream cursor position.

=== flow ===
<pre>
START
|
v
+--------------------------------------------------+
| Init XBlockStream |
| ActiveBlock = TEMP |
| Stack = empty |
+--------------------------------------------------+
|
v
+--------------------------------------------------+
| Read header |
| Source cursor advances |
| Blocks are created from header block sizes |
+--------------------------------------------------+
|
v
+--------------------------------------------------+
| Read XAssetList root |
| ActiveBlock = TEMP |
| Reads: scriptStringCount, scriptStringsPtr, |
| assetCount, assetsPtr |
+--------------------------------------------------+
|
v
+--------------------------------------------------+
| Materialize ScriptStringsPtr |
| Payload block = LARGE |
+--------------------------------------------------+
|
v
+--------------------------------------------------+
| PUSH LARGE |
| Stack push: previous = TEMP |
| ActiveBlock = LARGE |
+--------------------------------------------------+
|
v
+--------------------------------------------------+
| Read script string pointer array |
| ActiveBlock = LARGE |
+--------------------------------------------------+
|
v
+--------------------------------------------------+
| For each script string pointer |
| |
| 0 -> null, no payload |
| -1 inline -> read CString at current LARGE pos |
| -2 insert -> reserve extra pointer cell in LARGE |
| patch original + inserted cells |
| read CString in LARGE |
| offset -> decode block+offset, resolve/defer |
+--------------------------------------------------+
|
v
+--------------------------------------------------+
| POP LARGE |
| ActiveBlock returns to TEMP |
+--------------------------------------------------+
|
v
+--------------------------------------------------+
| Materialize AssetsPtr |
| Payload block = LARGE |
+--------------------------------------------------+
|
v
+--------------------------------------------------+
| PUSH LARGE |
| Stack push: previous = TEMP |
| ActiveBlock = LARGE |
+--------------------------------------------------+
|
v
+--------------------------------------------------+
| Phase 1: read XAsset table |
| ActiveBlock = LARGE |
| Each row: asset type + asset pointer |
+--------------------------------------------------+
|
v
+--------------------------------------------------+
| Phase 2: for each asset row |
| Materialize asset root pointer |
| Root payload block = TEMP |
+--------------------------------------------------+
|
v
+--------------------------------------------------+
| Asset root pointer kind |
| |
| 0 -> asset value = null |
| -1 inline -> PUSH TEMP, read asset payload |
| -2 insert -> reserve pointer cell in LARGE |
| patch original + inserted cells |
| PUSH TEMP, read asset payload |
| offset -> decode block+offset |
| PUSH decoded block, read payload |
+--------------------------------------------------+
|
v
+--------------------------------------------------+
| Read asset object fields |
| Nested pointers may push TEMP, LARGE, VIRTUAL, |
| or another decoded/allocated block |
+--------------------------------------------------+
|
v
+--------------------------------------------------+
| POP nested block(s) |
| POP asset payload block |
| Continue next asset |
+--------------------------------------------------+
|
v
+--------------------------------------------------+
| After all assets |
| POP LARGE |
| ActiveBlock returns to TEMP |
+--------------------------------------------------+
|
v
+--------------------------------------------------+
| Resolve deferred CString pointers |
| Validate source cursor |
| Seal/pad emitted blocks |
+--------------------------------------------------+
END
</pre>

Pop behavior:
<pre>
POP behavior:

If popping from TEMP:
restore TEMP cursor to the position saved when TEMP was pushed

If popping from any other block:
keep that block's advanced cursor

Always:
ActiveBlock = previous block from the stack frame

Important:
Source _position is not rewound by POP.
The stack only controls emitted block cursors.
</pre>

== Pointers in Zone Files ==
Pointers can be classified as one of the following:
* <code> 0 </code>: null, no data follows
* <code> -1 </code>: inline, data follows after the struct, usually in order but '''NOT ALWAYS'''
* <code> -2 </code>: insert, space is allocated in the stream block and inserted into later
* <code> else </code>: everything else is an encoded offset, it contains which block and offset it's pointing too.

Pointers have different types as well, depending on the type the data is loaded differently.
* <code> Direct </code>: It points directly to data, such as char*, int*, itemDef_t*
* <code> Alias </code>: It pointers to shared assets, such as Material*

For encoded offsets the first 4 bits (or 3 bits in BO2) are extracted and used as an index for the g_streamBlocks array. The other bits are the offset and is added to the data pointer in g_streamBlocks.

=== Encoding ===
<pre>
int EncodeOffset(int blockIndex, int offset)
{
return (blockIndex << 28) | (offset + 1);
}
</pre>

=== Decoding ===
<pre>
XBlockAddress DecodeOffset(int value)
{
int block = (XFILE_BLOCK)(value >> 28);
int offset = (int)(value & 0x0FFFFFFF) - 1;

return new XBlockAddress(block, offset);
}
</pre>

For example a pointer with a value of <code> 0x40001689 </code> means that the data belongs in block stream <code> 4 (large) </code> at offset <code> 0x1688 </code>.

The offset is only correct after the zone file has been loaded into the respective g_streamBlocks/memory. This is because data gets loaded into different blocks depending on how each executable loader works. In addition, data is aligned based on data type.

=== Padding Rules ===
{| class="wikitable"
| ||'''XStruct'''||'''Pointers'''||'''Byte'''||'''Bool'''||'''int16/uint16'''||'''Default'''
|-
|Byte Alignment||4||4||1||1||2||4
|}

== Insert Pointers ==
For -2 pointers, the flow goes as follows:
1. ReadPointer reads raw -2, writes that 4-byte value into the active emitted block, and remembers that cell as PatchAddress.

2. Later, when the pointer is materialized it recognizes -2 (insert)

3. For insert, it allocates one extra 4-byte pointer cell in the LARGE block, aligned to 4, initialized to 0

4. It resolves the actual payload address according to the plan: current block position, allocated block position, or current stream position.

5. It patches two cells to the encoded payload address:
the original pointer field that contained -2
the new inserted pointer cell in LARGE

Category:FastFiles

2026-06-12T03:39:32Z

Jakes625:

FastFiles and Zone files (MW2)

2026-06-12T03:26:40Z

Jakes625: /* Zone File */

[[Category:FastFiles]]
[[Category:MW2]]

== Main FastFile Structure ==
<syntaxhighlight lang="cpp">
//Note, on PS3 all values are << 1
enum language_t
{
LANGUAGE_ENGLISH = 0x1,
LANGUAGE_FRENCH = 0x2,
LANGUAGE_GERMAN = 0x3,
LANGUAGE_ITALIAN = 0x4,
LANGUAGE_SPANISH = 0x5,
LANGUAGE_BRITISH = 0x6,
LANGUAGE_RUSSIAN = 0x7,
LANGUAGE_POLISH = 0x8,
LANGUAGE_KOREAN = 0x9,
LANGUAGE_TAIWANESE = 0xA,
LANGUAGE_JAPANESE = 0xB,
LANGUAGE_CHINESE = 0xC,
LANGUAGE_THAI = 0xD,
LANGUAGE_LEET = 0xE,
LANGUAGE_CZECH = 0xF,
MAX_LANGUAGES
};

//Entry point for the FF.
struct DB_Header
{
char magic[8];
int version;
bool allowOnlineUpdate;
unsigned __int64 fileCreationTime;
language_t region;
int entryCount;
Entry entries[];
int fileSize;
int maxFileSize;
};
</syntaxhighlight>
=== Magic ===
The magic is a string that is 8 characters long. It is either "IWff0100" or "IWffu100". It indicates what is read after maxFileSize. If it is "IWff0100" then this FF is signed. If it is "IWffu100", then this FF is unsigned.
=== Version ===
Helps to dictate the version of the FF, so Modern Warfare 3 FastFiles cannot be loaded on Modern Warfare 2. The Modern Warfare 2 version is 0x10D for console systems and 0x114 for PC.
if (version > 0x10D)
Com_Error("Fastfile for zone '%s' is newer than client executable (version %d, expecting %d)", version, 0x10D);
else if (version < 0x10D)
Com_Error("Fastfile for zone '%s' is out of date (version %d, expecting %d)", version, 0x10D);
=== AllowOnlineUpdate ===
Whether or not assets in this FF may be replaced by an FF loaded at a later time.
=== Entries ===
These are still not entirely understood. Most FF systems simply parse past them.
==== Xbox 360 ====
for (int32 i = 0; i < 0x0f; i++)
{
if (((1 << i) & language) == 0)
continue;
else
ReadBytes(((entryCount << 1) + entryCount) << 2);
}
==== PS3 ====
readBytes(entryCount * 0x14);
=== File Sizes ===
The fileSize is the size of the FF, everything included. The maxFileSize is the highest number that fileSize can be, and in most FFs they are equal.

== Subheader ==
The rest of the FF is read depending on what the main FF magic was. If the magic was "IWff0100" then the FF is signed. If it was "IWffu100", the FF is unsigned.
=== Unsigned Files ===
PS3 only supports unsigned fastfiles. For Xbox 360, only single player FastFiles are unsigned. Unsigned FastFiles are very simple. The only data remaining is compressed zlib data. Decompressing the data yields the [[#Zone File|zone file]].
=== Signed Files ===
<syntaxhighlight lang="cpp">
struct DB_AuthHash
{
char bytes[32];
};

struct DB_AuthSignatureHash
{
char bytes[256];
};

struct DB_AuthSubheader
{
char fastfileName[32];
int reserved;
DB_AuthHash masterBlockHashes[244];
};

struct DB_AuthXBlock
{
#ifdef XBOX
DB_AuthHash blockSignature[0x100];
char blockData[0x200000];
#elif defined PS3
char blockData[0x10000];
#endif
};

//Sub DB_AuthHeader, continuation on the earlier.
struct DB_AuthHeader
{
char magic[8];
int reserved;
DB_AuthHash subheaderHash;
DB_AuthSignatureHash signedSubheaderHash;
DB_AuthSubHeader subheader;
DB_AuthXBlock xBlocks[];
};
</syntaxhighlight>
The signatures on the XBlocks are checked as the FastFile loads. Then the sub-header master block hashes are checked, followed by the signedSubheaderHash, and lastly the subheaderHash. If any fail, then the loading of the FF is aborted. Only Activision and the game developers can generate the RSA signatures.
==== Magic ====
The subheader magic is always "IWffs100".
==== XBlocks ====
XBlocks are used until they are no longer needed. If the compressed data can fit into 1, then only 1 will exist.

== Compression ==
=== PS3 ===
After the zone file is created, it is split into blocks each 0x10000 bytes, the last block being padded with zeroes if not 0x10000 bytes long. Each block is compressed using default zlib compression. The size of the compressed block is stored as an unsigned 16 bit integer over the zlib header (0x78DA). Compressed blocks are concatenated and appended to the fastfile.

=== Xbox 360 ===
Once the zone file is created, the entire zone is compressed using default zlib compression. If the FastFile is unsigned (single player) then the data is simply concatenated to the header. Signed files split the data up into 0x200000 byte XBlocks, each with a 0x2000 byte hash block.
== Zone File ==
The zone file is the decompressed data from an FF.

=== Header ===
The XFile header is loaded first. It contains XBlock sizes to be allocated for g_streamBlocks.
<syntaxhighlight lang="cpp">
enum
{
XFILE_BLOCK_TEMP = 0,
XFILE_BLOCK_PHYSICAL = 1,
XFILE_BLOCK_RUNTIME = 2,
XFILE_BLOCK_VIRTUAL = 3,
XFILE_BLOCK_LARGE = 4,
XFILE_BLOCK_CALLBACK = 5,
#if defined(PC) || defined(PS3)
XFILE_BLOCK_VERTEX = 6,
#ifdef PC
XFILE_BLOCK_INDEX = 7,
#endif
#endif
MAX_XFILE_COUNT
};

struct XFile
{
int size;
int externalSize;
int blockSize[MAX_XFILE_COUNT];
};
</syntaxhighlight>

=== g_streamBlocks ===
Remember that g_streamBlocks are loaded as the zone is read. Here are some examples. The raw dumps are collapsed by default to keep the page readable:

==== Temp ====
<div class="mw-collapsible mw-collapsed" style="border:1px solid #a2a9b1; padding:0.5em; margin:0.5em 0;">
'''Temp block dump'''
<div class="mw-collapsible-content">

<syntaxhighlight lang="text">
0000000B 40000001 000001AF 400000F5 40153A79 00000000 00000000 40153A82 401537C1 42820000 00000000 00000000 00000001 00000000 00000168 00000000 00000000 00000000 00000000 4000844B 00000000 00000000 00000085 00000085 0000016E 000001F4 00000001 00000000 00000000 00000000 00000000 00000000 00000000 40153A59 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 40000E89 4012CA4D 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
</syntaxhighlight>

</div>
</div>

==== Large ====
<div class="mw-collapsible mw-collapsed" style="border:1px solid #a2a9b1; padding:0.5em; margin:0.5em 0;">
'''Large block dump'''
<div class="mw-collapsible-content">

<syntaxhighlight lang="text">
00000000 4000002D 4000003E 40000052 40000066 4000007A 4000008F 4000009F 400000B0 400000C0 400000DA 6D656C65 655F6B6E 6966655F 73746162 00776561 705F6D31 3838375F 6C696674 5F706C72 00776561 705F6D31 3838375F 6F70656E 5F706C72 00776561 705F6D31 3838375F 6C6F6F70 5F706C72 00776561 705F6D31 3838375F 636C6F73 655F706C 72007669 65776D6F 64656C5F 736D616C 6C007669 65776D6F 64656C5F 6D656469 756D0076 6965776D 6F64656C 5F6C6172 67650077 6561705F 736D6F6B 65677265 6E616465 5F70696E 5F706C72 00776561 705F736D 6F6B6567 72656E61 64655F66 6972655F 706C7200 00000008 00000011 00000018 00000011 00000024 00000011 00000024 00000011 00000024 00000011 00000026 00000011 00000026 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000023 00000011 00000008 00000011 00000008 00000011 00000018 00000011 00000018 00000011 00000018 00000011 00000018 00000011 00000018 00000011 00000018 00000011 00000018 00000011 00000018 00000011 00000018 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 0000001A 00000011 00000008 00000011 00000008 00000011 00000008 00000011 00000008 00000011 00000008 00000011 00000008 00000011 00000008 00000011 00000008 00000011 00000008 00000011 00000008 00000011 0000001B 00000011 0000001B 00000011 0000001B 00000011 0000001B 00000011 00000008 00000011 00000008 00000011 00000008 00000011 00000008 00000011 00000008 00000011 0000001B 00000011 0000001B 00000011 0000001B 00000011 00000023 00000011 2C326400 75695F6D 702F6D61 696E2E6D 656E7500 0000001D 0000001D ........
</syntaxhighlight>

</div>
</div>

=== Asset List ===
After the XFile header is the asset list. The asset list contains a list of script strings and a list of assets. The fastfile compiler creates a rawfile as the last asset which contains any compiler errors (as seen in french code_post_gfx_mp.ff).
<syntaxhighlight lang="cpp">
struct XAsset
{
XAssetType type; //See enum below
XAssetHeader * header;
};

struct XAssetList
{
int scriptStringCount;
const char * * scriptStrings;
int assetCount;
XAsset *assets;
};
</syntaxhighlight>

== General [[:Category:Assets|Asset]] Information ==
=== Asset Types ===
The types of assets loaded are determined by this enum.
{| border="1" cellpadding="1" cellspacing="1" class="article-table" style="font-size:13px;line-height:21px;width:500px;height:500px;"
! scope="col"|Asset Type
! scope="col"|Xbox ID
! scope="col"|PS3 ID
! scope="col"|PC ID
! scope="col"|Is Used
! scope="col"|Max Count
! scope="col"|Asset Size (PC)
|-
|physpreset
|0x00
|0x00
|0x00
|True
|0x40
|0x2C
|-
|phys_collmap
|0x01
|0x01
|0x01
|True
|0x400
|0x48
|-
|xanim
|0x02
|0x02
|0x02
|True
|0x1000
|0x58
|-
|xmodelsurfs
|0x03
|0x03
|0x03
|True
|0x1000
|0x24
|-
|xmodel
|0x04
|0x04
|0x04
|True
|0x600
|0x130
|-
|material
|0x05
|0x05
|0x05
|True
|0x1000
|0x60
|-
|pixelshader
|0x06
|0x06
|0x06
|True
|0x1FA0
|0x10
|-
|vertexshader
|N/A
|0x07
|0x07
|True
|0x400
|0x10
|-
|vertexdecl
|N/A
|N/A
|0x08
|True
|0x30
|0x64
|-
|techset
|0x07
|0x08
|0x09
|True
|0x300
|0xCC
|-
|image
|0x08
|0x09
|0x0A
|True
|0xE00
|0x20
|-
|sound
|0x09
|0x0A
|0x0B
|True
|0x3E80
|0x0C
|-
|sndcurve
|0x0A
|0x0B
|0x0C
|True
|0x40
|0x88
|-
|loaded_sound
|0x0B
|0x0C
|0x0D
|True
|0x546
|0x2C
|-
|col_map_sp
|0x0C
|0x0D
|0x0E
|True
|1
|0x100
|-
|col_map_mp
|0x0D
|0x0E
|0x0F
|True
|1
|0x100
|-
|com_map
|0x0E
|0x0F
|0x10
|True
|1
|0x10
|-
|game_map_sp
|0x0F
|0x10
|0x11
|True
|1
|0x38
|-
|game_map_mp
|0x10
|0x11
|0x12
|True
|1
|0x08
|-
|map_ents
|0x11
|0x12
|0x13
|True
|2
|0x2C
|-
|fx_map
|0x12
|0x13
|0x14
|True
|1
|0x74
|-
|gfx_map
|0x13
|0x14
|0x15
|True
|1
|0x274
|-
|lightdef
|0x14
|0x15
|0x16
|True
|0x20
|0x10
|-
|ui_map
|0x15
|0x16
|0x17
|False
|0
|N/A
|-
|font
|0x16
|0x17
|0x18
|True
|0x10
|0x18
|-
|menufile
|0x17
|0x18
|0x19
|True
|0x80
|0x0C
|-
|menu
|0x18
|0x19
|0x1A
|True
|0x264
|0x190
|-
|localize
|0x19
|0x1A
|0x1B
|True
|0x1B58
|0x08
|-
|weapon
|0x1A
|0x1B
|0x1C
|True
|0x578
|0x684
|-
|snddriverglobals
|0x1B
|0x1C
|0x1D
|True
|1
|N/A
|-
|fx
|0x1C
|0x1D
|0x1E
|True
|0x258
|0x20
|-
|impactfx
|0x1D
|0x1E
|0x1F
|True
|4
|0x08
|-
|aitype
|0x1E
|0x1F
|0x20
|False
|0
|N/A
|-
|mptype
|0x1F
|0x20
|0x21
|False
|0
|N/A
|-
|character
|0x20
|0x21
|0x22
|False
|0
|N/A
|-
|xmodelalias
|0x21
|0x22
|0x23
|False
|0
|N/A
|-
|rawfile
|0x22
|0x23
|0x24
|True
|0x400
|0x10
|-
|stringtable
|0x23
|0x24
|0x25
|True
|0x190
|0x10
|-
|leaderboarddef
|0x24
|0x25
|0x26
|True
|0x64
|0x18
|-
|structureddatadef
|0x25
|0x26
|0x27
|True
|0x18
|0x0C
|-
|tracer
|0x26
|0x27
|0x28
|True
|0x20
|0x70
|-
|vehicle
|0x27
|0x28
|0x29
|True
|0x80
|0x2D0
|-
|addon_map_ents
|0x28
|0x29
|0x2A
|True
|1
|0x24
|}

Material Asset

2026-06-12T03:12:40Z

Jakes625: /* Call of Duty 4 & World at War & Modern Warfare 2 & Modern Warfare 3 */

__NOTOC__
[[Category:Assets]]
[[Category:CoD4]]
[[Category:WaW]]
[[Category:MW2]]
[[Category:BO1]]
[[Category:MW3]]
[[Category:BO2]]
[[Category:Ghosts]]
== Call of Duty 4 & World at War & Modern Warfare 2 & Modern Warfare 3 ==
<source lang="cpp">
struct MaterialConstantDef
{
int nameHash;
char name[12];
vec4_t literal;
};

struct GfxStateBitsStructured
{
//This word stores blend, alpha, culling, color write, gamma, and polygon mode state.
unsigned int srcBlendRgb : 4; // bits 0-3
unsigned int dstBlendRgb : 4; // bits 4-7
unsigned int blendOpRgb : 3; // bits 8-10
unsigned int alphaTestDisabled : 1; // bit 11
unsigned int alphaTest : 2; // bits 12-13
unsigned int cullFace : 2; // bits 14-15
unsigned int srcBlendAlpha : 4; // bits 16-19
unsigned int dstBlendAlpha : 4; // bits 20-23
unsigned int blendOpAlpha : 3; // bits 24-26
unsigned int colorWriteRgb : 1; // bit 27
unsigned int colorWriteAlpha : 1; // bit 28
unsigned int unused0 : 1; // bit 29
unsigned int gammaWrite : 1; // bit 30
unsigned int polymodeLine : 1; // bit 31

// This word stores depth and stencil state.
unsigned int depthWrite : 1; // bit 0
unsigned int depthTestDisabled : 1; // bit 1
unsigned int depthTest : 2; // bits 2-3
unsigned int polygonOffset : 2; // bits 4-5
unsigned int stencilFrontEnabled : 1; // bit 6
unsigned int stencilBackEnabled : 1; // bit 7
unsigned int stencilFrontPass : 3; // bits 8-10
unsigned int stencilFrontFail : 3; // bits 11-13
unsigned int stencilFrontZFail : 3; // bits 14-16
unsigned int stencilFrontFunc : 3; // bits 17-19
unsigned int stencilBackPass : 3; // bits 20-22
unsigned int stencilBackFail : 3; // bits 23-25
unsigned int stencilBackZFail : 3; // bits 26-28
unsigned int stencilBackFunc : 3; // bits 29-31
};

union GfxStateBits
{
#ifdef XBOX
int loadBits[2];
#elif defined(PS3)
int (*loadBits)[2];
#if defined(MW2) || defined(MW3)
GfxStateBitsStructured structured;
#endif
#endif
};

struct WaterWritable
{
float floatTime;
};

struct water_t
{
WaterWritable writable;
float *H0X; // Count = M * N
float *H0Y; // Count = M * N
float *wTerm; // Count = M * N
int M;
int N;
float Lx;
float Lz;
float gravity;
float windvel;
float winddir[2];
float amplitude;
float codeConstant[4];
GfxImage *image;
};

/* MaterialTextureDef->semantic */
#define TS_2D 0x0
#define TS_FUNCTION 0x1
#define TS_COLOR_MAP 0x2
#define TS_UNUSED_1 0x3
#define TS_UNUSED_2 0x4
#define TS_NORMAL_MAP 0x5
#define TS_UNUSED_3 0x6
#define TS_UNUSED_4 0x7
#define TS_SPECULAR_MAP 0x8
#define TS_UNUSED_5 0x9
#define TS_UNUSED_6 0xA
#define TS_WATER_MAP 0xB

union MaterialTextureDefInfo
{
GfxImage *image; // MaterialTextureDef->semantic != TS_WATER_MAP
water_t *water; // MaterialTextureDef->semantic == TS_WATER_MAP
};

struct MaterialTextureDef
{
unsigned int nameHash;
char nameStart;
char nameEnd;
char sampleState;
char semantic;
unsigned char isMatureContent;
unsigned char pad[3];
MaterialTextureDefInfo u;
};

union GFxDrawSurfFields
{
unsigned long long unused,
primarySortKey,
surfType,
primaryLightIndex,
prepass,
materialSortedIndex,
customIndex,
reflectionProbeIndex,
objectId;
};

union GfxDrawSurf
{
GFxDrawSurfFields fields;
unsigned long long packed;
};

struct __declspec(align(8)) MaterialInfo
{
const char *name;
char gameFlags;
char sortKey;
char textureAtlasRowCount;
char textureAtlasColumnCount;
GfxDrawSurf drawSurf;
int surfaceTypeBits;
};

struct Material
{
MaterialInfo info;
char stateBitsEntry[TECHNIQUE_COUNT]; // see MaterialTechniqueType
char textureCount;
char constantCount;
char stateBitsCount;
char stateFlags;
char cameraRegion;
#ifdef PS3
unsigned short ushorts[TECHNIQUE_COUNT];
unsigned short *ushortArray; // count = TECHNIQUE_COUNT, see MaterialTechniqueType
#endif
MaterialTechniqueSet *techniqueSet;
MaterialTextureDef *textureTable;
MaterialConstantDef *constantTable;
GfxStateBits *stateBitTable;
#if defined(MW2) || defined(MW3)
const char **unknownXStringArray;
#endif
};
</source>

== Black Ops & Black Ops 2==
<source lang="cpp">
struct MaterialConstantDef
{
unsigned int nameHash;
char name[12];
vec4_t literal;
};

struct GfxStateBits
{
#if defined(XBOX) || defined(BO2) // ps3 uses this for bo2..
unsigned int loadBits[2];
#elif defined PS3
int (*loadBits)[2];
#endif
};

struct WaterWritable
{
float floatTime;
};

struct water_t
{
WaterWritable writable;
float *H0X; // Count = M * N
float *H0Y; // Count = M * N
float *wTerm; // Count = M * N
int M;
int N;
float Lx;
float Lz;
float gravity;
float windvel;
float winddir[2];
float amplitude;
float codeConstant[4];
GfxImage *image;
};

/* MaterialTextureDef->semantic */
#define TS_2D 0x0
#define TS_FUNCTION 0x1
#define TS_COLOR_MAP 0x2
#define TS_UNUSED_1 0x3
#define TS_UNUSED_2 0x4
#define TS_NORMAL_MAP 0x5
#define TS_UNUSED_3 0x6
#define TS_UNUSED_4 0x7
#define TS_SPECULAR_MAP 0x8
#define TS_UNUSED_5 0x9
#define TS_UNUSED_6 0xA
#define TS_WATER_MAP 0xB

union MaterialTextureDefInfo
{
GfxImage *image; // MaterialTextureDef->semantic != TS_WATER_MAP
water_t *water; // MaterialTextureDef->semantic == TS_WATER_MAP
};

struct MaterialTextureDef
{
unsigned int nameHash;
char nameStart;
char nameEnd;
char samplerState;
char semantic;
char isMatureContent;
#ifdef BO1
MaterialTextureDefInfo u;
#elif
GfxImage *image;
#endif
};

union GFxDrawSurfFields
{
unsigned long long unused,
primarySortKey,
surfType,
primaryLightIndex,
prepass,
materialSortedIndex,
customIndex,
reflectionProbeIndex,
objectId;
};

union GfxDrawSurf
{
GFxDrawSurfFields fields;
unsigned long long packed;
};

struct MaterialInfo
{
const char *name;
unsigned int gameFlags;
char pad;
char sortKey;
char textureAtlasRowCount;
char textureAtlasColumnCount;
GfxDrawSurf drawSurf;
unsigned int surfaceTypeBits;
unsigned int layeredSurfaceTypes;
unsigned __int16 hashIndex;
int surfaceFlags;
#ifdef BO2
int contents;
#endif
};

struct Material
{
MaterialInfo info;
char stateBitsEntry[TECHNIQUE_COUNT]; // see MaterialTechniqueType
char textureCount;
char constantCount;
char stateBitsCount;
char stateFlags;
char cameraRegion;
char probeMipBits;
MaterialTechniqueSet *techniqueSet;
MaterialTextureDef *textureTable;
MaterialConstantDef *constantTable;
GfxStateBits *stateBitTable;
#ifdef BO2
Material *thermalMaterial;
#endif
};
</source>

== Ghosts ==
<source lang="cpp">
struct MaterialConstantDef
{
unsigned int nameHash;
char name[12];
float literal[4];
};

struct GfxStateBits
{
int (*loadBits)[3];
char unknown1[0xE];
char unknown2[0xE];
char unknown3[2];
char unknown4[2];
};

struct WaterWritable
{
float floatTime;
};

struct water_t
{
WaterWritable writable;
float *H0X; // Count = M * N
float *H0Y; // Count = M * N
float *wTerm; // Count = M * N
int M;
int N;
float Lx;
float Lz;
float gravity;
float windvel;
float winddir[2];
float amplitude;
float codeConstant[4];
GfxImage *image;
};

/* MaterialTextureDef->semantic */
#define TS_2D 0x0
#define TS_FUNCTION 0x1
#define TS_COLOR_MAP 0x2
#define TS_UNUSED_1 0x3
#define TS_UNUSED_2 0x4
#define TS_NORMAL_MAP 0x5
#define TS_UNUSED_3 0x6
#define TS_UNUSED_4 0x7
#define TS_SPECULAR_MAP 0x8
#define TS_UNUSED_5 0x9
#define TS_UNUSED_6 0xA
#define TS_WATER_MAP 0xB

union MaterialTextureDefInfo
{
GfxImage *image;
water_t *water;
};

struct MaterialTextureDef
{
unsigned int nameHash;
char nameStart;
char nameEnd;
char sampleState;
char semantic;
MaterialTextureDefInfo u;
};

union GFxDrawSurfFields
{
unsigned long long unused,
primarySortKey,
surfType,
primaryLightIndex,
prepass,
materialSortedIndex,
customIndex,
reflectionProbeIndex,
objectId;
};

union GfxDrawSurf
{
GFxDrawSurfFields fields;
unsigned long long packed;
};

struct __declspec(align(8)) MaterialInfo // 0x20
{
const char *name;
char gameFlags;
char sortKey;
char textureAtlasRowCount;
char textureAtlasColumnCount;
GfxDrawSurf drawSurf;
int surfaceTypeBits;
char unknown[0xC];
};

struct Material // 0xB8
{
MaterialInfo info;
char stateBitsEntry[TECHNIQUE_COUNT]; // see MaterialTechniqueType
char textureCount; // 0x47
char constantCount; // 0x48
char stateBitsCount; // 0x49
char stateFlags; // 0x4A
char cameraRegion; // 0x4B
char unknown; // 0x4C
char stringCount; // 0x4D
#ifdef PS3
unsigned short ushorts[TECHNIQUE_COUNT];
unsigned short *ushortArray; // count = TECHNIQUE_COUNT, see MaterialTechniqueType
#endif
MaterialTechniqueSet *techniqueSet;
MaterialTextureDef *textureTable; // count = textureCount
MaterialConstantDef *constantTable; // count = constantCount
GfxStateBits *stateBitTable; // count = stateBitsCount
const char **XStringArray; // count = stringCount
int unknown;
};
</source>

MapEnts Asset

2026-06-12T02:58:29Z

Jakes625: /* Modern Warfare 2 */

__NOTOC__
[[Category:Assets]]
[[Category:CoD4]]
[[Category:MW2]]
[[Category:MW3]]
[[Category:Ghosts]]
[[Category:AW]]
[[Category:WaW]]
[[Category:BO1]]
[[Category:BO2]]
[[Category:BO3]]
The map_ents asset is part of the D3DBSP system used that is produced by Radiant. This is used to define any entities in the map particularly spawn points, helicopter path points, physable entities, and destructible entities. Although the entity string itself is quite easy to understand, some unknown structures have been added on later Call of Duty games.
== Call of Duty 4 & World at War & Black Ops 1 ==
This is the simplest map_ents.
<syntaxhighlight lang="cpp">
struct MapEnts
{
const char *name;
char *entityString;
int numEntityChars;
};
</syntaxhighlight>
The entityString is simply a string that defines different entitys, and it's length is numEntityChars. This is a simple as it gets.
== Modern Warfare 2 ==
Modern Warfare 2 adds some extra data to the end, believed to be buffer data and Stage data.
<syntaxhighlight lang="cpp">
struct TriggerModel
{
int contents;
uint16_t hullCount;
uint16_t firstHull;
};

struct TriggerHull
{
Bounds bounds;
int contents;
uint16_t slabCount;
uint16_t firstSlab;
};

struct TriggerSlab
{
float dir[3];
float midPoint;
float halfSize;
};

struct MapTriggers
{
uint count;
TriggerModel* models; //size = count << 3
uint hullCount;
TriggerHull* hulls; //size = hullCount << 5
uint slabcount;
TriggerSlab* slabs; //size = ((slabCount << 2) + slabCount) << 2
};

struct Stage
{
char * stageName;
float origin[3];
uint16_t triggerIndex;
char sunPrimaryLightIndex;
};

struct MapEnts
{
const char *name;
char *entityString;
int numEntityChars;
MapTriggers trigger;
Stage * stages;
byte stageCount;
};
</syntaxhighlight>
Keep in mind that the MapTriggers is also used in the addon_map_ents asset, despite one of those never actually having been found.

== Modern Warfare 3 ==
Modern Warfare 3 adds even more extra data to the end, believed to be buffer data.
<syntaxhighlight lang="cpp">
struct unknownInternalMapEnts1
{
int unknownCount1;
char * unknownData1; //size = unknownCount1 << 3
int unknownCount2;
char * unknownData2; //size = unknownCount2 << 5
int unknownCount3;
char * unknownData3; //size = ((unknownCount3 << 2) + unknownCount3) << 2
};

struct unknownInternalMapEnts2
{
unknownInternalMapEnts1 unknownStruct1;
short unknownCount1;
char * unknownData1; //size = unknownCount1 * 0x1C
int unknownCount2;
char * unknownData2; //size = unknownCount2
char * unknownData3; //size = unknownStruct1->unknownCount1 << 1
char * unknownData4; //size = unknownStruct1->unknownCount1
char * unknownData5; //size = ((unknownStruct1->unknownCount1 << 1) + unknownStruct1->unknownCount1) << 2
char * unknownData6; //size = unknownStruct1->unknownCount1 << 2
char * unknownData7; //size = unknownStruct1->unknownCount1 << 1
};

struct MapEnts
{
const char *name;
char *entityString;
int numEntityChars;
unknownInternalMapEnts1 unknownStruct1;
unknownInternalMapEnts2 unknownStruct2;
};
</syntaxhighlight>
Keep in mind that the unknownInternalMapEnts1 is also used in the addon_map_ents and col_map_mp (clipMap) assets.
== Black Ops 2 & 3 ==
Black Ops 2 adds similar data to Modern Warfare 2 to the end of it's asset, believed to be buffer data.
<syntaxhighlight lang="cpp">
struct TriggerModel
{
int contents;
unsigned __int16 hullCount;
unsigned __int16 firstHull;
};

struct TriggerHull
{
Bounds bounds;
int contents;
unsigned __int16 slabCount;
unsigned __int16 firstSlab;
};

struct TriggerSlab
{
vec3_t dir;
float midPoint;
float halfSize;
};

struct MapTriggers
{
unsigned int count;
TriggerModel *models;
unsigned int hullCount;
TriggerHull *hulls;
unsigned int slabCount;
TriggerSlab *slabs;
};

struct MapEnts
{
const char *name;
char *entityString;
int numEntityChars;
MapTriggers trigger;
};
</syntaxhighlight>

== Ghosts ==
Ghosts provides a fundamental change to the way the map_ents asset works, because while the entityString still exists it goes unused.
<syntaxhighlight lang="cpp">
struct Bounds
{
float midPoint[3];
float halfSize[3];
};

struct TriggerModel
{
int contents;
unsigned __int16 hullCount;
unsigned __int16 firstHull;
};

struct TriggerHull
{
Bounds bounds;
int contents;
unsigned __int16 slabCount;
unsigned __int16 firstSlab;
};

struct TriggerSlab
{
float dir[3];
float midPoint;
float halfSize;
};

struct MapTriggers
{
unsigned int count;
TriggerModel *models;
unsigned int hullCount;
TriggerHull *hulls;
unsigned int slabCount;
TriggerSlab *slabs;
};

struct ClientTriggerAabbNode
{
Bounds bounds;
unsigned __int16 firstChild;
unsigned __int16 childCount;
};

struct ClientTriggers
{
MapTriggers trigger;
unsigned __int16 numClientTriggerNodes;
ClientTriggerAabbNode *clientTriggerAabbTree;
unsigned int triggerStringLength;
char *triggerString;
__int16 *visionSetTriggers;
char *triggerType;
float (*origins)[3];
float *scriptDelay;
__int16 *audioTriggers;
__int16 *blendLookup;
__int16 *npcTriggers;
};

struct ClientTriggerBlendNode
{
float pointA[3];
float pointB[3];
unsigned __int16 triggerA;
unsigned __int16 triggerB;
};

struct ClientTriggerBlend
{
unsigned __int16 numClientTriggerBlendNodes;
ClientTriggerBlendNode *blendNodes;
};

struct SpawnPointEntityRecord
{
unsigned __int16 index;
scr_string_t name;
scr_string_t target;
scr_string_t script_noteworthy;
float origin[3];
float angles[3];
};

struct SpawnPointRecordList
{
unsigned __int16 spawnsCount;
SpawnPointEntityRecord *spawns;
};

struct SplinePointEntityRecord
{
int splineId;
int splineNodeId;
char *splineNodeLabel;
float splineNodeTension;
float origin[3];
float corridorDims[2];
float tangent[3];
float distToNextNode;
float (*positionCubic)[3];
float (*tangentQuadratic)[3];
};

struct SplinePointRecordList
{
unsigned __int16 splinePointCount;
float splineLength;
SplinePointEntityRecord *splinePoints;
};

struct SplineRecordList
{
unsigned __int16 splineCount;
SplinePointRecordList *splines;
};

struct MapEnts
{
const char *name;
char *entityString;
int numEntityChars;
MapTriggers trigger;
ClientTriggers clientTrigger;
ClientTriggerBlend clientTriggerBlend;
SpawnPointRecordList spawnList;
SplineRecordList splineList;
};
</syntaxhighlight>

== Advanced Warfare ==
Advanced Warfare provides a fundamental change to the way the map_ents asset works, because while the entityString still exists it goes unused.
<syntaxhighlight lang="cpp">
struct unknownInternalMapEnts1
{
int unknownCount1;
char * unknownData1; //size = unknownCount1 << 3
int unknownCount2;
char * unknownData2; //size = unknownCount2 << 5
int unknownCount3;
char * unknownData3; //size = (unknownCount3 << 4) + (unknownCount3 << 2)
};

struct unknownInternalMapEnts2
{
unknownInternalMapEnts1 unknownStruct1;
short unknownCount1;
char * unknownData1; //size = unknownCount1 * 0x1C
int unknownCount2;
char * unknownData2; //size = unknownCount2
char * unknownData3; //size = unknownStruct1->unknownCount1 << 1
char * unknownData4; //size = unknownStruct1->unknownCount1 << 1
char * unknownData5; //size = unknownStruct1->unknownCount1 << 1
char * unknownData6; //size = unknownStruct1->unknownCount1 << 1
char * unknownData7; //size = ((unknownStruct1->unknownCount1 + unknownStruct1->unknownCount1) + unknownStruct1->unknownCount1) << 2
char * unknownData8; //size = unknownStruct1->unknownCount1 << 2
char * unknownData9; //size = unknownStruct1->unknownCount1 << 1
char * unknownData10; //size = unknownStruct1->unknownCount1 << 1
char * unknownData11; //size = unknownStruct1->unknownCount1 << 1
char * unknownData12; //size = unknownStruct1->unknownCount1 << 1
char * unknownData13; //size = unknownStruct1->unknownCount1 << 1
};

struct unknownInternalMapEnts3
{
short unknownCount;
char * unknownData; //size = unknownCount * 0x1C
};

struct unknownInternalMapEnts4Internal1
{
short unknown1;
ScriptString unknownScriptString1;
ScriptString unknownScriptString2;
ScriptString unknownScriptString3;
ScriptString unknownScriptString4;
char unknown2[0x12];
};

struct unknownInternalMapEnts4
{
short unknownCount;
unknownInternalMapEnts4Internal1 * unknownStruct; //Count = unknownCount
};

struct unknownInternalMapEnts5Internal1Internal1
{
char unknown1[8];
char (*unknown2)[0x40];
char unknown3[0x28];
char (*unknown4)[0x30];
char (*unknown5)[0x24];
};

struct unknownInternalMapEnts5Internal1
{
short unknownCount;
int unknown;
unknownInternalMapEnts5Internal1Internal1 * unknownStruct; //Count = unknownCount
};

struct unknownInternalMapEnts5
{
short unknownCount;
unknownInternalMapEnts5Internal1 * unknownStruct; //Count = unknownCount
};

struct MapEnts
{
const char *name;
char *entityString;
int numEntityChars;
unknownInternalMapEnts1 unknownStruct1;
unknownInternalMapEnts2 unknownStruct2;
unknownInternalMapEnts3 unknownStruct3;
unknownInternalMapEnts4 unknownStruct4;
unknownInternalMapEnts5 unknownStruct5;
};
</syntaxhighlight>

== Source Format ==
The source format must work in tandem with the other D3DBSP assets. Currently the used the source format is simply a text file with the entityString located at "raw/maps/(MAPNAME).d3dbsp" for SP maps and at "raw/maps/mp/(MAPNAME).d3dbsp" for MP maps.

MapEnts Asset

2026-06-12T02:55:39Z

Jakes625: /* Modern Warfare 2 */

__NOTOC__
[[Category:Assets]]
[[Category:CoD4]]
[[Category:MW2]]
[[Category:MW3]]
[[Category:Ghosts]]
[[Category:AW]]
[[Category:WaW]]
[[Category:BO1]]
[[Category:BO2]]
[[Category:BO3]]
The map_ents asset is part of the D3DBSP system used that is produced by Radiant. This is used to define any entities in the map particularly spawn points, helicopter path points, physable entities, and destructible entities. Although the entity string itself is quite easy to understand, some unknown structures have been added on later Call of Duty games.
== Call of Duty 4 & World at War & Black Ops 1 ==
This is the simplest map_ents.
<syntaxhighlight lang="cpp">
struct MapEnts
{
const char *name;
char *entityString;
int numEntityChars;
};
</syntaxhighlight>
The entityString is simply a string that defines different entitys, and it's length is numEntityChars. This is a simple as it gets.
== Modern Warfare 2 ==
Modern Warfare 2 adds some extra data to the end, believed to be buffer data and Stage data.
<syntaxhighlight lang="cpp">
struct TriggerModel
{
int contents;
uint16_t hullCount;
uint16_t firstHull;
};

struct TriggerHull
{
Bounds bounds;
int contents;
uint16_t slabCount;
uint16_t firstSlab;
};

struct MapTriggers
{
int count;
char * unknownData1; //size = count << 3
int hullCount;
char * hullCount; //size = hullCount << 5
int hullCount;
char * slabCount; //size = ((slabCount << 2) + slabCount) << 2
};

struct Stage
{
char * stageName;
float origin[3];
uint16_t triggerIndex;
char sunPrimaryLightIndex;
};

struct MapEnts
{
const char *name;
char *entityString;
int numEntityChars;
MapTriggers trigger;
Stage * stages;
byte stageCount;
};
</syntaxhighlight>
Keep in mind that the unknownInternalMapEnts1 is also used in the addon_map_ents asset, despite one of those never actually having been found.

== Modern Warfare 3 ==
Modern Warfare 3 adds even more extra data to the end, believed to be buffer data.
<syntaxhighlight lang="cpp">
struct unknownInternalMapEnts1
{
int unknownCount1;
char * unknownData1; //size = unknownCount1 << 3
int unknownCount2;
char * unknownData2; //size = unknownCount2 << 5
int unknownCount3;
char * unknownData3; //size = ((unknownCount3 << 2) + unknownCount3) << 2
};

struct unknownInternalMapEnts2
{
unknownInternalMapEnts1 unknownStruct1;
short unknownCount1;
char * unknownData1; //size = unknownCount1 * 0x1C
int unknownCount2;
char * unknownData2; //size = unknownCount2
char * unknownData3; //size = unknownStruct1->unknownCount1 << 1
char * unknownData4; //size = unknownStruct1->unknownCount1
char * unknownData5; //size = ((unknownStruct1->unknownCount1 << 1) + unknownStruct1->unknownCount1) << 2
char * unknownData6; //size = unknownStruct1->unknownCount1 << 2
char * unknownData7; //size = unknownStruct1->unknownCount1 << 1
};

struct MapEnts
{
const char *name;
char *entityString;
int numEntityChars;
unknownInternalMapEnts1 unknownStruct1;
unknownInternalMapEnts2 unknownStruct2;
};
</syntaxhighlight>
Keep in mind that the unknownInternalMapEnts1 is also used in the addon_map_ents and col_map_mp (clipMap) assets.
== Black Ops 2 & 3 ==
Black Ops 2 adds similar data to Modern Warfare 2 to the end of it's asset, believed to be buffer data.
<syntaxhighlight lang="cpp">
struct TriggerModel
{
int contents;
unsigned __int16 hullCount;
unsigned __int16 firstHull;
};

struct TriggerHull
{
Bounds bounds;
int contents;
unsigned __int16 slabCount;
unsigned __int16 firstSlab;
};

struct TriggerSlab
{
vec3_t dir;
float midPoint;
float halfSize;
};

struct MapTriggers
{
unsigned int count;
TriggerModel *models;
unsigned int hullCount;
TriggerHull *hulls;
unsigned int slabCount;
TriggerSlab *slabs;
};

struct MapEnts
{
const char *name;
char *entityString;
int numEntityChars;
MapTriggers trigger;
};
</syntaxhighlight>

== Ghosts ==
Ghosts provides a fundamental change to the way the map_ents asset works, because while the entityString still exists it goes unused.
<syntaxhighlight lang="cpp">
struct Bounds
{
float midPoint[3];
float halfSize[3];
};

struct TriggerModel
{
int contents;
unsigned __int16 hullCount;
unsigned __int16 firstHull;
};

struct TriggerHull
{
Bounds bounds;
int contents;
unsigned __int16 slabCount;
unsigned __int16 firstSlab;
};

struct TriggerSlab
{
float dir[3];
float midPoint;
float halfSize;
};

struct MapTriggers
{
unsigned int count;
TriggerModel *models;
unsigned int hullCount;
TriggerHull *hulls;
unsigned int slabCount;
TriggerSlab *slabs;
};

struct ClientTriggerAabbNode
{
Bounds bounds;
unsigned __int16 firstChild;
unsigned __int16 childCount;
};

struct ClientTriggers
{
MapTriggers trigger;
unsigned __int16 numClientTriggerNodes;
ClientTriggerAabbNode *clientTriggerAabbTree;
unsigned int triggerStringLength;
char *triggerString;
__int16 *visionSetTriggers;
char *triggerType;
float (*origins)[3];
float *scriptDelay;
__int16 *audioTriggers;
__int16 *blendLookup;
__int16 *npcTriggers;
};

struct ClientTriggerBlendNode
{
float pointA[3];
float pointB[3];
unsigned __int16 triggerA;
unsigned __int16 triggerB;
};

struct ClientTriggerBlend
{
unsigned __int16 numClientTriggerBlendNodes;
ClientTriggerBlendNode *blendNodes;
};

struct SpawnPointEntityRecord
{
unsigned __int16 index;
scr_string_t name;
scr_string_t target;
scr_string_t script_noteworthy;
float origin[3];
float angles[3];
};

struct SpawnPointRecordList
{
unsigned __int16 spawnsCount;
SpawnPointEntityRecord *spawns;
};

struct SplinePointEntityRecord
{
int splineId;
int splineNodeId;
char *splineNodeLabel;
float splineNodeTension;
float origin[3];
float corridorDims[2];
float tangent[3];
float distToNextNode;
float (*positionCubic)[3];
float (*tangentQuadratic)[3];
};

struct SplinePointRecordList
{
unsigned __int16 splinePointCount;
float splineLength;
SplinePointEntityRecord *splinePoints;
};

struct SplineRecordList
{
unsigned __int16 splineCount;
SplinePointRecordList *splines;
};

struct MapEnts
{
const char *name;
char *entityString;
int numEntityChars;
MapTriggers trigger;
ClientTriggers clientTrigger;
ClientTriggerBlend clientTriggerBlend;
SpawnPointRecordList spawnList;
SplineRecordList splineList;
};
</syntaxhighlight>

== Advanced Warfare ==
Advanced Warfare provides a fundamental change to the way the map_ents asset works, because while the entityString still exists it goes unused.
<syntaxhighlight lang="cpp">
struct unknownInternalMapEnts1
{
int unknownCount1;
char * unknownData1; //size = unknownCount1 << 3
int unknownCount2;
char * unknownData2; //size = unknownCount2 << 5
int unknownCount3;
char * unknownData3; //size = (unknownCount3 << 4) + (unknownCount3 << 2)
};

struct unknownInternalMapEnts2
{
unknownInternalMapEnts1 unknownStruct1;
short unknownCount1;
char * unknownData1; //size = unknownCount1 * 0x1C
int unknownCount2;
char * unknownData2; //size = unknownCount2
char * unknownData3; //size = unknownStruct1->unknownCount1 << 1
char * unknownData4; //size = unknownStruct1->unknownCount1 << 1
char * unknownData5; //size = unknownStruct1->unknownCount1 << 1
char * unknownData6; //size = unknownStruct1->unknownCount1 << 1
char * unknownData7; //size = ((unknownStruct1->unknownCount1 + unknownStruct1->unknownCount1) + unknownStruct1->unknownCount1) << 2
char * unknownData8; //size = unknownStruct1->unknownCount1 << 2
char * unknownData9; //size = unknownStruct1->unknownCount1 << 1
char * unknownData10; //size = unknownStruct1->unknownCount1 << 1
char * unknownData11; //size = unknownStruct1->unknownCount1 << 1
char * unknownData12; //size = unknownStruct1->unknownCount1 << 1
char * unknownData13; //size = unknownStruct1->unknownCount1 << 1
};

struct unknownInternalMapEnts3
{
short unknownCount;
char * unknownData; //size = unknownCount * 0x1C
};

struct unknownInternalMapEnts4Internal1
{
short unknown1;
ScriptString unknownScriptString1;
ScriptString unknownScriptString2;
ScriptString unknownScriptString3;
ScriptString unknownScriptString4;
char unknown2[0x12];
};

struct unknownInternalMapEnts4
{
short unknownCount;
unknownInternalMapEnts4Internal1 * unknownStruct; //Count = unknownCount
};

struct unknownInternalMapEnts5Internal1Internal1
{
char unknown1[8];
char (*unknown2)[0x40];
char unknown3[0x28];
char (*unknown4)[0x30];
char (*unknown5)[0x24];
};

struct unknownInternalMapEnts5Internal1
{
short unknownCount;
int unknown;
unknownInternalMapEnts5Internal1Internal1 * unknownStruct; //Count = unknownCount
};

struct unknownInternalMapEnts5
{
short unknownCount;
unknownInternalMapEnts5Internal1 * unknownStruct; //Count = unknownCount
};

struct MapEnts
{
const char *name;
char *entityString;
int numEntityChars;
unknownInternalMapEnts1 unknownStruct1;
unknownInternalMapEnts2 unknownStruct2;
unknownInternalMapEnts3 unknownStruct3;
unknownInternalMapEnts4 unknownStruct4;
unknownInternalMapEnts5 unknownStruct5;
};
</syntaxhighlight>

== Source Format ==
The source format must work in tandem with the other D3DBSP assets. Currently the used the source format is simply a text file with the entityString located at "raw/maps/(MAPNAME).d3dbsp" for SP maps and at "raw/maps/mp/(MAPNAME).d3dbsp" for MP maps.

Menu Asset (MW2)

2026-06-12T02:09:00Z

Jakes625:

[[Category:Assets]]
[[Category:MW2]]
<syntaxhighlight lang="cpp">
enum operationEnum
{
OP_NOOP = 0x0,
OP_RIGHTPAREN = 0x1,
OP_MULTIPLY = 0x2,
OP_DIVIDE = 0x3,
OP_MODULUS = 0x4,
OP_ADD = 0x5,
OP_SUBTRACT = 0x6,
OP_NOT = 0x7,
OP_LESSTHAN = 0x8,
OP_LESSTHANEQUALTO = 0x9,
OP_GREATERTHAN = 0xA,
OP_GREATERTHANEQUALTO = 0xB,
OP_EQUALS = 0xC,
OP_NOTEQUAL = 0xD,
OP_AND = 0xE,
OP_OR = 0xF,
OP_LEFTPAREN = 0x10,
OP_COMMA = 0x11,
OP_BITWISEAND = 0x12,
OP_BITWISEOR = 0x13,
OP_BITWISENOT = 0x14,
OP_BITSHIFTLEFT = 0x15,
OP_BITSHIFTRIGHT = 0x16,
OP_STATICDVARINT = 0x17,
OP_STATICDVARBOOL = 0x18,
OP_STATICDVARFLOAT = 0x19,
OP_STATICDVARSTRING = 0x1A,
OP_INT = 0x1B,
OP_STRING = 0x1C,
OP_FLOAT = 0x1D,
OP_SIN = 0x1E,
OP_COS = 0x1F,
OP_MIN = 0x20,
OP_MAX = 0x21,
OP_MILLISECONDS = 0x22,
OP_DVARINT = 0x23,
OP_DVARBOOL = 0x24,
OP_DVARFLOAT = 0x25,
OP_DVARSTRING = 0x26,
OP_STAT = 0x27,
OP_UIACTIVE = 0x28,
OP_FLASHBANGED = 0x29,
OP_USINGVEHICLE = 0x2A,
OP_MISSILECAM = 0x2B,
OP_SCOPED = 0x2C,
OP_SCOPEDTHERMAL = 0x2D,
OP_SCOREBOARDVISIBLE = 0x2E,
OP_INKILLCAM = 0x2F,
OP_INKILLCAMNPC = 0x30,
OP_PLAYERFIELD = 0x31,
OP_GETPERK = 0x32,
OP_SELECTINGLOCATION = 0x33,
OP_SELECTINGDIRECTION = 0x34,
OP_TEAMFIELD = 0x35,
OP_OTHERTEAMFIELD = 0x36,
OP_MARINESFIELD = 0x37,
OP_OPFORFIELD = 0x38,
OP_MENUISOPEN = 0x39,
OP_WRITINGDATA = 0x3A,
OP_INLOBBY = 0x3B,
OP_INPRIVATEPARTY = 0x3C,
OP_PRIVATEPARTYHOST = 0x3D,
OP_PRIVATEPARTYHOSTINLOBBY = 0x3E,
OP_ALONEINPARTY = 0x3F,
OP_ADSJAVELIN = 0x40,
OP_WEAPLOCKBLINK = 0x41,
OP_WEAPATTACKTOP = 0x42,
OP_WEAPATTACKDIRECT = 0x43,
OP_WEAPLOCKING = 0x44,
OP_WEAPLOCKED = 0x45,
OP_WEAPLOCKTOOCLOSE = 0x46,
OP_WEAPLOCKSCREENPOSX = 0x47,
OP_WEAPLOCKSCREENPOSY = 0x48,
OP_SECONDSASTIME = 0x49,
OP_TABLELOOKUP = 0x4A,
OP_TABLELOOKUPBYROW = 0x4B,
OP_TABLEGETROWNUM = 0x4C,
OP_LOCALIZESTRING = 0x4D,
OP_LOCALVARINT = 0x4E,
OP_LOCALVARBOOL = 0x4F,
OP_LOCALVARFLOAT = 0x50,
OP_LOCALVARSTRING = 0x51,
OP_TIMELEFT = 0x52,
OP_SECONDSASCOUNTDOWN = 0x53,
OP_GAMEMSGWNDACTIVE = 0x54,
OP_GAMETYPENAME = 0x55,
OP_GAMETYPE = 0x56,
OP_GAMETYPEDESCRIPTION = 0x57,
OP_SCORE = 0x58,
OP_FRIENDSONLINE = 0x59,
OP_SPECTATINGCLIENT = 0x5A,
OP_SPECTATINGFREE = 0x5B,
OP_STATRANGEBITSSET = 0x5C,
OP_KEYBINDING = 0x5D,
OP_ACTIONSLOTUSABLE = 0x5E,
OP_HUDFADE = 0x5F,
OP_MAXRECOMMENDEDPLAYERS = 0x60,
OP_ACCEPTINGINVITE = 0x61,
OP_ISINTERMISSION = 0x62,
OP_GAMEHOST = 0x63,
OP_PARTYISMISSINGMAPPACK = 0x64,
OP_PARTYMISSINGMAPPACKERROR = 0x65,
OP_ANYNEWMAPPACKS = 0x66,
OP_AMISELECTED = 0x67,
OP_PARTYSTATUSSTRING = 0x68,
OP_ATTACHEDCONTROLLERCOUNT = 0x69,
OP_ISSPLITSCREENONLINEPOSSIBLE = 0x6A,
OP_SPLITSCREENPLAYERCOUNT = 0x6B,
OP_GETPLAYERDATA = 0x6C,
OP_GETPLAYERDATASPLITSCREEN = 0x6D,
OP_EXPERIENCEFORLEVEL = 0x6E,
OP_LEVELFOREXPERIENCE = 0x6F,
OP_ISITEMUNLOCKED = 0x70,
OP_ISITEMUNLOCKEDSPLITSCREEN = 0x71,
OP_DEBUGPRINT = 0x72,
OP_GETPLAYERDATAANYBOOLTRUE = 0x73,
OP_WEAPONCLASSNEW = 0x74,
OP_WEAPONNAME = 0x75,
OP_ISRELOADING = 0x76,
OP_SAVEGAMEAVAILABLE = 0x77,
OP_UNLOCKEDITEMCOUNT = 0x78,
OP_UNLOCKEDITEMCOUNTSPLITSCREEN = 0x79,
OP_UNLOCKEDITEM = 0x7A,
OP_UNLOCKEDITEMSPLITSCREEN = 0x7B,
OP_MAILSUBJECT = 0x7C,
OP_MAILFROM = 0x7D,
OP_MAILRECEIVED = 0x7E,
OP_MAILBODY = 0x7F,
OP_MAILLOOTLOCALIZED = 0x80,
OP_MAILGIVESLOOT = 0x81,
OP_ANYNEWMAIL = 0x82,
OP_MAILTIMETOFOLLOWUP = 0x83,
OP_MAILLOOTTYPE = 0x84,
OP_MAILRANLOTTERY = 0x85,
OP_LOTTERYLOOTLOCALIZED = 0x86,
OP_RADARISJAMMED = 0x87,
OP_RADARJAMINTENSITY = 0x88,
OP_RADARISENABLED = 0x89,
OP_ISEMPJAMMED = 0x8A,
OP_PLAYERADS = 0x8B,
OP_WEAPONHEATACTIVE = 0x8C,
OP_WEAPONHEATVALUE = 0x8D,
OP_WEAPONHEATOVERHEATED = 0x8E,
OP_GETSPLASHTEXT = 0x8F,
OP_GETSPLASHDESCRIPTION = 0x90,
OP_GETSPLASHMATERIAL = 0x91,
OP_SPLASHHASICON = 0x92,
OP_SPLASHROWNUM = 0x93,
OP_GETFOCUSEDITEMNAME = 0x94,
OP_GETFOCUSEDITEMX = 0x95,
OP_GETFOCUSEDITEMY = 0x96,
OP_GETFOCUSEDITEMWIDTH = 0x97,
OP_GETFOCUSEDITEMHEIGHT = 0x98,
OP_GETITEMX = 0x99,
OP_GETITEMY = 0x9A,
OP_GETITEMWIDTH = 0x9B,
OP_GETITEMHEIGHT = 0x9C,
OP_PLAYLIST = 0x9D,
OP_SCOREBOARDEXTERNALMUTENOTICE = 0x9E,
OP_GETCLIENTMATCHDATA = 0x9F,
OP_GETCLIENTMATCHDATADEF = 0xA0,
OP_GETMAPNAME = 0xA1,
OP_GETMAPIMAGE = 0xA2,
OP_GETMAPCUSTOM = 0xA3,
OP_GETMIGRATIONSTATUS = 0xA4,
OP_GETPLAYERCARDINFO = 0xA5,
OP_ISOFFLINEPROFILESELECTED = 0xA6,
OP_COOPPLAYER = 0xA7,
OP_ISCOOP = 0xA8,
OP_GETPARTYSTATUS = 0xA9,
OP_GETSEARCHPARAMS = 0xAA,
OP_GETTIMEPLAYED = 0xAB,
OP_ISSELECTEDPLAYERFRIEND = 0xAC,
OP_GETCHARBYINDEX = 0xAD,
OP_GETPROFILEDATA = 0xAE,
OP_ISPROFILESIGNEDIN = 0xAF,
OP_GETWAITPOPUPSTATUS = 0xB0,
OP_GETNATTYPE = 0xB1,
OP_GETLOCALIZEDNATTYPE = 0xB2,
OP_GETADJUSTEDSAFEAREAHORIZONTAL = 0xB3,
OP_GETADJUSTEDSAFEAREAVERTICAL = 0xB4,
OP_CONNECTIONINFO = 0xB5,
OP_OFFLINEPROFILECANSAVE = 0xB6,
OP_ALLSPLITSCREENPROFILESCANSAVE = 0xB7,
OP_ALLSPLITSCREENPROFILESARESIGNEDIN = 0xB8,
OP_DOWEHAVEMAPPACK = 0xB9,
};

enum expDataType
{
VAL_INT = 0x0,
VAL_FLOAT = 0x1,
VAL_STRING = 0x2,
NUM_INTERNAL_DATATYPES = 0x3,
VAL_FUNCTION = 0x3,
NUM_DATATYPES = 0x4,
};

struct Statement_s;
struct MenuEventHandlerSet;
struct ExpressionSupportingData;

struct ExpressionString
{
const char *string;
};

union operandInternalDataUnion
{
int intVal;
float floatVal;
ExpressionString *stringVal;
Statement_s *function;
};

struct Operand
{
expDataType dataType;
operandInternalDataUnion internals;
};

union entryInternalData
{
operationEnum op;
Operand operand;
};

struct SetLocalVarData
{
const char *localVarName;
Statement_s *expression;
};

struct ConditionalScript
{
MenuEventHandlerSet *eventHandlerSet;
Statement_s *eventExpression; // loads this first
};

struct expressionEntry
{
int type;
entryInternalData data;
};

struct Statement_s
{
int numEntries;
expressionEntry *entries;
ExpressionSupportingData *supportingData;
int lastExecuteTime;
Operand lastResult;
};

enum ItemFloatExpressionTarget
{
ITEM_FLOATEXP_TGT_RECT_X = 0x0,
ITEM_FLOATEXP_TGT_RECT_Y = 0x1,
ITEM_FLOATEXP_TGT_RECT_W = 0x2,
ITEM_FLOATEXP_TGT_RECT_H = 0x3,
ITEM_FLOATEXP_TGT_FORECOLOR_R = 0x4,
ITEM_FLOATEXP_TGT_FORECOLOR_G = 0x5,
ITEM_FLOATEXP_TGT_FORECOLOR_B = 0x6,
ITEM_FLOATEXP_TGT_FORECOLOR_RGB = 0x7,
ITEM_FLOATEXP_TGT_FORECOLOR_A = 0x8,
ITEM_FLOATEXP_TGT_GLOWCOLOR_R = 0x9,
ITEM_FLOATEXP_TGT_GLOWCOLOR_G = 0xA,
ITEM_FLOATEXP_TGT_GLOWCOLOR_B = 0xB,
ITEM_FLOATEXP_TGT_GLOWCOLOR_RGB = 0xC,
ITEM_FLOATEXP_TGT_GLOWCOLOR_A = 0xD,
ITEM_FLOATEXP_TGT_BACKCOLOR_R = 0xE,
ITEM_FLOATEXP_TGT_BACKCOLOR_G = 0xF,
ITEM_FLOATEXP_TGT_BACKCOLOR_B = 0x10,
ITEM_FLOATEXP_TGT_BACKCOLOR_RGB = 0x11,
ITEM_FLOATEXP_TGT_BACKCOLOR_A = 0x12,
ITEM_FLOATEXP_TGT__COUNT = 0x13,
};

struct ItemFloatExpression
{
ItemFloatExpressionTarget target;
Statement_s *expression;
};

union EventData
{
const char *unconditionalScript;
ConditionalScript *conditionalScript;
MenuEventHandlerSet *elseScript;
SetLocalVarData *setLocalVarData;
};

#pragma pack(push, 4)
struct MenuEventHandler
{
EventData eventData;
char eventType;
};
#pragma pack(pop)

struct MenuEventHandlerSet
{
int eventHandlerCount;
MenuEventHandler **eventHandlers;
};

struct ItemKeyHandler
{
int key;
MenuEventHandlerSet *action;
ItemKeyHandler *next;
};

struct newsTickerDef_s
{
int feedId; // 0 = text input, 1 = motd
int speed;
int spacing;
int lastTime;
int start;
int end;
float x;
};

#define MAX_LB_COLUMNS 16

struct columnInfo_s
{
int pos;
int width;
int maxChars;
int alignment;
};

struct listBoxDef_s
{
#ifndef PC
int startPos[4];
int endPos[4];
int drawPadding;
#else
int unknown[4];
#endif
float elementWidth;
float elementHeight;
int elementStyle;
int numColumns;
columnInfo_s columnInfo[MAX_LB_COLUMNS];
MenuEventHandlerSet *doubleClick;
int notselectable;
int noscrollbars;
int usepaging;
vec4_t selectBorder;
Material *selectIcon;
};

struct editFieldDef_s
{
float minVal;
float maxVal;
float defVal;
float range;
int maxChars;
int maxCharsGotoNext;
int maxPaintChars;
int paintOffset;
};

#define MAX_MULTI_DVARS 32

struct multiDef_s
{
char *dvarList[MAX_MULTI_DVARS];
char *dvarStr[MAX_MULTI_DVARS];
float dvarValue[MAX_MULTI_DVARS];
int count;
int strDef;
};

struct textScrollDef_s
{
int startTime;
};

union itemDefData_t
{
listBoxDef_s *listBox;
editFieldDef_s *editField;
multiDef_s *multi;
const char *enumDvarName;
newsTickerDef_s *newsTicker;
textScrollDef_s *textScroll;
void *data;
};

#define WINDOWDYNAMIC_VISIBLE 0x00000004
#define WINDOWDYNAMIC_HASFORECOLOR 0x00010000

#define WINDOWSTATIC_DECORATION 0x00100000
#define WINDOWSTATIC_HORIZONTALSCROLL 0x00200000
#define WINDOWSTATIC_SCREENSPACE 0x00400000
#define WINDOWSTATIC_AUTOWRAPPED 0x00800000
#define WINDOWSTATIC_POPUP 0x01000000
#define WINDOWSTATIC_OUTOFBOUNDSCLICK 0x02000000
#define WINDOWSTATIC_LEGACYSPLITSCREENSCALE 0x04000000
#define WINDOWSTATIC_HIDDENDURINGFLASH 0x10000000
#define WINDOWSTATIC_HIDDENDURINGSCOPE 0x20000000
#define WINDOWSTATIC_HIDDENDURINGUI 0x40000000
#define WINDOWSTATIC_TEXTONLYFOCUS 0x80000000

#pragma pack(push, 4)
struct rectDef_s
{
float x;
float y;
float w;
float h;
char horzAlign;
char vertAlign;
};
#pragma pack(pop)

typedef rectDef_s Rectangle;

struct windowDef_t
{
const char *name;
Rectangle rect;
Rectangle rectClient;
const char *group;
int style;
int border;
int ownerDraw;
int ownerDrawFlags;
float borderSize;
int staticFlags;
#ifndef PC
int dynamicFlags[4];
#else
int dynamicFlags[1];
#endif
int nextTime;
vec4_t foreColor;
vec4_t backColor;
vec4_t borderColor;
vec4_t outlineColor;
vec4_t disableColor;
Material *background;
};

typedef windowDef_t Window;

struct itemDef_s
{
Window window;
#ifndef PC
Rectangle textRect[4];
#else
Rectangle textRect[1];
#endif
int type;
int dataType;
int align;
int fontEnum;
int textAlignMode;
float textAlignX;
float textAlignY;
float textScale;
int textStyle;
int gameMsgWindowIndex;
int gameMsgWindowMode;
const char *text;
int textSaveGameInfo;
menuDef_t *parent;
MenuEventHandlerSet *mouseEnterText;
MenuEventHandlerSet *mouseExitText;
MenuEventHandlerSet *mouseEnter;
MenuEventHandlerSet *mouseExit;
MenuEventHandlerSet *action;
MenuEventHandlerSet *accept;
MenuEventHandlerSet *onFocus;
MenuEventHandlerSet *leaveFocus;
const char *dvar;
const char *dvarTest;
ItemKeyHandler *onKey;
const char *enableDvar;
int dvarFlags;
snd_alias_list_t *focusSound;
float special;
#ifndef PC
int cursorPos[4];
#else
int cursorPos[1];
#endif
itemDefData_t typeData;
int imageTrack;
int floatExpressionCount;
ItemFloatExpression *floatExpressions;
Statement_s *visibleExp;
Statement_s *disabledExp;
Statement_s *textExp;
Statement_s *materialExp;
vec4_t glowColor;
bool decayActive;
int fxBirthTime;
int fxLetterTime;
int fxDecayStartTime;
int fxDecayDuration;
int lastSoundPlayedTime;
};

struct StaticDvar
{
dvar_s *dvar;
const char *dvarName;
};

struct StaticDvarList
{
int numStaticDvars;
StaticDvar **staticDvars;
};

struct UIFunctionList
{
int totalFunctions;
Statement_s **functions;
};

struct StringList
{
int totalStrings;
const char **strings;
};

struct ExpressionSupportingData
{
UIFunctionList uifunctions;
StaticDvarList staticDvarList;
StringList uiStrings;
};

enum transitionType
{
TRANS_INACTIVE = 0x0,
TRANS_LERP = 0x1,
};

enum triggerType
{
TRIGGER_NONE = 0x0,
TRIGGER_CLOSEMENU = 0x1,
};

struct menuTransition
{
transitionType transitionType;
int startTime;
float startVal;
float endVal;
float time;
triggerType endTriggerType;
};

struct menuDef_t
{
Window window;
const char *font;
int fullscreen;
int itemCount;
int fontIndex;
#ifndef PC
int cursorItems[4];
#else
int cursorItems[1];
#endif
int fadeCycle;
float fadeClamp;
float fadeAmount;
float fadeInAmount;
float blurRadius;
MenuEventHandlerSet *onOpen;
MenuEventHandlerSet *onRequestClose;
MenuEventHandlerSet *onClose;
MenuEventHandlerSet *onEsc;
ItemKeyHandler *execKeys;
Statement_s *visibleExp;
const char *allowedBinding;
const char *soundName;
int imageTrack;
vec4_t focusColor;
Statement_s *rectXExp;
Statement_s *rectYExp;
Statement_s *rectHExp;
Statement_s *rectWExp;
#ifdef PC
Statement_s *openSoundExp;
Statement_s *closeSoundExp;
#endif
itemDef_s **items;
#ifndef PC
menuTransition scaleTransition[4];
menuTransition alphaTransition[4];
menuTransition xTransition[4];
menuTransition yTransition[4];
#else
char unknown[112];
#endif
ExpressionSupportingData *expressionData;
};
</syntaxhighlight>

Category:FastFiles

2026-06-12T02:01:44Z

Jakes625:

Category:FastFiles

2026-06-12T01:57:21Z

Jakes625: /* Stream Blocks */

Category:FastFiles

2026-06-12T01:54:19Z

Jakes625: /* Pointers in Zone Files */