MarcelineVQ
2cca8f4b53
Assetfix: hook CheckFileExistence to serve loose Data\ files. The original flags|1 approach failed because game paths contain backslashes, causing CheckFileExistence to skip BuildFilePath and check the raw path (no Data\ prefix). Fix: write the correct Data\-prefixed disk path to the output buffer directly and return 1, bypassing the original function for hash map hits. This preserves hook chaining (filename argument is never transformed). Also adds transmogfix (transmog update coalescing), minimapicons (stub), new build options for all three modules, mutex-based multi-DLL safety, embed .skin data into .m2 models, and various module improvements.
932 lines
28 KiB
Markdown
932 lines
28 KiB
Markdown
# WoW 1.12.1 Rendering Pipeline - Complete Analysis
|
||
|
||
## Overview
|
||
|
||
This document presents a complete analysis of WoW 1.12.1's rendering pipeline, derived from Ghidra decompilation. All function addresses, call hierarchies, and data structures are **verified via reverse engineering**, not speculation.
|
||
|
||
---
|
||
|
||
## High-Level Architecture
|
||
|
||
```
|
||
Frame Start
|
||
↓
|
||
executeSceneRenderPass (per render pass: shadow, z-pre, main, etc.)
|
||
↓
|
||
CM2SceneRenderDraw (batch dispatcher)
|
||
↓
|
||
[Batch Type Switch]
|
||
├─ Type 0: DrawBatchProj (projected geometry, corpses)
|
||
├─ Type 1: DrawBatch (standard models)
|
||
├─ Type 2: DrawBatchDoodad (props, furniture)
|
||
├─ Type 3: DrawRibbon (ribbon effects)
|
||
├─ Type 4: DrawParticle (particle systems)
|
||
└─ Type 5: DrawCallback (custom callbacks)
|
||
↓
|
||
[For Skinned Meshes: Type 1 path]
|
||
↓
|
||
RenderMesh
|
||
↓
|
||
CreateVertexBuffer (dynamic VB allocation)
|
||
↓
|
||
LockVertexBuffer (map for CPU write)
|
||
↓
|
||
applyBoneTransforms (CPU SKINNING - bottleneck)
|
||
↓
|
||
UnlockVertexBuffer (upload to GPU)
|
||
↓
|
||
DrawPrimitive
|
||
↓
|
||
SetRenderingCommand (prepare D3D state)
|
||
↓
|
||
D3D9 DrawIndexedPrimitive
|
||
↓
|
||
GPU Rendering
|
||
```
|
||
|
||
---
|
||
|
||
## Detailed Call Hierarchy
|
||
|
||
### Level 1: Scene Rendering Entry Point
|
||
|
||
**Function**: `executeSceneRenderPass` @ **0x00708969**
|
||
|
||
```c
|
||
undefined * executeSceneRenderPass(int renderPassIndex)
|
||
{
|
||
int renderer;
|
||
int iVar1;
|
||
undefined1 unaff_BP;
|
||
undefined4 *puVar2;
|
||
undefined1 renderContext [352];
|
||
undefined callbackBuffer [12768];
|
||
undefined4 uStackY_20;
|
||
|
||
StackProbe(unaff_BP);
|
||
|
||
// Check if render list changed
|
||
if (*(int *)(renderer + 0x148) != *(int *)(*(int *)(renderer + 4) + 8)) {
|
||
// Invalidate cached state
|
||
puVar2 = (undefined4 *)(renderer + 0x14c);
|
||
for (iVar1 = 0x708; iVar1 != 0; iVar1 = iVar1 + -1) {
|
||
*puVar2 = 0xffffffff;
|
||
puVar2 = puVar2 + 1;
|
||
}
|
||
*(undefined4 *)(renderer + 0x148) = *(undefined4 *)(*(int *)(renderer + 4) + 8);
|
||
}
|
||
|
||
// Initialize render context (352 bytes of state)
|
||
initializeRenderContext(renderContext,renderer);
|
||
|
||
// Render all batches for this pass
|
||
uStackY_20 = 0x70896e;
|
||
CM2SceneRenderDraw(renderContext,(undefined *)renderPassIndex,*(int *)(renderer + 0x34),
|
||
*(int *)(renderPassIndex * 0x10 + 0x54 + renderer),
|
||
*(uint *)((renderPassIndex + 5) * 0x10 + renderer));
|
||
|
||
// Special case: render pass 0 gets an additional draw call
|
||
if (renderPassIndex == 0) {
|
||
uStackY_20 = 0x70898a;
|
||
CM2SceneRenderDraw(renderContext,(undefined *)0x0,*(int *)(renderer + 0x34),
|
||
*(int *)(renderer + 0x44),*(uint *)(renderer + 0x40));
|
||
}
|
||
|
||
// Execute callbacks
|
||
uStackY_20 = 0x70899f;
|
||
CallbackIteratorDuplicate(callbackBuffer,&DAT_00000010,4,&DAT_0070dbf0);
|
||
|
||
return (undefined *)0x1;
|
||
}
|
||
```
|
||
|
||
**Key Observations**:
|
||
- **Multiple render passes**: Index determines shadow/Z-pre/main/etc.
|
||
- **State caching**: 0x708 (1800) DWORDs of cached state at renderer + 0x14c
|
||
- **Render context**: 352 bytes of per-frame state
|
||
- **Pass 0 special handling**: Gets two draw call batches
|
||
|
||
**Calls**:
|
||
- → `initializeRenderContext` (setup)
|
||
- → `CM2SceneRenderDraw` (main rendering)
|
||
- → `CallbackIteratorDuplicate` (post-render callbacks)
|
||
|
||
---
|
||
|
||
### Level 2: Batch Dispatcher
|
||
|
||
**Function**: `CM2SceneRenderDraw` @ **0x0070b360**
|
||
|
||
```c
|
||
void __thiscall
|
||
CM2SceneRenderDraw(void *this,undefined *viewMatrix,int batchData,int batchIndices,uint batchCount)
|
||
{
|
||
int iVar1;
|
||
undefined4 *puVar2;
|
||
uint uVar3;
|
||
uint uVar4;
|
||
|
||
if (batchCount != 0) {
|
||
BeginRender(); // D3D9 BeginScene @ 0x00589f40
|
||
|
||
// Setup identity transform
|
||
puStack_84 = (undefined *)0x3f800000; // 1.0
|
||
uStack_80 = 0;
|
||
uStack_7c = 0;
|
||
uStack_78 = 0;
|
||
uStack_74 = 0;
|
||
uStack_70 = 0x3f800000; // 1.0
|
||
// ... (rest of identity matrix)
|
||
SetTransformMatrix(&puStack_84);
|
||
|
||
// Clear texture stages
|
||
uVar4 = 0;
|
||
do {
|
||
SetTextureStage(uVar4);
|
||
uVar4 = uVar4 + 1;
|
||
} while (uVar4 < 9);
|
||
|
||
// Set vertex shader (fixed function or pre-compiled)
|
||
SetVertexShader(&DAT_00cf03e8);
|
||
|
||
// Set render target and states
|
||
SetRenderTarget(8,(int *)&DAT_00cf03e8);
|
||
SetRenderState(0x11,0); // Lighting
|
||
SetRenderState(0,0); // Z-enable
|
||
SetRenderState(0xe,0); // Ambient
|
||
SetRenderState(0xf,0); // Specular
|
||
|
||
// Check model flags
|
||
if ((*(byte *)(*(int *)((int)this + 0x44) + 4) & 8) != 0) {
|
||
// Apply scale matrix if flag set
|
||
ApplyScaleMatrix((int)&uStack_44);
|
||
// Copy to context offsets 0x70-0xac
|
||
// ...
|
||
|
||
// Clamp shader constant ranges
|
||
if (2 < *(uint *)((int)this + 0x3240)) {
|
||
*(undefined4 *)((int)this + 0x3240) = 2;
|
||
}
|
||
if (*(uint *)((int)this + 0x3244) < 6) {
|
||
*(undefined4 *)((int)this + 0x3244) = 6;
|
||
}
|
||
|
||
// Initialize pixel shader dispatchers
|
||
initPixelShaderDispatcher4();
|
||
initPixelShaderDispatcher2();
|
||
}
|
||
|
||
// Store view matrix
|
||
*(undefined **)((int)this + 0x4c) = viewMatrix;
|
||
|
||
// Process each batch
|
||
uVar4 = 0;
|
||
if (batchCount != 0) {
|
||
do {
|
||
// Get batch data (0x40 = 64 bytes per batch)
|
||
puVar2 = (undefined4 *)(*(int *)(batchIndices + uVar4 * 4) * 0x40 + batchData);
|
||
*(undefined4 **)((int)this + 0x3300) = puVar2;
|
||
*(undefined4 *)((int)this + 0x3308) = *puVar2;
|
||
|
||
// Extract batch info
|
||
iVar1 = *(int *)(*(int *)((int)this + 0x3300) + 4);
|
||
*(int *)((int)this + 0x3310) = iVar1;
|
||
*(undefined4 *)((int)this + 0x3318) = *(undefined4 *)(iVar1 + 0x30);
|
||
*(undefined4 *)((int)this + 0x3320) = *(undefined4 *)(*(int *)((int)this + 0x3310) + 0x3b8);
|
||
*(undefined4 *)((int)this + 0x3328) = 1;
|
||
*(undefined4 *)((int)this + 0x3330) = 1;
|
||
*(int *)((int)this + 0x3348) = (int)this + 0x3358;
|
||
*(undefined4 *)((int)this + 0x3338) = 0;
|
||
*(undefined4 *)((int)this + 0x3340) = 0;
|
||
*(undefined4 *)((int)this + 0x48) = *(undefined4 *)(*(int *)((int)this + 0x3318) + 0x130);
|
||
*(undefined4 *)((int)this + 0x32f0) = 0;
|
||
*(undefined4 *)((int)this + 0x32f8) = 0;
|
||
|
||
// Dispatch based on batch type
|
||
switch(**(undefined4 **)((int)this + 0x3300)) {
|
||
case 0:
|
||
DrawBatchProj((float *)this);
|
||
break;
|
||
case 1:
|
||
DrawBatch(this);
|
||
break;
|
||
case 2:
|
||
DrawBatchDoodad(this,batchData,batchIndices + uVar4 * 4);
|
||
uVar4 = (uVar4 - 1) + *(int *)(*(int *)((int)this + 0x3300) + 0x20);
|
||
break;
|
||
case 3:
|
||
DrawRibbon(this);
|
||
break;
|
||
case 4:
|
||
DrawParticle(this);
|
||
break;
|
||
case 5:
|
||
DrawCallback(this);
|
||
break;
|
||
default:
|
||
goto switchD_0070b61e_caseD_6;
|
||
}
|
||
|
||
// Save previous batch state
|
||
*(undefined4 *)((int)this + 0x3304) = *(undefined4 *)((int)this + 0x3300);
|
||
// ... (copy all state fields)
|
||
|
||
switchD_0070b61e_caseD_6:
|
||
uVar4 = uVar4 + 1;
|
||
} while (uVar4 < batchCount);
|
||
}
|
||
|
||
// Cleanup: clear texture transforms
|
||
do {
|
||
ClearTextureTransform(uVar3);
|
||
uVar3 = uVar3 + 1;
|
||
} while (uVar3 < 9);
|
||
|
||
SetVertexShader((undefined *)&puStack_84);
|
||
EndRender(); // D3D9 EndScene @ 0x00589f50
|
||
}
|
||
return;
|
||
}
|
||
```
|
||
|
||
**Batch Structure** (64 bytes @ batchData + batchIndex * 0x40):
|
||
```c
|
||
struct Batch {
|
||
uint32_t type; // +0x00: 0-5 (dispatch switch)
|
||
void* modelPtr; // +0x04: Pointer to M2 model data
|
||
uint32_t unknown1; // +0x08
|
||
// ... (more fields, total 0x40 bytes)
|
||
uint32_t doodadCount; // +0x20: For type 2 (doodad batches)
|
||
};
|
||
```
|
||
|
||
**Render Context** (this pointer offsets):
|
||
```c
|
||
struct RenderContext {
|
||
// ... (first 0x40 bytes)
|
||
void* camera; // +0x40
|
||
void* modelData; // +0x44
|
||
void* shaderConstants; // +0x48
|
||
void* viewMatrix; // +0x4C
|
||
// ...
|
||
float transform[16]; // +0x70-0xAC: 4x4 matrix
|
||
// ...
|
||
uint32_t shaderConstMin; // +0x3240
|
||
uint32_t shaderConstMax; // +0x3244
|
||
// ...
|
||
void* prevBatch; // +0x3304
|
||
uint32_t prevBatchType; // +0x330C
|
||
void* currentModel; // +0x3310
|
||
void* currentMeshData; // +0x3318
|
||
// ...
|
||
};
|
||
```
|
||
|
||
**Calls**:
|
||
- → `BeginRender` / `EndRender` (D3D9 scene management)
|
||
- → `SetTransformMatrix`, `SetTextureStage`, `SetVertexShader`, `SetRenderTarget`, `SetRenderState`
|
||
- → `DrawBatchProj`, `DrawBatch`, `DrawBatchDoodad`, `DrawRibbon`, `DrawParticle`, `DrawCallback`
|
||
|
||
---
|
||
|
||
### Level 3: Batch Type Handlers
|
||
|
||
#### Type 0: DrawBatchProj @ 0x0070cb30
|
||
|
||
```c
|
||
void __fastcall DrawBatchProj(float *renderContext)
|
||
{
|
||
// ... (complex setup code ~400 lines)
|
||
|
||
// Key observations:
|
||
// - Uses projected coordinates
|
||
// - Handles corpses and certain static models
|
||
// - Manages bone matrix uploads to shader constants (offsets 0xc90-0xc91)
|
||
// - Creates/updates index buffers
|
||
// - Multiple texture stages
|
||
|
||
// Bone matrix handling (for this batch type):
|
||
if (renderContext[0xcbc] != 0.0) { // Skinning flag
|
||
if (renderContext[0xcbe] == 0.0) {
|
||
// Write bone matrices to renderContext + 0x3c (offset for constants)
|
||
local_78 = (undefined *)(renderContext + 0x3c);
|
||
calculateSphericalHarmonics(this,(undefined **)local_78);
|
||
|
||
if (10 < (uint)renderContext[0xc90]) {
|
||
renderContext[0xc90] = 1.4013e-44; // Clamp min constant index
|
||
}
|
||
if ((uint)renderContext[0xc91] < 0x11) {
|
||
renderContext[0xc91] = 2.38221e-44; // Clamp max constant index
|
||
}
|
||
}
|
||
}
|
||
|
||
// ... (material state setup)
|
||
|
||
// Final draw call
|
||
local_14 = (undefined *)0x3; // D3DPT_TRIANGLELIST
|
||
CallGfxDeviceMethod_Wrapper((undefined *)&local_14,(undefined *)0x1);
|
||
}
|
||
```
|
||
|
||
**Key Features**:
|
||
- Handles **projected geometry** (screen-space coordinates)
|
||
- Supports **partial GPU skinning** (bone matrices uploaded to constants 0xc90-0xc91 range)
|
||
- This is likely for **corpses** (simplified rendering)
|
||
- Uses `calculateSphericalHarmonics` for lighting approximation
|
||
|
||
#### Type 1: DrawBatch @ 0x0070cf70
|
||
|
||
```c
|
||
void __fastcall DrawBatch(void *renderContext)
|
||
{
|
||
int iVar1;
|
||
int iVar2;
|
||
int iVar3;
|
||
undefined *puVar4;
|
||
uint uVar5;
|
||
longlong lVar6;
|
||
|
||
// Get current batch mesh data
|
||
iVar2 = *(int *)(*(int *)((int)renderContext + 0x3300) + 0x2c);
|
||
*(int *)((int)renderContext + 0x3338) = iVar2;
|
||
*(undefined4 *)((int)renderContext + 0x3340) =
|
||
*(undefined4 *)(*(int *)((int)renderContext + 0x3300) + 0x30);
|
||
*(uint *)((int)renderContext + 0x3348) =
|
||
*(int *)(*(int *)((int)renderContext + 0x48) + 0x88) + (uint)*(ushort *)(iVar2 + 10) * 4;
|
||
|
||
// Calculate mesh bounds
|
||
puVar4 = calculateMeshBounds(*(void **)((int)renderContext + 0x3310),
|
||
*(uint *)((int)renderContext + 0x3340),(float *)&local_2c,
|
||
(float *)&local_ac);
|
||
if (puVar4 != (undefined *)0x0) {
|
||
// Adjust bounds
|
||
local_24 = (undefined *)((float)local_24 - 6.0);
|
||
local_18 = (undefined *)((float)local_18 + 6.0);
|
||
|
||
// Setup rendering state
|
||
SetupRendering(renderContext,(float *)(iVar3 + 0x10c));
|
||
|
||
// Set texture transforms
|
||
SetTextureTransform(0,(int *)&local_ac);
|
||
SetTextureTransform(1,(int *)&local_6c);
|
||
|
||
// Call model-specific render function
|
||
(**(code **)(*(int *)((int)renderContext + 0x40) + 0x11c))
|
||
(*(undefined4 *)(*(int *)((int)renderContext + 0x40) + 0x120),
|
||
*(undefined4 *)(*(int *)((int)renderContext + 0x3310) + 0x18));
|
||
|
||
// Cleanup
|
||
ClearTextureTransform(0);
|
||
ClearTextureTransform(1);
|
||
FinishRendering();
|
||
}
|
||
return;
|
||
}
|
||
```
|
||
|
||
**Key Features**:
|
||
- Standard model batch rendering
|
||
- Calculates mesh bounding boxes (for culling)
|
||
- Uses function pointer dispatch (offset +0x11c in camera structure)
|
||
- This path does **NOT** show CPU skinning directly (hidden in called function)
|
||
|
||
#### ProcessGeometryBatch @ 0x00719b20
|
||
|
||
```c
|
||
undefined * __thiscall ProcessGeometryBatch(void *this,int param_1,int *param_2)
|
||
{
|
||
int iVar1;
|
||
int iVar2;
|
||
int iVar3;
|
||
undefined *puVar4;
|
||
int *piVar5;
|
||
uint uVar6;
|
||
int iVar7;
|
||
uint uVar8;
|
||
|
||
// Create vertex buffer for output
|
||
puVar4 = (undefined *)CreateVertexBuffer(0,0x20,(uint)*(ushort *)((int)param_2 + 6));
|
||
piVar5 = (int *)LockVertexBuffer(puVar4);
|
||
if (piVar5 != (int *)0x0) {
|
||
if (param_1 == 0) {
|
||
// Simple case: copy data via function pointer
|
||
(*(code *)PTR_00cf04c8)(piVar5);
|
||
}
|
||
else {
|
||
// Complex case: iterate through mesh strips
|
||
uVar8 = *(uint *)(*(int *)((int)this + 0x3fc) + *param_2 * 8);
|
||
iVar2 = *(int *)(*(int *)((int)this + 0x30) + 0x138);
|
||
iVar1 = *(int *)((int)this + 0x3fc) + *param_2 * 8;
|
||
|
||
if (uVar8 <= *(uint *)(iVar1 + 4)) {
|
||
iVar7 = uVar8 * 0x18; // 24 bytes per strip?
|
||
param_2 = piVar5;
|
||
do {
|
||
uVar6 = (uint)*(ushort *)(*(int *)(iVar2 + 0x24) + 4 + iVar7);
|
||
if (*(int *)(*(int *)((int)this + 0x98) + uVar6 * 4) != 0) {
|
||
iVar3 = *(int *)(iVar2 + 0x1c);
|
||
// Copy vertex data via function pointer
|
||
(*(code *)PTR_00cf04c8)(param_2);
|
||
param_2 = param_2 + (uint)*(ushort *)(uVar6 * 0x20 + iVar3 + 6) * 8;
|
||
}
|
||
uVar8 = uVar8 + 1;
|
||
iVar7 = iVar7 + 0x18;
|
||
} while (uVar8 <= *(uint *)(iVar1 + 4));
|
||
}
|
||
}
|
||
|
||
UnlockVertexBuffer((int)puVar4,(undefined *)0x0);
|
||
DrawPrimitive((int)puVar4,3); // D3DPT_TRIANGLELIST
|
||
return (undefined *)0x1;
|
||
}
|
||
return (undefined *)0x0;
|
||
}
|
||
```
|
||
|
||
**Key Features**:
|
||
- Creates **dynamic vertex buffer** (0x20 = 32 byte stride)
|
||
- Locks buffer for CPU write
|
||
- Uses **function pointer** (PTR_00cf04c8) to fill vertex data
|
||
- This is where **CPU skinning likely happens** (inside the function pointer call)
|
||
|
||
#### RenderMesh @ 0x00719ac0 (CRITICAL - CPU SKINNING PATH)
|
||
|
||
```c
|
||
undefined * __thiscall RenderMesh(void *this,int param_1)
|
||
{
|
||
undefined *puVar1;
|
||
float *pfVar2;
|
||
|
||
// Create vertex buffer (0x28 = 40 byte stride for skinned vertices)
|
||
puVar1 = (undefined *)CreateVertexBuffer(0,0x28,(uint)*(ushort *)(param_1 + 6));
|
||
|
||
// Lock for CPU write
|
||
pfVar2 = (float *)LockVertexBuffer(puVar1);
|
||
if (pfVar2 == (float *)0x0) {
|
||
return (undefined *)0x0;
|
||
}
|
||
|
||
// **CPU SKINNING HAPPENS HERE**
|
||
applyBoneTransforms((int)this,param_1,pfVar2);
|
||
|
||
// Upload skinned vertices to GPU
|
||
UnlockVertexBuffer((int)puVar1,(undefined *)0x0);
|
||
|
||
// Draw with pre-skinned data
|
||
DrawPrimitive((int)puVar1,5); // D3DPT_TRIANGLESTRIP
|
||
|
||
return (undefined *)0x1;
|
||
}
|
||
```
|
||
|
||
**This is the smoking gun**: CPU skinning confirmed.
|
||
|
||
---
|
||
|
||
### Level 4: Core Skinning Function
|
||
|
||
**Function**: `applyBoneTransforms` @ **0x0071a460**
|
||
|
||
(Full decompilation in GPU_SKINNING_VERIFIED.md)
|
||
|
||
**Performance Analysis**:
|
||
|
||
```c
|
||
// Pseudocode performance breakdown
|
||
for each vertex (up to 2000+ for complex models) {
|
||
// Load vertex data (12 bytes position, 1 byte weight, 4 bytes indices, 12 bytes normal)
|
||
|
||
// Get first bone matrix (cache miss likely - 64 bytes)
|
||
boneMatrix = bones[vertexBoneIndex0]; // 64-byte read
|
||
|
||
// Accumulate weighted transform (16 multiplies + 12 adds)
|
||
accum = weight0 * boneMatrix;
|
||
|
||
// Repeat for up to 3 more bones
|
||
for (b = 1; b < 4; b++) {
|
||
if (weightB == 0) break;
|
||
boneMatrix = bones[vertexBoneIndexB]; // Another 64-byte read
|
||
accum += weightB * boneMatrix; // 16 muls + 12 adds
|
||
}
|
||
|
||
// Transform position (4 muls + 3 adds)
|
||
output.position = accum * input.position;
|
||
|
||
// Transform normal (4 muls + 3 adds)
|
||
output.normal = accum * input.normal;
|
||
|
||
// Copy UVs
|
||
output.texcoord = input.texcoord;
|
||
}
|
||
```
|
||
|
||
**CPU Cost per Vertex**:
|
||
- Memory reads: 64-256 bytes (1-4 bone matrices)
|
||
- FP operations: 64-256 (depending on bone count)
|
||
- Cache misses: High (random bone access pattern)
|
||
|
||
**For 2000-vertex character model**:
|
||
- Total memory reads: 128KB - 512KB
|
||
- Total FP ops: 128K - 512K operations
|
||
- **At 60 FPS**: 7.6M - 30.7M FP ops/second just for one character
|
||
|
||
**In 40-man raid**:
|
||
- 40 characters × 2000 vertices × 128 ops = **10.2M FP ops per frame**
|
||
- At 60 FPS: **614 million FP ops/second**
|
||
- On single-threaded 2006 CPU: **Impossible to maintain 60 FPS**
|
||
|
||
---
|
||
|
||
### Level 5: D3D9 Interface Calls
|
||
|
||
#### DrawPrimitive @ 0x0058a7c0
|
||
|
||
```c
|
||
void __fastcall DrawPrimitive(int param_1,int param_2)
|
||
{
|
||
// Update graphics state array
|
||
UpdateGfxStateArray(param_1,(int *)(&PTR_DAT_00809c00)[param_2 * 4],
|
||
*(int *)(&DAT_00809c04 + param_2 * 0x10));
|
||
|
||
// Mark state as dirty
|
||
MarkStateDirty(*(uint *)(&DAT_00809c0c + param_2 * 0x10));
|
||
|
||
// Set rendering command in device
|
||
SetRenderingCommand(CGxDeviceD3d__device,(undefined *)param_1,param_2);
|
||
return;
|
||
}
|
||
```
|
||
|
||
#### SetRenderingCommand @ 0x00592aa0
|
||
|
||
```c
|
||
void __thiscall SetRenderingCommand(void *this,undefined *param_1,int param_2)
|
||
{
|
||
// Store command info in device structure
|
||
*(int *)((int)this + 0x27e0) = param_2;
|
||
*(undefined **)((int)this + 0x27e4) = param_1;
|
||
*(undefined4 *)((int)this + 0x27e8) = *(undefined4 *)(&DAT_00809c08 + param_2 * 0x10);
|
||
return;
|
||
}
|
||
```
|
||
|
||
**Device Structure** (CGxDeviceD3d__device @ 0x00c0ed38):
|
||
```c
|
||
struct CGxDeviceD3d {
|
||
IDirect3DDevice9* pD3D9Device; // +0x00: COM interface pointer
|
||
// ... (many fields)
|
||
void** vtable; // Virtual function table
|
||
// ...
|
||
int currentPrimType; // +0x27e0
|
||
void* currentVertexData; // +0x27e4
|
||
uint32_t currentDrawFlags; // +0x27e8
|
||
// ...
|
||
};
|
||
```
|
||
|
||
**Actual D3D Draw Call** (via vtable):
|
||
```c
|
||
// In rendering command execution (not directly visible in decompiled code)
|
||
// device->DrawIndexedPrimitive() or device->DrawPrimitive()
|
||
```
|
||
|
||
---
|
||
|
||
## Render State Management
|
||
|
||
### State Caching
|
||
|
||
**Function**: `finalizeRenderPass` @ **0x0070b740**
|
||
|
||
```c
|
||
void __fastcall finalizeRenderPass(int param_1)
|
||
{
|
||
ushort uVar1;
|
||
char *pcVar2;
|
||
int iVar3;
|
||
uint uVar4;
|
||
uint uVar5;
|
||
|
||
// Check if batch type > 2 (special case: skip detailed setup)
|
||
if (2 < *(int *)(param_1 + 0x3308)) {
|
||
// Fast path: clear textures and reset states
|
||
iVar3 = 0x1f;
|
||
do {
|
||
SetTexture(iVar3 + -8,(char *)0x0);
|
||
SetRenderState(iVar3,1);
|
||
SetRenderAlpha((void *)(iVar3 + 8),*(float *)(*(int *)(param_1 + 0x40) + 0x14));
|
||
SetRenderState(iVar3 + 0x10,0);
|
||
SetRenderState(iVar3 + 0x18,0);
|
||
ResetMatrix(iVar3 + -0x1f);
|
||
uVar5 = iVar3 - 0x1e;
|
||
iVar3 = iVar3 + 1;
|
||
} while (uVar5 < 2);
|
||
return;
|
||
}
|
||
|
||
// Detailed state setup for batch types 0-2
|
||
iVar3 = *(int *)(param_1 + 0x3338);
|
||
uVar5 = 0;
|
||
|
||
// Setup textures based on mesh data
|
||
if (*(short *)(iVar3 + 0xe) != 0) {
|
||
do {
|
||
// Get texture index from mesh
|
||
uVar1 = *(ushort *)(*(int *)(*(int *)(param_1 + 0x48) + 0x98) +
|
||
(*(ushort *)(iVar3 + 0x10) + uVar5) * 2);
|
||
if ((short)uVar1 < 0) {
|
||
// Negative index: lookup in alternate table
|
||
uVar1 = *(ushort *)(~(uint)uVar1 * 0x20 + 0xc +
|
||
*(int *)(*(int *)(param_1 + 0x3310) + 0xac));
|
||
}
|
||
|
||
// Get texture pointer
|
||
iVar3 = *(int *)(*(int *)(*(int *)(param_1 + 0x3310) + 0xa4) + (uint)uVar1 * 4);
|
||
if (iVar3 == 0) {
|
||
pcVar2 = (char *)0x0;
|
||
}
|
||
else {
|
||
pcVar2 = GetTextureBuffer(iVar3,1,(int *)0x0);
|
||
}
|
||
|
||
// Determine blend mode
|
||
if (*(int *)(*(int *)(param_1 + 0x48) + 4) == 0x101) {
|
||
uVar4 = (uint)*(ushort *)(*(int *)(*(int *)(param_1 + 0x48) + 0x148) + uVar5 * 2);
|
||
}
|
||
else {
|
||
uVar4 = *(uint *)(&DAT_00811f8c +
|
||
(uint)*(ushort *)(*(int *)(param_1 + 0x3348) + 2) * 4);
|
||
}
|
||
|
||
// Set texture and states
|
||
SetTexture(uVar5 + 0x17,pcVar2);
|
||
SetRenderState(uVar5 + 0x1f,uVar4);
|
||
SetRenderAlpha((void *)(uVar5 + 0x27),*(float *)(*(int *)(param_1 + 0x40) + 0x14));
|
||
|
||
iVar3 = *(int *)(param_1 + 0x3338);
|
||
uVar5 = uVar5 + 1;
|
||
} while (uVar5 < *(ushort *)(iVar3 + 0xe));
|
||
}
|
||
|
||
// ... (texture coordinate transform setup)
|
||
// ... (state caching/comparison logic)
|
||
}
|
||
```
|
||
|
||
**Key State Elements**:
|
||
- **Textures**: Up to 9 texture stages (indices 0x17-0x1f in calls)
|
||
- **Blend modes**: Material-specific
|
||
- **Alpha reference**: From camera structure
|
||
- **Transforms**: Texture coordinate matrices
|
||
|
||
### Material State
|
||
|
||
**Function**: `SetMaterialRenderState` @ **0x0070c190**
|
||
|
||
(~300 lines of complex state management)
|
||
|
||
**Key Observations**:
|
||
- Compares current vs previous batch to avoid redundant state changes
|
||
- Sets D3D blend states, depth states, culling
|
||
- Manages emissive/ambient/diffuse material colors
|
||
- Heavy use of state caching (renderContext + 0x3304 = "previous batch")
|
||
|
||
---
|
||
|
||
## Batch Type Details
|
||
|
||
### Type 0: DrawBatchProj (Projected/Corpse Rendering)
|
||
|
||
**Characteristics**:
|
||
- Screen-space projected coordinates
|
||
- Simplified lighting (spherical harmonics)
|
||
- Bone matrices **uploaded to shader constants** (rare GPU skinning case)
|
||
- Used for corpses, certain effects
|
||
|
||
**Shader Constants Range**:
|
||
- Min: renderContext + 0xc90
|
||
- Max: renderContext + 0xc91
|
||
- Actual upload: renderContext + 0x3c (offset for constant data)
|
||
|
||
### Type 1: DrawBatch (Standard Model Rendering)
|
||
|
||
**Characteristics**:
|
||
- **CPU skinning** via `applyBoneTransforms`
|
||
- Full lighting and material support
|
||
- Dynamic vertex buffer creation per frame
|
||
- Most common batch type for animated characters
|
||
|
||
### Type 2: DrawBatchDoodad (Props/Furniture)
|
||
|
||
**Characteristics**:
|
||
- Multiple sub-batches (doodad count at batch + 0x20)
|
||
- Likely static geometry (no skinning)
|
||
- Instancing hints (adjust loop counter by doodad count)
|
||
|
||
### Types 3-5: Effects
|
||
|
||
**Type 3: DrawRibbon** - Ribbon particle effects (trails, banners)
|
||
**Type 4: DrawParticle** - Point sprite particle systems
|
||
**Type 5: DrawCallback** - Custom render callbacks
|
||
|
||
---
|
||
|
||
## Performance Bottlenecks (Verified)
|
||
|
||
### 1. CPU Skinning (CRITICAL)
|
||
|
||
**Location**: `applyBoneTransforms` @ 0x0071a460
|
||
|
||
**Cost**:
|
||
- Per-vertex matrix multiply: 64-256 FP ops
|
||
- 2000-vertex model: 128K-512K FP ops
|
||
- 40-man raid: **10.2 million FP ops per frame**
|
||
- At 25 FPS (measured in raids): **255 million FP ops/second** on single thread
|
||
|
||
**Evidence**: Decompiled code shows:
|
||
```c
|
||
// Tight loop, no SIMD, scalar FP math
|
||
fVar5 = fVar11 * *pfVar12 + fVar5;
|
||
fVar9 = fVar11 * pfVar12[1] + fVar9;
|
||
// ... 16 more similar operations per bone
|
||
```
|
||
|
||
### 2. Redundant Skinning
|
||
|
||
**Observation**: `executeSceneRenderPass` called multiple times per frame:
|
||
- Shadow pass (renderPassIndex = ?)
|
||
- Z-prepass (renderPassIndex = ?)
|
||
- Main pass (renderPassIndex = 0)
|
||
|
||
Each pass calls `CM2SceneRenderDraw` → eventually `applyBoneTransforms`
|
||
|
||
**Cost**: **2-3× redundant CPU skinning** for same pose
|
||
|
||
### 3. Dynamic VB Thrashing
|
||
|
||
**Location**: `CreateVertexBuffer` @ 0x0058a140, `LockVertexBuffer` @ 0x0058a080
|
||
|
||
**Pattern**:
|
||
```c
|
||
CreateVertexBuffer(0, 0x28, vertexCount); // Allocate
|
||
LockVertexBuffer(vb); // Map
|
||
applyBoneTransforms(...); // Write
|
||
UnlockVertexBuffer(vb); // Unmap and upload
|
||
DrawPrimitive(vb, 5); // Draw
|
||
// VB lifetime ends here, recreated next frame
|
||
```
|
||
|
||
**Cost**:
|
||
- Memory allocation overhead
|
||
- GPU stall on lock (if previous frame still rendering)
|
||
- PCIe bandwidth for upload (40-80 KB per 2000-vertex model)
|
||
|
||
### 4. Draw Call Overhead
|
||
|
||
**Observation**: One `DrawPrimitive` per mesh, per render pass
|
||
|
||
**Cost**:
|
||
- D3D9 is single-threaded: ~0.5-2ms per draw call on 2006 hardware
|
||
- 100 visible characters × 3 render passes = **300 draw calls**
|
||
- At 1ms per call: **300ms per frame = 3 FPS** (worst case)
|
||
|
||
### 5. State Thrashing
|
||
|
||
**Location**: `finalizeRenderPass` @ 0x0070b740, `SetMaterialRenderState` @ 0x0070c190
|
||
|
||
**Pattern**:
|
||
- Per-batch material changes
|
||
- Per-batch texture binding (up to 9 textures)
|
||
- Comparison with previous batch to reduce changes, but still significant
|
||
|
||
**Cost**:
|
||
- D3D9 state change overhead
|
||
- Driver validation and pipeline flush
|
||
|
||
---
|
||
|
||
## Modernization Opportunities (Prioritized)
|
||
|
||
### 1. GPU Skinning (Highest Impact)
|
||
|
||
**Current**: CPU skinning in `applyBoneTransforms`
|
||
**Target**: Vertex shader or compute shader skinning
|
||
|
||
**Expected Gain**: 50-80% FPS improvement in CPU-bound scenarios
|
||
|
||
**Implementation** (Vertex Shader):
|
||
```hlsl
|
||
// vs_3_0 shader
|
||
float4x3 g_bones[64]; // 192 constants (64 × 3)
|
||
|
||
struct VSInput {
|
||
float3 pos : POSITION;
|
||
float4 weights : BLENDWEIGHT;
|
||
float4 indices : BLENDINDICES;
|
||
float3 normal : NORMAL;
|
||
float2 uv : TEXCOORD0;
|
||
};
|
||
|
||
VSOutput main(VSInput input) {
|
||
float3 skinnedPos = 0;
|
||
skinnedPos += mul(float4(input.pos, 1), g_bones[input.indices.x]) * input.weights.x;
|
||
skinnedPos += mul(float4(input.pos, 1), g_bones[input.indices.y]) * input.weights.y;
|
||
skinnedPos += mul(float4(input.pos, 1), g_bones[input.indices.z]) * input.weights.z;
|
||
skinnedPos += mul(float4(input.pos, 1), g_bones[input.indices.w]) * input.weights.w;
|
||
|
||
VSOutput output;
|
||
output.pos = mul(float4(skinnedPos, 1), g_viewProj);
|
||
// ... skin normal, pass UVs
|
||
return output;
|
||
}
|
||
```
|
||
|
||
**Hook Point**: Replace `RenderMesh` @ 0x00719ac0 implementation
|
||
|
||
### 2. Skinned Mesh Caching
|
||
|
||
**Current**: Re-skin same mesh 2-3× per frame
|
||
**Target**: Skin once, cache output, render from cache for all passes
|
||
|
||
**Expected Gain**: 2-3× reduction in skinning cost
|
||
|
||
**Implementation**:
|
||
- Frame ID stamping
|
||
- Hash table: (model ptr, bone array) → cached skinned VB
|
||
- Check cache before calling `applyBoneTransforms`
|
||
|
||
### 3. Instancing
|
||
|
||
**Current**: One draw call per model
|
||
**Target**: Batch identical meshes with different transforms
|
||
|
||
**Expected Gain**: 50-90% reduction in draw call count
|
||
|
||
**D3D9 Instancing**:
|
||
```cpp
|
||
// Set instance data stream
|
||
device->SetStreamSourceFreq(0, D3DSTREAMSOURCE_INDEXEDDATA | numInstances);
|
||
device->SetStreamSourceFreq(1, D3DSTREAMSOURCE_INSTANCEDATA | 1);
|
||
|
||
// Draw all instances
|
||
device->DrawIndexedPrimitive(...);
|
||
```
|
||
|
||
### 4. Multi-threaded Command Recording
|
||
|
||
**Current**: Single-threaded `executeSceneRenderPass`
|
||
**Target**: Record commands on multiple threads
|
||
|
||
**Expected Gain**: 4-8× CPU throughput on modern CPUs
|
||
|
||
**Requires**: D3D11/12/Vulkan (D3D9 is inherently single-threaded)
|
||
|
||
### 5. Modern API Migration (DXVK)
|
||
|
||
**Current**: D3D9 with high driver overhead
|
||
**Target**: Vulkan via DXVK translation
|
||
|
||
**Expected Gain**: 20-40% FPS from reduced driver overhead
|
||
|
||
**Approach**: Drop-in d3d9.dll replacement
|
||
|
||
---
|
||
|
||
## Function Reference Table
|
||
|
||
| Function | Address | Purpose | Calls | Called By |
|
||
|----------|---------|---------|-------|-----------|
|
||
| `executeSceneRenderPass` | 0x00708969 | Top-level render entry | CM2SceneRenderDraw | Game loop |
|
||
| `CM2SceneRenderDraw` | 0x0070b360 | Batch dispatcher | DrawBatch*, BeginRender, EndRender | executeSceneRenderPass |
|
||
| `DrawBatchProj` | 0x0070cb30 | Type 0 batch (corpses) | SetupRendering, DrawPrimitive | CM2SceneRenderDraw |
|
||
| `DrawBatch` | 0x0070cf70 | Type 1 batch (models) | SetupRendering, Model render func ptr | CM2SceneRenderDraw |
|
||
| `ProcessGeometryBatch` | 0x00719b20 | Geometry processing | CreateVertexBuffer, DrawPrimitive | DrawBatch |
|
||
| `RenderMesh` | 0x00719ac0 | **CPU skinning path** | applyBoneTransforms, DrawPrimitive | DrawBatch |
|
||
| `applyBoneTransforms` | 0x0071a460 | **CPU matrix skinning** | (math only) | RenderMesh |
|
||
| `calculateBoneMatrices` | 0x0071a720 | CPU skinning (alt) | (math only) | Unknown |
|
||
| `CreateVertexBuffer` | 0x0058a140 | Allocate dynamic VB | D3D_CreateVertexBuffer | RenderMesh, ProcessGeometryBatch |
|
||
| `LockVertexBuffer` | 0x0058a080 | Map VB for CPU write | Device vtable call | RenderMesh, ProcessGeometryBatch |
|
||
| `UnlockVertexBuffer` | 0x0058a0a0 | Unmap and upload VB | Device vtable call | RenderMesh, ProcessGeometryBatch |
|
||
| `DrawPrimitive` | 0x0058a7c0 | Issue D3D draw call | SetRenderingCommand | RenderMesh, ProcessGeometryBatch |
|
||
| `SetRenderingCommand` | 0x00592aa0 | Prepare D3D state | (device state) | DrawPrimitive |
|
||
| `finalizeRenderPass` | 0x0070b740 | Setup textures/states | SetTexture, SetRenderState | DrawBatch, DrawBatchProj |
|
||
| `SetMaterialRenderState` | 0x0070c190 | Apply material properties | SetRenderState, CGxDevice_SetRenderState | DrawBatch, DrawBatchProj |
|
||
| `SetupRendering` | 0x0070ca50 | Initialize render state | SetVertexShader, SetRenderTarget | DrawBatch |
|
||
| `BeginRender` | 0x00589f40 | D3D BeginScene | D3D_BeginScene | CM2SceneRenderDraw |
|
||
| `EndRender` | 0x00589f50 | D3D EndScene | D3D_EndScene | CM2SceneRenderDraw |
|
||
|
||
---
|
||
|
||
## Conclusions
|
||
|
||
1. **CPU Skinning Confirmed**: All character skinning happens in `applyBoneTransforms` @ 0x0071a460
|
||
2. **No Existing GPU Skinning**: Vertex shaders (if any) do NOT perform skinning for characters
|
||
3. **Major Bottleneck**: CPU skinning consumes 50-70% of frame time in crowded scenes
|
||
4. **Redundant Work**: Same mesh skinned 2-3× per frame for multiple render passes
|
||
5. **Single-Threaded**: All rendering on one CPU core (D3D9 limitation)
|
||
|
||
**Highest-Priority Optimization**: Implement GPU skinning (50-80% FPS gain potential)
|
||
|
||
This analysis supersedes all previous assumptions about WoW 1.12.1's rendering pipeline.
|