rdc-analyst

# RDC Analyst

Analyze GPU frame captures to reconstruct render pass graphs, resource flows, and engine structure. This skill handles analysis and knowledge-building requests; for defect debugging, use the debugger framework instead.

## Workflow

### Step 1: Identify the Input

Determine what capture data is available:

| Input Type | Examples | Action |
|------------|----------|--------|
| RenderDoc capture | `.rdc` file, texture/buffer viewer output | Proceed with pass-level analysis |
| Frame debugger log | PIX capture, Xcode GPU trace, NVIDIA Nsight export | Proceed — normalize to pass/draw-call model |
| Engine replay data | Unreal Insights, Unity Frame Debugger dump | Proceed — map to render pass abstraction |
| Text description only | "We have 3 passes: shadow, gbuffer, lighting" | Proceed with user-provided structure |
| No capture available | User has no data yet | Help user plan what to capture and with which tool |

### Step 2: Clarify the Analysis Goal

Ask the user to confirm what they need. If unclear, ask explicitly:

1. **What is the capture or input?** (file type, engine, API — D3D12, Vulkan, Metal, etc.)
2. **What analysis product do you need?**
   - Pass graph (render pass sequence with dependencies)
   - Resource dependency chain (which textures/buffers flow between passes)
   - Material/shader structure map (bindings, permutations, parameter sources)
   - Pipeline state summary (blend modes, rasterizer config per draw)
   - Knowledge entry (reusable reference doc for this rendering technique)
3. **What scope?** Full frame, a specific pass range, or a single draw call?

### Step 3: Perform the Analysis

Follow the appropriate path based on the requested product:

**Pass graph reconstruction:**
1. List all render passes in execution order
2. For each pass, record: name/label, render targets, input resources, draw count
3. Identify dependencies (pass B reads a resource written by pass A)
4. Output as a structured table or diagram description

**Resource dependency chain:**
1. Enumerate key resources (render targets, depth buffers, UAVs)
2. Track producer and consumer passes for each resource
3. Flag resources that are written but never read (potential waste)

**Material/shader analysis:**
1. Group draw calls by pipeline state object or shader combination
2. Identify material parameter sources (constant buffers, push constants)
3. Note shader permutation patterns and binding slot conventions

**Knowledge entry:**
1. Synthesize findings into a reusable reference document
2. Include: technique name, pass sequence, resource flow, shader roles, key parameters
3. Format for storage in `analyzer/common/` as a knowledge artifact

### Step 4: Validate and Deliver

Before delivering results:
- [ ] Every claim references a specific pass, draw call, or resource by name/index
- [ ] Dependencies are directional (producer -> consumer) and acyclic where expected
- [ ] Output format matches what the user requested
- [ ] Scope matches what was agreed in Step 2

## Routing Table

| User Says | Route To |
|-----------|----------|
| "Why is this triangle wrong" / "rendering bug" / "visual glitch" | **Debugger** — this is a defect, not analysis |
| "Map out the render passes" / "show me the pass graph" | **This skill** — pass graph reconstruction |
| "What resources does the shadow pass use" | **This skill** — resource dependency chain |
| "How does this engine set up materials" | **This skill** — material/shader analysis |
| "Document this rendering technique" | **This skill** — knowledge entry |

## Example

**User:** "I have a RenderDoc capture of our deferred renderer. Can you map out the pass structure and resource flow?"

**Intake response:**
> To map the pass structure, I need to confirm:
> 1. **API**: Which graphics API — D3D12, Vulkan, or Metal?
> 2. **Scope**: Full frame, or a specific section (e.g., just the lighting passes)?
> 3. **Output**: Pass graph with resource dependencies, or also material/shader breakdown?
>
> Once confirmed, I will reconstruct the pass sequence, identify render targets and input resources per pass, and produce a dependency table showing resource flow across passes.

**After intake — sample output structure:**

| Pass | Render Targets | Input Resources | Draw Calls |
|------|---------------|-----------------|------------|
| Shadow Depth | ShadowMap (D32) | — | 142 |
| GBuffer | Albedo, Normal, Depth | — | 387 |
| SSAO | AO (R8) | Depth, Normal | 1 |
| Lighting | HDR Color | Albedo, Normal, Depth, AO, ShadowMap | 1 |
| Tonemap | Backbuffer | HDR Color | 1 |

## Current Scope

This skill is part of the incubating `analyzer` framework. It provides the full intake-and-analysis workflow described above. Analysis artifacts are stored under `analyzer/common/`. As the framework matures, additional automation (template hooks, runtime contracts) will be added.