Graphics Map Asset (MW2): Difference between revisions

From COD Engine Research
← Older edit
No edit summary
Jakes625 (talk | contribs)
confirmed
63 edits
 
(3 intermediate revisions by the same user not shown)
Line 3: Line 3:
[[Category:MW2]]
[[Category:MW2]]
The graphics map (or gfx_map) has existed on every Call of Duty so far and is part of the D3DBSP system produced by Radiant. Where the [[:Collision Map Asset (MW2)|collision map]] is used for collision data in the map, the graphics map holds visual systems such as lights and particularly the dPVS system. The Dynamic Potentially Visible Sets (dPVS) were developed by Umbra Software to compute visibility databases in real time, and power the Call of Duty engine to this day.
The graphics map (or gfx_map) has existed on every Call of Duty so far and is part of the D3DBSP system produced by Radiant. Where the [[:Collision Map Asset (MW2)|collision map]] is used for collision data in the map, the graphics map holds visual systems such as lights and particularly the dPVS system. The Dynamic Potentially Visible Sets (dPVS) were developed by Umbra Software to compute visibility databases in real time, and power the Call of Duty engine to this day.
<syntaxhighlight lang="cpp">
struct XModelDrawInfo
{
  unsigned __int16 lod;
  unsigned __int16 surfId;
};


struct GfxSceneDynModel
=== Rendering ===
{
[[MW2_Rendering|Rendering]]
  XModelDrawInfo info;
  unsigned __int16 dynEntId;
};


struct BModelDrawInfo
=== Structures ===
{
<syntaxhighlight lang="cpp">
  unsigned __int16 surfId;
#pragma pack(push, 4)
};


struct GfxSceneDynBrush
typedef struct GfxImage GfxImage;
{
typedef struct Material Material;
  BModelDrawInfo info;
typedef struct XModel XModel;
  unsigned __int16 dynEntId;
};


struct GfxStreamingAabbTree
typedef struct DpvsPlane
{
{
  unsigned __int16 firstItem;
    float normal[3];
  unsigned __int16 itemCount;
    float dist;
  unsigned __int16 firstChild;
    uint8_t type;
  unsigned __int16 childCount;
    uint8_t signbits;
  float mins[3];
    uint16_t pad12;
  float maxs[3];
} DpvsPlane; // 0x14
};


struct GfxWorldStreamInfo
typedef struct GfxWorldDpvsPlanes
{
{
  int aabbTreeCount;
    int32_t cellCount;
  GfxStreamingAabbTree *aabbTrees;
    DpvsPlane *planes;
  int leafRefCount;
    uint16_t *nodes;
  int *leafRefs;
    uint32_t *sceneEntCellBits;
};
} GfxWorldDpvsPlanes; // 0x10


union GfxColor
typedef struct GfxSky
{
{
  unsigned int packed;
    int32_t skySurfCount;
  char array[4];
    int32_t *skyStartSurfs;
};
    GfxImage *skyImage;
    int32_t skySamplerState;
} GfxSky; // 0x10


union PackedUnitVec
typedef struct GfxCellTreeCount
{
{
  unsigned int packed;
    uint32_t aabbTreeCount;
};
} GfxCellTreeCount; // 0x04


struct GfxWorldVertex
typedef struct GfxAabbTree
{
{
  float xyz[3];
    float mins[3];
  float binormalSign;
    float maxs[3];
  GfxColor color;
    uint16_t childCount;
  float texCoord[2];
    uint16_t surfaceCount;
  float lmapCoord[2];
    uint16_t startSurfIndex;
  PackedUnitVec normal;
    uint16_t smodelIndexCount;
  PackedUnitVec tangent;
    uint16_t *smodelIndexes;
};
    int32_t childrenOffset;
} GfxAabbTree; // 0x28


struct GfxWorldVertexData
typedef struct GfxCellTree
{
{
  GfxWorldVertex *vertices;
    GfxAabbTree *aabbTrees;
  D3DVertexBuffer worldVb;
} GfxCellTree; // 0x04
};


struct GfxLight
typedef struct GfxPortalVertex
{
{
  char type;
    float xyz[3];
  char canUseShadowMap;
} GfxPortalVertex; // 0x0C
  char unused[2];
  float color[3];
  float dir[3];
  float origin[3];
  float radius;
  float cosHalfFovOuter;
  float cosHalfFovInner;
  int exponent;
  unsigned int spotShadowIndex;
  GfxLightDef *def;
};


struct GfxReflectionProbe
typedef struct GfxPortal
{
{
  float offset[3];
    uint8_t isQueued;
};
    uint8_t isAncestor;
    uint8_t recursionDepth;
    uint8_t hullPointCount;
    int32_t hullPointsRuntimePointer;
    DpvsPlane plane;
    GfxPortalVertex *vertices;
    uint8_t unknown20To21[2];
    uint8_t vertexCount;
    uint8_t pad23;
    float hullAxis[2][3];
} GfxPortal; // 0x3C


struct GfxWorldDpvsPlanes
typedef struct GfxCell
{
{
  int cellCount;
    float mins[3];
  cplane_s *planes;
    float maxs[3];
  unsigned __int16 *nodes;
    int32_t portalCount;
  unsigned int *sceneEntCellBits; //Size = cellCount << 11
    GfxPortal *portals;
};
    uint8_t reflectionProbeCount;
    uint8_t pad21[3];
    uint8_t *reflectionProbes;
} GfxCell; // 0x28


struct GfxAabbTree
typedef struct GfxReflectionProbe
{
{
  float mins[3];
    float offset[3];
  float maxs[3];
} GfxReflectionProbe; // 0x0C
  unsigned __int16 childCount;
  unsigned __int16 surfaceCount;
  unsigned __int16 startSurfIndex;
  unsigned __int16 smodelIndexCount;
  unsigned __int16 *smodelIndexes;
  int childrenOffset;
};


struct GfxLightGridEntry
typedef struct GfxTexture
{
{
  unsigned __int16 colorsIndex;
    uint32_t words[6];
  char primaryLightIndex;
} GfxTexture; // 0x18
  char needsTrace;
};


struct GfxLightGridColors
typedef struct GfxLightmapArray
{
{
  char rgb[56][3];
    GfxImage *primary;
};
    GfxImage *secondary;
} GfxLightmapArray; // 0x08


struct GfxStaticModelInst
typedef struct GfxWorldVertexData
{
{
  float mins[3];
    uint8_t *vertices;
  float maxs[3];
    int32_t worldVbHandle;
  GfxColor groundLighting;
    int32_t worldVbOffset;
};
} GfxWorldVertexData; // 0x0C


struct srfTriangles_t
typedef struct GfxWorldVertexLayerData
{
{
  int vertexLayerData;
    uint8_t *data;
  int firstVertex;
    int32_t layerVbHandle;
  unsigned __int16 vertexCount;
    int32_t layerVbOffset;
  unsigned __int16 triCount;
} GfxWorldVertexLayerData; // 0x0C
  int baseIndex;
};


struct GfxSurface
typedef struct GfxWorldDraw
{
{
  srfTriangles_t tris;
    uint32_t reflectionProbeCount;
  Material *material;
    GfxImage **reflectionImages;
  char lightmapIndex;
    GfxReflectionProbe *reflectionProbes;
  char reflectionProbeIndex;
    GfxTexture *reflectionProbeTextures;
  char primaryLightIndex;
    int32_t lightmapCount;
  bool castsSunShadow;
    GfxLightmapArray *lightmaps;
};
    GfxTexture *lightmapPrimaryTextures;
    GfxTexture *lightmapSecondaryTextures;
    GfxImage *skyImage;
    GfxImage *outdoorImage;
    uint32_t vertexCount;
    GfxWorldVertexData vd;
    uint32_t vertexLayerDataSize;
    GfxWorldVertexLayerData vld;
    int32_t indexCount;
    uint16_t *indices;
    int32_t indexBufferRaw;
} GfxWorldDraw; // 0x54


struct GfxCullGroup
typedef struct GfxLightGridEntry
{
{
  float mins[3];
    uint16_t colorsIndex;
  float maxs[3];
    uint8_t primaryLightIndex;
  int surfaceCount;
    uint8_t needsTrace;
  int startSurfIndex;
} GfxLightGridEntry; // 0x04
};


struct GfxDrawSurfFields
typedef struct GfxLightGridColors
{
{
  __int64 _bf0;
    uint8_t rgb[56][3];
};
} GfxLightGridColors; // 0xA8


union GfxDrawSurf
typedef struct GfxLightGrid
{
{
  GfxDrawSurfFields fields;
    uint32_t hasLightRegions;
  unsigned __int64 packed;
    uint32_t sunPrimaryLightIndex;
};
    uint16_t mins[3];
    uint16_t maxs[3];
    uint32_t rowAxis;
    uint32_t colAxis;
    uint16_t *rowDataStart;
    uint32_t rawRowDataSize;
    uint8_t *rawRowData;
    uint32_t entryCount;
    GfxLightGridEntry *entries;
    uint32_t colorCount;
    GfxLightGridColors *colors;
} GfxLightGrid; // 0x38


struct GfxWorldDpvsStatic
typedef struct GfxBrushModel
{
{
  unsigned int smodelCount;
    float writableMins[3];
  unsigned int staticSurfaceCount;
    float writableMaxs[3];
  unsigned int litSurfsBegin;
    float boundsMins[3];
  unsigned int litSurfsEnd;
    float boundsMaxs[3];
  char unknown1[0x20];
    uint32_t surfaceCount;
  char *smodelVisData[3];
    uint32_t startSurfIndex;
  char *surfaceVisData[3];
} GfxBrushModel; // 0x38
  unsigned __int16 *sortedSurfIndex;
  GfxStaticModelInst *smodelInsts;
  GfxSurface *surfaces;
  GfxCullGroup *cullGroups;
  GfxStaticModelDrawInst *smodelDrawInsts;
  GfxDrawSurf *surfaceMaterials;
  unsigned int *surfaceCastsSunShadow;
  volatile int usageCount;
};


#pragma pack(push, 4)
typedef struct MaterialMemory
struct GfxPackedPlacement
{
{
  float origin[3];
    Material *material;
  PackedUnitVec axis[3];
    int32_t memory;
  float scale;
} MaterialMemory; // 0x08
};


struct GfxStaticModelDrawInst
typedef struct Sunflare
{
{
  GfxPackedPlacement placement;
    uint32_t hasValidData;
  XModel *model;
    Material *spriteMaterial;
  float cullDist;
    Material *flareMaterial;
  char reflectionProbeIndex;
    float spriteSize;
  char primaryLightIndex;
    float flareMinSize;
  unsigned __int16 lightingHandle;
    float flareMinDot;
  char flags;
    float flareMaxSize;
};
    float flareMaxDot;
    float flareMaxAlpha;
    int32_t flareFadeInTime;
    int32_t flareFadeOutTime;
    float blindMinDot;
    float blindMaxDot;
    float blindMaxDarken;
    int32_t blindFadeInTime;
    int32_t blindFadeOutTime;
    float glareMinDot;
    float glareMaxDot;
    float glareMaxLighten;
    int32_t glareFadeInTime;
    int32_t glareFadeOutTime;
    float sunFxPosition[3];
} Sunflare; // 0x60


struct cplane_s
typedef struct GfxSceneDynModel
{
{
  float normal[3];
    uint16_t lod;
  float dist;
    uint16_t surfId;
  char type;
    uint16_t dynEntId;
  char signbits;
} GfxSceneDynModel; // 0x06
};


struct GfxPortalWritable
typedef struct GfxSceneDynBrush
{
{
  bool isQueued;
    uint16_t surfId;
  bool isAncestor;
    uint16_t dynEntId;
  char recursionDepth;
} GfxSceneDynBrush; // 0x04
  char hullPointCount;
  float (*hullPoints)[2];
};


struct DpvsPlane
typedef struct GfxShadowGeometry
{
{
  float coeffs[4];
    uint16_t surfaceCount;
  char side[3];
    uint16_t smodelCount;
};
    uint16_t *sortedSurfIndex;
    uint16_t *smodelIndex;
} GfxShadowGeometry; // 0x0C


struct GfxPortal
typedef struct GfxLightRegionAxis
{
{
  GfxPortalWritable writable;
    float dir[3];
  DpvsPlane plane;
    float midPoint;
  float (*vertices)[3];
    float halfSize;
      char unknown[2];
} GfxLightRegionAxis; // 0x14
  char vertexCount;
  float hullAxis[2][3];
};


struct GfxCell
typedef struct GfxLightRegionHull
{
{
  float mins[3];
    float kdopMidPoint[9];
  float maxs[3];
    float kdopHalfSize[9];
  int portalCount;
    uint32_t axisCount;
  GfxPortal *portals;
    GfxLightRegionAxis *axis;
  char reflectionProbeCount;
} GfxLightRegionHull; // 0x50
  char *reflectionProbes;
};


struct GfxLightmapArray
typedef struct GfxLightRegion
{
{
  GfxImage *primary;
    int32_t hullCount;
  GfxImage *secondary;
    GfxLightRegionHull *hulls;
};
} GfxLightRegion; // 0x08


struct GfxLightGrid
typedef struct GfxPackedPlacement
{
{
  bool hasLightRegions;
    float origin[3];
  unsigned int sunPrimaryLightIndex;
    uint32_t packedAxis[3];
  unsigned __int16 mins[3];
    float scale;
  unsigned __int16 maxs[3];
} GfxPackedPlacement; // 0x1C
  unsigned int rowAxis;
  unsigned int colAxis;
  unsigned __int16 *rowDataStart;
  unsigned int rawRowDataSize;
  char *rawRowData;
  unsigned int entryCount;
  GfxLightGridEntry *entries;
  unsigned int colorCount;
  GfxLightGridColors *colors;
};


struct GfxBrushModelWritable
typedef struct GfxStaticModelInst
{
{
  float mins[3];
    float mins[3];
  float maxs[3];
    float maxs[3];
};
    uint32_t groundLighting;
    uint8_t unknown1CTo23[8];
} GfxStaticModelInst; // 0x24


struct GfxBrushModel
typedef struct SrfTriangles
{
{
  GfxBrushModelWritable writable;
    int32_t vertexLayerData;
  float bounds[2][3];
    int32_t baseVertex;
  unsigned int surfaceCount;
    uint32_t minVertexIndex;
  unsigned int startSurfIndex;
    uint16_t vertexCount;
};
    uint16_t triCount;
    int32_t baseIndex;
} SrfTriangles; // 0x14


struct MaterialMemory
typedef struct GfxSurface
{
{
  Material *material;
    SrfTriangles tris;
  int memory;
    Material *material;
};
    uint8_t lightmapIndex;
    uint8_t reflectionProbeIndex;
    uint8_t primaryLightIndex;
    uint8_t castsSunShadow;
} GfxSurface; // 0x1C


struct sunflare_t
typedef union GfxMapDrawSurf
{
{
  bool hasValidData;
    uint64_t packed;
  Material *spriteMaterial;
} GfxMapDrawSurf; // 0x08
  Material *flareMaterial;
  float spriteSize;
  float flareMinSize;
  float flareMinDot;
  float flareMaxSize;
  float flareMaxDot;
  float flareMaxAlpha;
  int flareFadeInTime;
  int flareFadeOutTime;
  float blindMinDot;
  float blindMaxDot;
  float blindMaxDarken;
  int blindFadeInTime;
  int blindFadeOutTime;
  float glareMinDot;
  float glareMaxDot;
  float glareMaxLighten;
  int glareFadeInTime;
  int glareFadeOutTime;
  float sunFxPosition[3];
};


struct GfxShadowGeometry
typedef struct GfxCullGroup
{
{
  unsigned __int16 surfaceCount;
    float mins[3];
  unsigned __int16 smodelCount;
    float maxs[3];
  unsigned __int16 *sortedSurfIndex;
    int32_t surfaceCount;
  unsigned __int16 *smodelIndex;
    int32_t startSurfIndex;
};
} GfxCullGroup; // 0x20


struct GfxLightRegionAxis
typedef struct GfxStaticModelDrawInst
{
{
  float dir[3];
    GfxPackedPlacement placement;
  float midPoint;
    XModel *model;
  float halfSize;
    uint16_t cullDist;
};
    uint16_t lightingHandle;
    uint8_t reflectionProbeIndex;
    uint8_t primaryLightIndex;
    uint8_t flags;
    uint8_t firstMaterialSkinIndex;
    uint8_t unknown28;
    uint8_t unknown29;
    uint8_t unknown2A;
    uint8_t unknown2B;
} GfxStaticModelDrawInst; // 0x2C


struct GfxLightRegionHull
typedef struct GfxWorldDpvsStatic
{
{
  float kdopMidPoint[9];
    uint32_t smodelCount;
  float kdopHalfSize[9];
    uint32_t staticSurfaceCount;
  unsigned int axisCount;
    uint32_t litSurfsBegin;
  GfxLightRegionAxis *axis;
    uint32_t litSurfsEnd;
};
    uint32_t visibilityCounts[8];
    uint32_t *smodelVisData[3];
    uint32_t *surfaceVisData[3];
    uint16_t *sortedSurfIndex;
    GfxStaticModelInst *smodelInsts;
    GfxSurface *surfaces;
    GfxCullGroup *cullGroups;
    GfxStaticModelDrawInst *smodelDrawInsts;
    GfxMapDrawSurf *surfaceMaterials;
    uint32_t *surfaceCastsSunShadow;
    volatile uint32_t usageCount;
} GfxWorldDpvsStatic; // 0x68


struct GfxLightRegion
typedef struct GfxWorldDpvsDynamic
{
{
  unsigned int hullCount;
    uint32_t dynEntClientWordCount[2];
  GfxLightRegionHull *hulls;
    uint32_t dynEntClientCount[2];
};
    uint32_t *dynEntCellBits[2];
    uint8_t *dynEntVisData[6];
} GfxWorldDpvsDynamic; // 0x30


struct GfxWorldDpvsDynamic
typedef struct GfxHeroOnlyLight
{
{
  unsigned int dynEntClientWordCount[2];
    uint8_t bytes[0x38];
  unsigned int dynEntClientCount[2];
} GfxHeroOnlyLight; // 0x38
  unsigned int *dynEntCellBits[2];
  char *dynEntVisData[2][3];
};


struct SunLightParseParams
typedef struct GfxWorld
{
{
  char name[64];
    const char *name;
  float ambientScale;
    const char *baseName;
  float ambientColor[3];
    int32_t planeCount;
  float diffuseFraction;
    int32_t nodeCount;
  float sunLight;
    int32_t surfaceCount;
  float sunColor[3];
    uint32_t skyCount;
  float diffuseColor[3];
    GfxSky *skies;
  bool diffuseColorHasBeenSet;
    int32_t primaryLightFirstShadowable;
  float angles[3];
    int32_t primaryLightCount;
};
    int32_t sortKeyLitDecal;
    int32_t sortKeyEffectDecal;
    int32_t sortKeyEffectAuto;
    int32_t sortKeyDistortion;
    GfxWorldDpvsPlanes dpvsPlanes;
    GfxCellTreeCount *cellTreeCounts;
    GfxCellTree *cellTrees;
    GfxCell *cells;
    GfxWorldDraw worldDraw;
    GfxLightGrid lightGrid;
    int32_t modelCount;
    GfxBrushModel *models;
    float mins[3];
    float maxs[3];
    uint32_t checksum;
    int32_t materialMemoryCount;
    MaterialMemory *materialMemory;
    Sunflare sun;
    float outdoorLookupMatrix[16];
    GfxImage *outdoorImage;
    uint32_t *cellCasterBits;
    uint32_t *cellCasterBits2;
    GfxSceneDynModel *sceneDynModel;
    GfxSceneDynBrush *sceneDynBrush;
    uint32_t *primaryLightEntityShadowVis;
    uint32_t *primaryLightDynEntShadowVis[2];
    uint8_t *primaryLightForModelDynEnt;
    GfxShadowGeometry *shadowGeom;
    GfxLightRegion *lightRegion;
    GfxWorldDpvsStatic dpvs;
    GfxWorldDpvsDynamic dpvsDyn;
    uint32_t unknown26C;
    uint32_t heroOnlyLightCount;
    GfxHeroOnlyLight *heroOnlyLights;
    uint32_t unknown278;
    int32_t umbraGateCount;
    uint8_t *umbraGateData;
    uint8_t *umbraGateData2;
} GfxWorld; // 0x288 on PS3/32-bit


struct GfxWorldVertexLayerData
#pragma pack(pop)
{
</syntaxhighlight>
  char *data;
  D3DVertexBuffer layerVb;
};


typedef char GfxTexture[0x34];
==== Notes ====
<syntaxhighlight lang="C">
// sceneEntCellBits count = cellCount << 9 uint32_t values.
// rowDataStart count = maxs[rowAxis] - mins[rowAxis] + 1 uint16_t values.
// vertices payload size = vertexCount * 0x10 bytes.
// vertexLayerData payload size = vertexLayerDataSize bytes.
// cellCasterBits count = cellCount * ((cellCount + 31) >> 5) uint32_t values.
// cellCasterBits2 count = ((cellCount + 31) >> 5) uint32_t values.
// sceneDynModel count = dpvsDyn.dynEntClientCount[0].
// sceneDynBrush count = dpvsDyn.dynEntClientCount[1].
// primaryLightEntityShadowVis count = max(0, primaryLightCount - primaryLightFirstShadowable - 1) * 0x2000 uint32_t values.
// primaryLightDynEntShadowVis[0] count = same shadowable tail * sceneDynModel count.
// primaryLightDynEntShadowVis[1] count = same shadowable tail * sceneDynBrush count.
// primaryLightForModelDynEnt count = sceneDynModel count bytes.
// dpvs.smodelVisData[i] count = dpvs.visibilityCounts[6] uint32_t values.
// dpvs.surfaceVisData[i] count = dpvs.visibilityCounts[7] uint32_t values.
// dpvs.sortedSurfIndex count = dpvs.staticSurfaceCount uint16_t values.
// dpvs.smodelInsts and dpvs.smodelDrawInsts count = dpvs.smodelCount.
// dpvs.surfaces, dpvs.cullGroups, and dpvs.surfaceMaterials count = surfaceCount.
// dpvs.surfaceCastsSunShadow count = dpvs.visibilityCounts[7] uint32_t values.
// dpvsDyn.dynEntCellBits[i] count = dynEntClientWordCount[i] * dpvsPlanes.cellCount uint32_t values.
// dpvsDyn.dynEntVisData load order is [0, 3, 1, 4, 2, 5].
// dpvsDyn.dynEntVisData[0..2] byte size = dynEntClientWordCount[0] << 5.
// dpvsDyn.dynEntVisData[3..5] byte size = dynEntClientWordCount[1] << 5.
// heroOnlyLights count = heroOnlyLightCount, stride 0x38.
// umbraGateData and umbraGateData2 byte size = umbraGateCount + 0x1000.
</syntaxhighlight>


struct GfxWorldDraw
{
  unsigned int reflectionProbeCount;
  GfxImage * * reflectionImages;
  GfxReflectionProbe *reflectionProbes;
  GfxTexture * reflectionProbeTextures; //Count = refelctionProbeCount
  int lightmapCount;
  GfxLightmapArray *lightmaps;
  GfxTexture * lightmapPrimaryTextures; //Count = lightmapCount
  GfxTexture * lightmapSecondaryTextures; //Count = lightmapCount
  GfxImage *skyImage;
  GfxImage *outdoorImage;
  unsigned int vertexCount;
  GfxWorldVertexData vd;
  unsigned int vertexLayerDataSize;
  GfxWorldVertexLayerData vld;
  int indexCount;
  unsigned __int16 *indices;
  D3DIndexBuffer indexBuffer;
};
struct unknownGfxWorldStruct2
{
  int unknownCount;
  int * unknownArray;
  GfxImage * unknownImage;
  int unknown;
};
struct GfxWorld
{
  const char *name;
  const char *baseName;
  int planeCount;
  int nodeCount;
      int unknown2;
      unsigned int unknownCount1;
      unknownGfxWorldStruct2 * unknownStructs1; //Count = unknownCount1;
      char unknown1[0x18];
  GfxWorldDpvsPlanes dpvsPlanes; //The following rely on the count in this
      char *unknown4;
  GfxAabbTree *aabbTree;
  GfxCell *cells;
  GfxWorldDraw worldDraw;
  GfxLightGrid lightGrid;
  int modelCount;
  GfxBrushModel *models;
  float mins[3];
  float maxs[3];
  unsigned int checksum;
  int materialMemoryCount;
  MaterialMemory *materialMemory;
  sunflare_t sun;
  unsigned int *cellCasterBits[2];
  GfxSceneDynModel *sceneDynModel;
  GfxSceneDynBrush *sceneDynBrush;
  unsigned int *primaryLightEntityShadowVis;
  unsigned int *primaryLightDynEntShadowVis[2];
  char *primaryLightForModelDynEnt;
  GfxShadowGeometry *shadowGeom;
  GfxLightRegion *lightRegion;
  GfxWorldDpvsStatic dpvs;
  GfxWorldDpvsDynamic dpvsDyn;
      unsigned int unknownCount2;
      char * unknown2; //Size = unknownCount2 * 0x38
      int unknown3;
};
#pragma pack(pop)
</syntaxhighlight>
Keep in mind that the checksum is checked on other clients using the mapcrc dvar.
Keep in mind that the checksum is checked on other clients using the mapcrc dvar.

Latest revision as of 22:25, 5 July 2026

The graphics map (or gfx_map) has existed on every Call of Duty so far and is part of the D3DBSP system produced by Radiant. Where the collision map is used for collision data in the map, the graphics map holds visual systems such as lights and particularly the dPVS system. The Dynamic Potentially Visible Sets (dPVS) were developed by Umbra Software to compute visibility databases in real time, and power the Call of Duty engine to this day.

Rendering

Rendering

Structures

#pragma pack(push, 4)

typedef struct GfxImage GfxImage;
typedef struct Material Material;
typedef struct XModel XModel;

typedef struct DpvsPlane
{
    float normal[3];
    float dist;
    uint8_t type;
    uint8_t signbits;
    uint16_t pad12;
} DpvsPlane; // 0x14

typedef struct GfxWorldDpvsPlanes
{
    int32_t cellCount;
    DpvsPlane *planes;
    uint16_t *nodes;
    uint32_t *sceneEntCellBits;
} GfxWorldDpvsPlanes; // 0x10

typedef struct GfxSky
{
    int32_t skySurfCount;
    int32_t *skyStartSurfs;
    GfxImage *skyImage;
    int32_t skySamplerState;
} GfxSky; // 0x10

typedef struct GfxCellTreeCount
{
    uint32_t aabbTreeCount;
} GfxCellTreeCount; // 0x04

typedef struct GfxAabbTree
{
    float mins[3];
    float maxs[3];
    uint16_t childCount;
    uint16_t surfaceCount;
    uint16_t startSurfIndex;
    uint16_t smodelIndexCount;
    uint16_t *smodelIndexes;
    int32_t childrenOffset;
} GfxAabbTree; // 0x28

typedef struct GfxCellTree
{
    GfxAabbTree *aabbTrees;
} GfxCellTree; // 0x04

typedef struct GfxPortalVertex
{
    float xyz[3];
} GfxPortalVertex; // 0x0C

typedef struct GfxPortal
{
    uint8_t isQueued;
    uint8_t isAncestor;
    uint8_t recursionDepth;
    uint8_t hullPointCount;
    int32_t hullPointsRuntimePointer;
    DpvsPlane plane;
    GfxPortalVertex *vertices;
    uint8_t unknown20To21[2];
    uint8_t vertexCount;
    uint8_t pad23;
    float hullAxis[2][3];
} GfxPortal; // 0x3C

typedef struct GfxCell
{
    float mins[3];
    float maxs[3];
    int32_t portalCount;
    GfxPortal *portals;
    uint8_t reflectionProbeCount;
    uint8_t pad21[3];
    uint8_t *reflectionProbes;
} GfxCell; // 0x28

typedef struct GfxReflectionProbe
{
    float offset[3];
} GfxReflectionProbe; // 0x0C

typedef struct GfxTexture
{
    uint32_t words[6];
} GfxTexture; // 0x18

typedef struct GfxLightmapArray
{
    GfxImage *primary;
    GfxImage *secondary;
} GfxLightmapArray; // 0x08

typedef struct GfxWorldVertexData
{
    uint8_t *vertices;
    int32_t worldVbHandle;
    int32_t worldVbOffset;
} GfxWorldVertexData; // 0x0C

typedef struct GfxWorldVertexLayerData
{
    uint8_t *data;
    int32_t layerVbHandle;
    int32_t layerVbOffset;
} GfxWorldVertexLayerData; // 0x0C

typedef struct GfxWorldDraw
{
    uint32_t reflectionProbeCount;
    GfxImage **reflectionImages;
    GfxReflectionProbe *reflectionProbes;
    GfxTexture *reflectionProbeTextures;
    int32_t lightmapCount;
    GfxLightmapArray *lightmaps;
    GfxTexture *lightmapPrimaryTextures;
    GfxTexture *lightmapSecondaryTextures;
    GfxImage *skyImage;
    GfxImage *outdoorImage;
    uint32_t vertexCount;
    GfxWorldVertexData vd;
    uint32_t vertexLayerDataSize;
    GfxWorldVertexLayerData vld;
    int32_t indexCount;
    uint16_t *indices;
    int32_t indexBufferRaw;
} GfxWorldDraw; // 0x54

typedef struct GfxLightGridEntry
{
    uint16_t colorsIndex;
    uint8_t primaryLightIndex;
    uint8_t needsTrace;
} GfxLightGridEntry; // 0x04

typedef struct GfxLightGridColors
{
    uint8_t rgb[56][3];
} GfxLightGridColors; // 0xA8

typedef struct GfxLightGrid
{
    uint32_t hasLightRegions;
    uint32_t sunPrimaryLightIndex;
    uint16_t mins[3];
    uint16_t maxs[3];
    uint32_t rowAxis;
    uint32_t colAxis;
    uint16_t *rowDataStart;
    uint32_t rawRowDataSize;
    uint8_t *rawRowData;
    uint32_t entryCount;
    GfxLightGridEntry *entries;
    uint32_t colorCount;
    GfxLightGridColors *colors;
} GfxLightGrid; // 0x38

typedef struct GfxBrushModel
{
    float writableMins[3];
    float writableMaxs[3];
    float boundsMins[3];
    float boundsMaxs[3];
    uint32_t surfaceCount;
    uint32_t startSurfIndex;
} GfxBrushModel; // 0x38

typedef struct MaterialMemory
{
    Material *material;
    int32_t memory;
} MaterialMemory; // 0x08

typedef struct Sunflare
{
    uint32_t hasValidData;
    Material *spriteMaterial;
    Material *flareMaterial;
    float spriteSize;
    float flareMinSize;
    float flareMinDot;
    float flareMaxSize;
    float flareMaxDot;
    float flareMaxAlpha;
    int32_t flareFadeInTime;
    int32_t flareFadeOutTime;
    float blindMinDot;
    float blindMaxDot;
    float blindMaxDarken;
    int32_t blindFadeInTime;
    int32_t blindFadeOutTime;
    float glareMinDot;
    float glareMaxDot;
    float glareMaxLighten;
    int32_t glareFadeInTime;
    int32_t glareFadeOutTime;
    float sunFxPosition[3];
} Sunflare; // 0x60

typedef struct GfxSceneDynModel
{
    uint16_t lod;
    uint16_t surfId;
    uint16_t dynEntId;
} GfxSceneDynModel; // 0x06

typedef struct GfxSceneDynBrush
{
    uint16_t surfId;
    uint16_t dynEntId;
} GfxSceneDynBrush; // 0x04

typedef struct GfxShadowGeometry
{
    uint16_t surfaceCount;
    uint16_t smodelCount;
    uint16_t *sortedSurfIndex;
    uint16_t *smodelIndex;
} GfxShadowGeometry; // 0x0C

typedef struct GfxLightRegionAxis
{
    float dir[3];
    float midPoint;
    float halfSize;
} GfxLightRegionAxis; // 0x14

typedef struct GfxLightRegionHull
{
    float kdopMidPoint[9];
    float kdopHalfSize[9];
    uint32_t axisCount;
    GfxLightRegionAxis *axis;
} GfxLightRegionHull; // 0x50

typedef struct GfxLightRegion
{
    int32_t hullCount;
    GfxLightRegionHull *hulls;
} GfxLightRegion; // 0x08

typedef struct GfxPackedPlacement
{
    float origin[3];
    uint32_t packedAxis[3];
    float scale;
} GfxPackedPlacement; // 0x1C

typedef struct GfxStaticModelInst
{
    float mins[3];
    float maxs[3];
    uint32_t groundLighting;
    uint8_t unknown1CTo23[8];
} GfxStaticModelInst; // 0x24

typedef struct SrfTriangles
{
    int32_t vertexLayerData;
    int32_t baseVertex;
    uint32_t minVertexIndex;
    uint16_t vertexCount;
    uint16_t triCount;
    int32_t baseIndex;
} SrfTriangles; // 0x14

typedef struct GfxSurface
{
    SrfTriangles tris;
    Material *material;
    uint8_t lightmapIndex;
    uint8_t reflectionProbeIndex;
    uint8_t primaryLightIndex;
    uint8_t castsSunShadow;
} GfxSurface; // 0x1C

typedef union GfxMapDrawSurf
{
    uint64_t packed;
} GfxMapDrawSurf; // 0x08

typedef struct GfxCullGroup
{
    float mins[3];
    float maxs[3];
    int32_t surfaceCount;
    int32_t startSurfIndex;
} GfxCullGroup; // 0x20

typedef struct GfxStaticModelDrawInst
{
    GfxPackedPlacement placement;
    XModel *model;
    uint16_t cullDist;
    uint16_t lightingHandle;
    uint8_t reflectionProbeIndex;
    uint8_t primaryLightIndex;
    uint8_t flags;
    uint8_t firstMaterialSkinIndex;
    uint8_t unknown28;
    uint8_t unknown29;
    uint8_t unknown2A;
    uint8_t unknown2B;
} GfxStaticModelDrawInst; // 0x2C

typedef struct GfxWorldDpvsStatic
{
    uint32_t smodelCount;
    uint32_t staticSurfaceCount;
    uint32_t litSurfsBegin;
    uint32_t litSurfsEnd;
    uint32_t visibilityCounts[8];
    uint32_t *smodelVisData[3];
    uint32_t *surfaceVisData[3];
    uint16_t *sortedSurfIndex;
    GfxStaticModelInst *smodelInsts;
    GfxSurface *surfaces;
    GfxCullGroup *cullGroups;
    GfxStaticModelDrawInst *smodelDrawInsts;
    GfxMapDrawSurf *surfaceMaterials;
    uint32_t *surfaceCastsSunShadow;
    volatile uint32_t usageCount;
} GfxWorldDpvsStatic; // 0x68

typedef struct GfxWorldDpvsDynamic
{
    uint32_t dynEntClientWordCount[2];
    uint32_t dynEntClientCount[2];
    uint32_t *dynEntCellBits[2];
    uint8_t *dynEntVisData[6];
} GfxWorldDpvsDynamic; // 0x30

typedef struct GfxHeroOnlyLight
{
    uint8_t bytes[0x38];
} GfxHeroOnlyLight; // 0x38

typedef struct GfxWorld
{
    const char *name;
    const char *baseName;
    int32_t planeCount;
    int32_t nodeCount;
    int32_t surfaceCount;
    uint32_t skyCount;
    GfxSky *skies;
    int32_t primaryLightFirstShadowable;
    int32_t primaryLightCount;
    int32_t sortKeyLitDecal;
    int32_t sortKeyEffectDecal;
    int32_t sortKeyEffectAuto;
    int32_t sortKeyDistortion;
    GfxWorldDpvsPlanes dpvsPlanes;
    GfxCellTreeCount *cellTreeCounts;
    GfxCellTree *cellTrees;
    GfxCell *cells;
    GfxWorldDraw worldDraw;
    GfxLightGrid lightGrid;
    int32_t modelCount;
    GfxBrushModel *models;
    float mins[3];
    float maxs[3];
    uint32_t checksum;
    int32_t materialMemoryCount;
    MaterialMemory *materialMemory;
    Sunflare sun;
    float outdoorLookupMatrix[16];
    GfxImage *outdoorImage;
    uint32_t *cellCasterBits;
    uint32_t *cellCasterBits2;
    GfxSceneDynModel *sceneDynModel;
    GfxSceneDynBrush *sceneDynBrush;
    uint32_t *primaryLightEntityShadowVis;
    uint32_t *primaryLightDynEntShadowVis[2];
    uint8_t *primaryLightForModelDynEnt;
    GfxShadowGeometry *shadowGeom;
    GfxLightRegion *lightRegion;
    GfxWorldDpvsStatic dpvs;
    GfxWorldDpvsDynamic dpvsDyn;
    uint32_t unknown26C;
    uint32_t heroOnlyLightCount;
    GfxHeroOnlyLight *heroOnlyLights;
    uint32_t unknown278;
    int32_t umbraGateCount;
    uint8_t *umbraGateData;
    uint8_t *umbraGateData2;
} GfxWorld; // 0x288 on PS3/32-bit

#pragma pack(pop)

Notes

// sceneEntCellBits count = cellCount << 9 uint32_t values.
// rowDataStart count = maxs[rowAxis] - mins[rowAxis] + 1 uint16_t values.
// vertices payload size = vertexCount * 0x10 bytes.
// vertexLayerData payload size = vertexLayerDataSize bytes.
// cellCasterBits count = cellCount * ((cellCount + 31) >> 5) uint32_t values.
// cellCasterBits2 count = ((cellCount + 31) >> 5) uint32_t values.
// sceneDynModel count = dpvsDyn.dynEntClientCount[0].
// sceneDynBrush count = dpvsDyn.dynEntClientCount[1].
// primaryLightEntityShadowVis count = max(0, primaryLightCount - primaryLightFirstShadowable - 1) * 0x2000 uint32_t values.
// primaryLightDynEntShadowVis[0] count = same shadowable tail * sceneDynModel count.
// primaryLightDynEntShadowVis[1] count = same shadowable tail * sceneDynBrush count.
// primaryLightForModelDynEnt count = sceneDynModel count bytes.
// dpvs.smodelVisData[i] count = dpvs.visibilityCounts[6] uint32_t values.
// dpvs.surfaceVisData[i] count = dpvs.visibilityCounts[7] uint32_t values.
// dpvs.sortedSurfIndex count = dpvs.staticSurfaceCount uint16_t values.
// dpvs.smodelInsts and dpvs.smodelDrawInsts count = dpvs.smodelCount.
// dpvs.surfaces, dpvs.cullGroups, and dpvs.surfaceMaterials count = surfaceCount.
// dpvs.surfaceCastsSunShadow count = dpvs.visibilityCounts[7] uint32_t values.
// dpvsDyn.dynEntCellBits[i] count = dynEntClientWordCount[i] * dpvsPlanes.cellCount uint32_t values.
// dpvsDyn.dynEntVisData load order is [0, 3, 1, 4, 2, 5].
// dpvsDyn.dynEntVisData[0..2] byte size = dynEntClientWordCount[0] << 5.
// dpvsDyn.dynEntVisData[3..5] byte size = dynEntClientWordCount[1] << 5.
// heroOnlyLights count = heroOnlyLightCount, stride 0x38.
// umbraGateData and umbraGateData2 byte size = umbraGateCount + 0x1000.

Keep in mind that the checksum is checked on other clients using the mapcrc dvar.

Retrieved from "https://codresearch.dev/index.php?title=Graphics_Map_Asset_(MW2)&oldid=1086"