← 1.20 ReplayEntropic Dev

REPLAY 1.20 · RESEARCH NOTES

The asset brain

A linked map of loading, rendering, and collision evidence.

34 notes · Latest source update

SOURCE NOTE · Updated 2026-09-28 17:15:47 UTC
On this page

Map Asset Integration

Asset brain · Asset System Overview · Engine Integration · Asset data formats · GfxWorld and Brush Models · XModels and Surfaces · SModels · Materials, Techsets, and Glass · CModels and Clipmaps · Lighting, Light Grids, and Shadows · Umbra and Culling · Transient Zones

Scope and evidence rule

This page links the current static evidence for map loading and native render/collision paths in Game-Test and Replay. For object-by-object data-format notes and explicit unknowns, see the Assets section. It is a cross-reference map, not a claim that these functions run in one observed session.

For asset layouts scoped only to the Game-Test executable, see Game-Test-only asset layouts. Use the Replay symbol-mapping guide: establish source identity, Replay target identity, and ABI/layout separately; inspect alternatives and code ownership; treat imported names and similarity scores as leads; retain q/hold status where evidence conflicts. Source PDB signatures and UDTs explain source behavior, but they do not define Replay ABI or the serialized fastfile format.

Builds: Game-Test source E:\1-game-test\1-game_test.exe SHA-256 269D6137A465DA9D5F5DF68961000D683B9A868FDE5E7800743177C05D059E99; Replay target E:\IW8\Builds\1.20-replay\game_dx12_ship_replay.exe SHA-256 68FB1CBCB2924182724004039DE55A4C50152BB6561803C4898B7930B38132F0. The Replay SQLite program MD5 is 1C238FE327F2ECC3B0DB924C5B425439, separately from the executable hash.

The integration graph, with evidence boundaries

flowchart TD
  H[Replay XAssetHeader phase dispatch] -->|Load case 0x1F| GW[Load_GfxWorldPtr / root]
  GW --> GWS[Load_GfxWorldSurfaces]
  GWS --> AL[q_AllocLoad_GfxDrawSurf]
  AL --> DSA[q_Load_GfxDrawSurfArray]
  H -->|Postload case 0x1F| PGW[q_Postload_GfxWorld root]
  PGW --> GSM[q_Postload_GfxWorldStaticModels]
  GSM --> XP[Postload_XModelPtr and helpers]
  GW --> DPVS[DPVS static/dynamic visibility data]
  ST[Load_SpatialPartition_Tree] --> U8[Load_uint8_tArray 18989]
  GWSM[Load_GfxWorldStaticModels] --> U8
  GW --> GWD[GfxWorldDraw]
  GWD -->|Load_GfxWorldTransientZone parent / save, set, call, restore| GDV[Load_GfxWorldDrawVerts 20398]
  GDVP[Replay current-object global varGfxWorldDrawVerts] -->|current DrawVerts pointer| GDV
  GDV --> GIB[Load_GfxIndexBuffer 18924]
  GIB --> LIB[Load_IndexBuffer 50660]
  GWD -->|0x600 pointer slots| TZ[GfxWorldTransientZonePtr / root]
  TZ -->|Replay type 0x20 pool/release| TR[transient-zone lifetime route]
  H -->|Load case 0x09| XM[XModelPtr / XModel roots]
  XM -->|q-candidate child| DV[q_Load_XModelDecalVolumesInfo ID 20331]
  H -->|Load case 0x08| XS[XModelSurfsPtr / Load_XModelSurfs]
  XS --> XSF[q_Load_XSurface and shared data]
  M[Mark traversal phase] --> MW[Mark_GfxWorldPtr 18268 -> root 18266 -> asset helper 24825]
  M -->|paired parent references| XMA[Mark_XModelPtrArray 20351]
  MT[Load_MaterialTechniqueSetPtr 20036] --> MTR[MaterialTechniqueSet root / asset registration]
  MG[Mark material/image/decal-mask helpers] -. no load-to-runtime join .-> R[material/image rendering]
  H -->|Load case 0x19| GL[Load_GlassWorldPtr (source case 0x15)]
  GL --> GLP[Replay glass_map pool / asset helper]
  SH[AddStaticModelSunShadow registration] -->|exact callback pointer| SHCB[q_R_AddAllStaticModelSurfacesSunShadow]
  DPVS -. visibility metadata; placement link open .-> SHCB
  SHCB -->|transformed calls| SEMIT[held children 50617 / 50614]
  UM[Umbra worker registrations] --> UI[SceneEntCamera initializer 565]
  UM --> UW1[SceneEntCamera ShouldWait 36281]
  UM --> UW2[SceneEntSunShadows ShouldWait 36282]
  UM --> UREG[shared helper / task registration]
  UREG --> UC[unresolved shared execute callback 50572]
  DPVS -. adjacent visibility context only .-> UC
  CL[Load_clipMap_t] --> CML[static-model collision records]
  CML -->|serialized child pointer routes| PA[PhysicsAssetPtr / XModelDetailCollisionPtr]
  PA -. runtime join unresolved .-> WC[WorldCollision and physics consumers]
  BV[CM_BrushModelIsValid 35229; separate bound check]
  SCL[Replay q_ScriptableCl_RunStateEventCollision 37106] -->|event model index +0x14; two checks| BV
  SSV[Replay q_ScriptableSv_RunStateEventCollision 37162] -->|event model index +0x14; two checks| BV
  SPE[Replay q_ScriptableSv_PrecacheAssetEventDef 37322] -->|collmap index +0x2C| BV
  XM -. Replay DObj render-consumer pair unresolved .-> DOBJ[Replay scene/DObj surface submission]

Solid arrows summarize reported Replay calls or table/pool relationships. Dashed arrows mark an incomplete join; they are not call edges. Dispatch values shown are local to Replay unless a source value is explicitly given below. Phase-specific Load, Preload, Postload, and Mark routes must be followed independently; this diagram does not assert one universal temporal sequence.

Verified Replay paths and source comparisons

GfxWorld root, Postload children, and Mark walk

Replay Load dispatch case 0x1F reaches the named GfxWorld pointer and root path. The paired GfxWorldDraw route walks 0x600 pointer entries at an observed eight-byte stride into transient-zone pointer/root helpers. Registration/pool and deferred-release evidence independently associates Replay type 0x20 with gfx_map_trzone (0x148 pool element) and a release callback. Game-Test uses source case/type 0x1B for GfxWorld and 0x1C for its transient-zone family; these numbers differ from Replay's and are not interchangeable.

A separate Replay Postload root path reaches q_Postload_GfxWorldStaticModels ID 20354 before GfxWorldDraw, and its body calls Postload_XModelPtr and wrapped-buffer/material helpers. The source current-object displacement +0x170 differs from Replay +0x150; neither value is portable structure evidence. The Mark walk is also separate: ID 18268 Mark_GfxWorldPtr → ID 18266 Mark_GfxWorld → ID 18265 Mark_GfxPrecomputedSkyIllumination and other children → ID 24825 Mark_GfxWorldAsset. Several root child identities remain unresolved and PDATA/SQLite size differences are preserved on the family page.

Evidence: Engine Integration, GfxWorld and Brush Models, Transient Zones, GfxWorld type-20 pool/release report, GfxWorld StaticModels Postload report, and GfxWorld Mark root/child applied report.

Replay ID 20398 Load_GfxWorldDrawVerts (RVA 0xE303E0) is called by the already named Load_GfxWorldTransientZone parent. It loads a 0xC8 root, then processes position/auxiliary buffers and BSP index-buffer data. That route calls Load_GfxIndexBuffer ID 18924 followed by the distinct resource operation Load_IndexBuffer ID 50660 (RVA 0x18D9F10). The latter's SQLite size is 91 bytes while its complete PDATA span is 132 bytes, and its target body consumes four argument registers despite a two-parameter SQLite prototype. These are Replay code-flow/extent observations; no source layout, resource ABI, or shared serialized record is inferred. See the DrawVerts review, DrawVerts applied manifest, IndexBuffer review, and IndexBuffer applied manifest.

XModel and XModelSurfs loading toward rendering

Replay XAssetHeader cases 0x09 and 0x08 lead respectively to XModel and XModelSurfs pointer/root paths. The Replay XModel roots remain q-prefixed. Under the paired XModel Load roots, Replay ID 20331 / RVA 0xE2A270 is a q-candidate for source Load_XModelDecalVolumesInfo ID 24807; it follows the paired BlendShape-info child in both builds. Its full Replay PDATA coverage is 291 bytes while SQLite exports 162 bytes. The XModelSurfs path reaches Load_XModelSurfs, then scalar q_Load_XSurface ID 20339 and separate shared-data handling. For subdivision levels, Replay ID 20342 is q_Load_XSurfaceSubdivLevelArray and traverses a counted array with target-local 0x238 steps. The source array wrapper uses source-local 0x128 steps and calls a scalar child, while the paired Replay parent calls the counted child. This is function-role evidence with changed granularity, not shared layout.

The source PDB establishes DObj/render consumer roles such as DObjGetSurfaceData, R_AddDObjSurfaces, and camera/shadow submission. The decal-volume candidate body ranks first in a global source corpus and preserves sibling call order under the XModel roots, but its nested Replay Load_MapEdgeListPtr wrapper does not uniquely identify the source decal-mask pointer child. Current Replay evidence includes Stream_UsedMesh and DObj bone helpers, but does not establish the corresponding Replay XModelSurfs-to-scene-submission edge. Keep source consumer calls distinct from Replay loader evidence until the Replay target and caller chain are independently resolved.

Evidence: decal-volume coordinator report, global scan manifest, XModel Fastfile to DObj Flow, XModels and Surfaces, XSurface scalar-loader report, XSurface subdivision-array review, and applied subdivision-array manifest.

XModel Mark pointer-array path

The separate Mark phase now has a confirmed Replay name: ID 20351 Mark_XModelPtrArray ↔ source ID 25025. Generated marker bodies and their ordered callee pattern are tied across several source types, so the decisive evidence comes from two named paired callers: Mark_ScriptableDef calls the target at matching caller offset +0xAE, and Mark_WeaponAttachment calls it at +0xC4 and +0xF2. Replay PDATA is 176 bytes while the SQLite row retains size 172; source size is 172. These are Mark/reachability edges, distinct from Load/Postload order and not proof of ABI or disk layout. See XModels and Surfaces and the coordinator report with its applied manifest.

SModel rendering callback versus map placement data

Replay callback-registration wrapper ID 442 registers string AddStaticModelSunShadow with the exact pointer to ID 50616, currently q_R_AddAllStaticModelSurfacesSunShadow; source PDB ID 87368 has the corresponding SunShadow role. The target has a transformed helper sequence and 288 bytes of chained PDATA versus a preserved 285-byte SQLite size, so q remains appropriate. Its children IDs 50617 and 50614 are held: the earlier camera-emission source candidate conflicts with Replay's registered SunShadow parent, and the other child lacks a unique source identity.

This identifies a render callback root and not the serialized SModel placement array. SModel collision records, GfxWorld DPVS visibility, callback processing, and placement/draw data remain separate concepts unless a direct parser-to-runtime edge is found.

Evidence: SModels, SModel SunShadow parent-chain review, coordinator report, and applied manifest.

Materials and techsets

Replay ID 20036 Load_MaterialTechniqueSetPtr is reached from paired Load_Material and Load_XAssetHeader parents, then calls the paired root and asset-registration helper. Replay ID 24731 Load_MaterialTechniqueSetAsset uses build-local type immediate 0x12, whose pool is named techset; Game-Test uses 0x0E. The helper identity and registration route do not prove payload schema or material-to-techset runtime dependency traversal. Mark helpers for techsets, images, and decal masks are separate reachability paths; they do not establish render-time use.

GlassWorld provides another phase example: Game-Test case 0x15 maps to Replay 0x19; source/Replay Load, Preload, and Postload wrappers reach their respective roots, with the Replay glass_map pool independently supporting family identity. These values and the 0x10 pool element size do not define serialized root layout.

Evidence: Materials, Techsets, and Glass, MaterialTechniqueSetPtr report, pointer-route manifest, and GlassWorld phase report.

ClipMap collision and native cleanup

The source and Replay Load_clipMap_t paths reach static-model collision-list/model parsing. Replay also has separate StaticModels collision-tile shape creation/destruction and transient-zone unloading helpers. DB_ReleaseClipMap calls the stored Replay WorldCollision_RemoveClipMap row, but the source symbol is overload-ambiguous and the loaded PhysicsAsset pointer has not been joined to a runtime consumer. Treat parser and teardown as distinct proven paths with a missing middle.

Evidence: CModels and Clipmaps, collision-tile shape-create report, clipMap cleanup analysis.

Cross-family Load, Postload, Mark, and consumer ledger

These routes show where reviewed map/render families meet in the binaries. A parent call proves a parser or helper edge in that build; a Mark call proves a reachability operation; registration/pool tables give asset-family context. None alone proves a single runtime execution or the fastfile schema. The mapping guide's rule applies here: verify both function owners and callers, keep alternatives, and treat source PDB layout separately from Replay memory accesses.

Asset relationship Replay-side evidence Game-Test/source comparison Unresolved boundary
GfxWorld → draw buffers Load_GfxWorldSurfaces calls ID 18147 q_AllocLoad_GfxDrawSurf, then ID 18163 q_Load_GfxDrawSurfArray; Replay array wrapper scales count by 16 and tail-jumps to Load_Stream. Paired source parent calls AllocLoad_GfxDrawSurf then Load_GfxDrawSurfArray. The array-wrapper body is generated and widespread, so parent order plus allocator adjacency anchor the q-name. These are GfxDrawSurf stream helpers; they are distinct from XModel XSurface geometry. Count scale alone is not a complete schema. See GfxWorld and Brush Models and the allocator report and array report.
GfxWorldDrawVerts current-object handoff Replay Load_GfxWorldTransientZone saves, assigns, and restores global varGfxWorldDrawVerts while calling ID 20398 Load_GfxWorldDrawVerts; the child reads the same global throughout its parser body. The paired source parent performs the same save/assign/call/restore role through source varGfxWorldDrawVerts, independently of the child body comparison. The Replay global has six indexed owners, four unnamed; Atlas provides no standalone data-symbol type. The mapping names a build-local current-object pointer role and proves no cross-build layout or type. See Assets/GfxWorld, global review, and global manifest.
GfxWorld / terrain index buffers Replay ID 18924 Load_GfxIndexBuffer is an 18-byte Load_Stream wrapper called by paired Load_StDiskTerrainSurface, Load_StMesh, and Load_GfxWorldDrawVerts parents; Replay ID 50660 Load_IndexBuffer is a distinct following resource operation at RVA 0x18D9F10. Load_GfxWorldDrawVerts is ID 20398 at RVA 0xE303E0. The source names and paired callers are provenance for function identity; source's 8-byte immediate differs from Replay's 0x20 and is not a transferred format value. Source Array/Stream callers are unmatched in the Replay index. Load_IndexBuffer Replay SQLite size is 91 vs complete PDATA 132 bytes; exported prototype has two args while its body consumes four registers. No resource ABI/layout is claimed. See Assets/GfxWorld, Assets/SModel, and DrawVerts review, DrawVerts manifest, IndexBuffer report, and IndexBuffer manifest.
Spatial/static-model byte arrays Replay ID 18989 Load_uint8_tArray is called by paired Load_SpatialPartition_Tree and Load_GfxWorldStaticModels parents; in the latter, a later Load_byteArray is a separate helper/global. Both builds pass the count from their own current-object +0x10, and the 15-byte helpers tail-call their own Load_Stream; source and Replay global RVAs differ. This names a byte-array helper only. The +0x10 count role and stream globals are build-local; no shared field meaning or layout is inferred. See GfxWorld and Brush Models and SModels. Report, manifest, applied CSV.
GfxWorld → world models and lighting/visibility The paired Postload GfxWorld roots reach q-prefixed StaticModels and DPVS children; StaticModels body reaches Postload_XModelPtr. Load GfxWorld also sequences the light-AABB child before DPVS static. Source PDB roots show corresponding ordered children; source current-object displacement +0x170 differs from Replay +0x150 for StaticModels. DPVS has paired source-member/Replay access observations. Root child names, offsets, sizes, and serialized record layout remain per-build; see GfxWorld and Brush Models and Lighting, Light Grids, and Shadows. Reports: StaticModels Postload, DPVS access manifest.
XModel → XModelSurfs / XSurface XAssetHeader Load cases 0x09 and 0x08 reach the separate XModel and XModelSurfs pointer/root paths; Load_XModelSurfs calls q_Load_XSurface in its count-controlled loop, plus shared-data helpers. Paired source roots confirm the function roles, but source XModel UDT size differs from Replay root stream use; source and Replay XSurface loop step is an observed 0xC0 in its respective code. Subdivision path differs: source array wrapper uses 0x128 and calls scalar child; Replay q-array child uses 0x238. No shared ABI or serialized stride. Replay XSurface caller census remains incomplete, and the Replay DObj render-submission edge is unresolved. See XModels and Surfaces and XModel Fastfile to DObj Flow.
XModel references → Mark_XModelPtrArray Replay ID 20351 is Mark_XModelPtrArray. It is called by paired Mark_ScriptableDef at +0xAE and paired Mark_WeaponAttachment twice at +0xC4 and +0xF2. Source ID 25025 has generated-body ties with Mark_XModelPtr and Mark_GfxStaticModelArray; body rank alone is not unique. Independent paired named caller contexts identify the typed array. Mark/reachability is separate from Load/Postload and does not establish XModel array schema. Replay PDATA 176 B vs SQLite size 172 B; source size 172 B. See XModels and Surfaces and the applied report/manifest.
SModels ↔ GfxWorld visibility and render callback GfxWorld DPVS static contains visibility data for SModels/surfaces; separately, Replay callback registration string AddStaticModelSunShadow passes exact pointer ID 50616 to q_R_AddAllStaticModelSurfacesSunShadow. The registered callback role matches source R_AddAllStaticModelSurfacesSunShadow ID 87368. The callback does not identify placement records; held children 50617/50614 and complete Replay SModel placement remain open. DPVS visibility, collision tiles, and render placement must remain separate. See SModels and the callback-chain review.
Materials / images / decal masks Replay has a paired Load pointer/root/asset route for MaterialTechniqueSet; separate Mark leaves identify MaterialTechniqueSetAsset, GfxImageAsset, and GfxDecalVolumeMask helpers. ID 20397 q_Load_GfxImageRawGpuTempArray is a separate provisional raw-data child under Load_GfxLightGridVolumeAtlasDataTemp. Source PDB parents and helper identities are documented individually; source and Replay dispatch immediates differ, including MaterialTechniqueSet 0x0E/0x12, GfxImage 0x0F/0x13, and decal mask 0x6C/0x70. Load and Mark edges establish separate parser/reachability roles, not the runtime material-to-techset selection chain or GfxImage payload ABI. See Materials, Techsets, and Glass, Assets/GfxImage, and GfxWorld and Brush Models.
GlassWorld Replay Load/Preload/Postload wrappers reach GlassWorld roots; the Replay pool row names type 0x19 glass_map with element size 0x10. Source dispatch case is 0x15; Replay case/type is 0x19. Each wrapper/root pair is tied to the appropriate phase. Type ordinals and pool size do not transfer to disk layout. A paired Mark wrapper reaches Replay ID 18308 Mark_WeaponVFXPackageDefs; although source Mark_GlassWorld calls Mark_G_GlassData, the source child is only 169 bytes and walks glass-name strings, while the Replay target is 916 bytes and has a full-body WeaponVFX match. Keep the live target name; wrapper-child ordinal alone does not resolve the discrepancy. See Materials, Techsets, and Glass, the pointer-phase report, and the paired Mark conflict review.
Umbra / culling Replay has q_s_workerCmdUmbraCullGlass_Init; s_workerCmdUmbraCullSceneEntCamera_Init ID 565 at RVA 0x345430; WorkerCmdUmbraCullSceneEntCamera::ShouldWait ID 36281 at RVA 0x12CD030; and WorkerCmdUmbraCullSceneEntSunShadows::ShouldWait ID 36282 at RVA 0x12CD040. Shared execute callback ID 50572 remains unresolved. Exact source initializers/leaf roles support names only; task immediates differ by build (source 0x15, Replay 0x13). No Umbra asset root, serialized format, or culling implementation is identified. Worker initializer/wait-predicate names do not prove a data layout or algorithm; DPVS remains adjacent context only. See Assets/WorldCulling, callback reconciliation, applied manifest, and applied CSV.
ClipMap collision/model assets Load_clipMap_t reaches q-prefixed static-model collision list/model parsers; those routes read PhysicsAsset and XModel detail-collision pointers. Separately, DB_ReleaseClipMap calls the stored WorldCollision cleanup row, and StaticModels has collision-tile shape lifecycle helpers. Source PDB call tree supports the parser children; source/Replay cleanup and shape functions have separate paired-parent evidence. No direct edge joins parsed PhysicsAsset records to runtime WorldCollision/CollisionTile consumers. The cleanup name remains overload-sensitive; no common CollisionTile/clipMap ABI is inferred. See CModels and Clipmaps and the collision evidence manifest.
Brush-model validity bound Replay ID 35229 CM_BrushModelIsValid at RVA 0x12959E0 is a complete 17-byte leaf; it compares its input against a 32-bit count at Replay global-relative +0x158. Replay CM_GetBrushModelCount reads that per-build value. Exact Game-Test PDB identity and matching leaf body support the function name; source global address is distinct and not transferred. +0x158 is a per-build access observation, not a portable field or CModel layout. See Assets/CModel, validity review, and applied manifest.
Scriptable collision events → brush-model bound Client RunState collision ID 37106 and server q_ScriptableSv_RunStateEventCollision ID 37162 each make two Replay validity checks using the event model index at +0x14. The separate server event-precache handler ID 37322 passes an index at +0x2C to the same leaf. Paired source handlers support client and server collision roles; the server source body has three validity/getter routes while Replay has two, so ID 37162 keeps q_. The precache handler has its own event-definition traversal and is not the collision handler. These caller observations do not establish Scriptable record layout or serialization. The +0x14 and +0x2C offsets are Replay-local; preserve the third-source-branch discrepancy and the q-prefix. See Assets/CModel, server collision adjudication, guarded name manifest, caller audit, and extent audit.

How to use this for ZoneTool work

  • Implement only per-build behavior supported by Replay-side reads, stream phases, pointer fixups, counts, and registration arguments; keep source PDB structure data as a separate hypothesis/evidence layer.
  • Keep Load, Preload, Postload, and Mark operations distinct. A Mark root can corroborate references but does not specify load order or serialization.
  • Preserve q labels, prototype, SQLite size, and recorded PDATA/chunk extent independently. Do not “fix” target function metadata to match a source function's size.
  • Treat pool element size, current-object offsets, observed pointer increments, and dispatcher cases as build-local facts. None alone establishes the on-disk asset stride or ABI.
  • Do not claim that static edges prove a live map loaded, materials were selected, models rendered, or collision ran. Those require target runtime validation.