fix(handlers): align GetConstantBlock/push constants with real RenderDoc API (B29-B31) (#129)

- GetConstantBlock returns UsedDescriptor, not bare Descriptor (B30)
- Unwrap .descriptor in shader_constants, cbuffer_decode handlers
- Rewrite pipe_push_constants: iterate constantBlocks with bufferBacked=False
  instead of non-existent pushConstantRangeByteOffset/Size (B29)
- Expose raw push constant bytes as hex-encoded raw_bytes field (B31)
- Move _flatten_shader_var to _helpers.py for reuse across handlers

Author: BANANASJIM

src/rdc/handlers/_helpers.py

@@ -272,6 +272,44 @@ def get_default_disasm_target(controller: Any) -> str:
     return str(targets[0]) if targets else "SPIR-V"
 
 
+def _flatten_shader_var(var: Any) -> dict[str, Any]:
+    """Recursively convert a ShaderVariable to a dict."""
+    members = getattr(var, "members", [])
+    if members:
+        return {
+            "name": var.name,
+            "type": str(getattr(var, "type", "")),
+            "rows": getattr(var, "rows", 0),
+            "columns": getattr(var, "columns", 0),
+            "value": None,
+            "members": [_flatten_shader_var(m) for m in members],
+        }
+
+    rows = getattr(var, "rows", 0)
+    columns = getattr(var, "columns", 0)
+    count = max(rows * columns, 1)
+
+    val = getattr(var, "value", None)
+    if val is None:
+        values: list[Any] = []
+    else:
+        type_str = str(getattr(var, "type", "")).lower()
+        if "uint" in type_str:
+            values = list(getattr(val, "u32v", [0.0] * 16)[:count])
+        elif "int" in type_str or "sint" in type_str:
+            values = list(getattr(val, "s32v", [0] * 16)[:count])
+        else:
+            values = list(getattr(val, "f32v", [0.0] * 16)[:count])
+
+    return {
+        "name": var.name,
+        "type": str(getattr(var, "type", "")),
+        "rows": rows,
+        "columns": columns,
+        "value": values,
+    }
+
+
 def _resolve_vfs_path(path: str, state: DaemonState) -> tuple[str, str | None]:
     """Normalize VFS path: strip trailing slash, resolve /current alias."""
     path = path.rstrip("/") or "/"

src/rdc/handlers/buffer.py

@@ -140,7 +140,8 @@ def _handle_cbuffer_decode(  # noqa: PLR0912
     shader = pipe_state.GetShader(stage_val)
     entry = pipe_state.GetShaderEntryPoint(stage_val)
     if hasattr(pipe_state, "GetConstantBlock"):
-        cb_desc = pipe_state.GetConstantBlock(stage_val, target_idx, 0)
+        cb_used = pipe_state.GetConstantBlock(stage_val, target_idx, 0)
+        cb_desc = cb_used.descriptor
         cb_resource = cb_desc.resource
         cb_offset = getattr(cb_desc, "byteOffset", 0)
         cb_size = getattr(cb_desc, "byteSize", 0)

src/rdc/handlers/pipe_state.py

@@ -9,9 +9,11 @@
     STAGE_MAP,
     _enum_name,
     _error_response,
+    _flatten_shader_var,
     _result_response,
     _sanitize_size,
     _set_frame_event,
+    get_pipeline_for_stage,
 )
 from rdc.handlers._types import Handler
 
@@ -252,18 +254,46 @@ def _handle_pipe_push_constants(
     if err:
         return _error_response(request_id, -32002, err), True
     pipe_state = state.adapter.get_pipeline_state()
-    ranges: list[dict[str, Any]] = []
+    controller = state.adapter.controller
+    push_constants: list[dict[str, Any]] = []
     for stage_val, stage_name in _STAGE_NAMES.items():
-        if int(pipe_state.GetShader(stage_val)) == 0:
+        shader_id = pipe_state.GetShader(stage_val)
+        if int(shader_id) == 0:
             continue
         refl = pipe_state.GetShaderReflection(stage_val)
         if refl is None:
             continue
-        offset = getattr(refl, "pushConstantRangeByteOffset", 0)
-        size = getattr(refl, "pushConstantRangeByteSize", 0)
-        if size > 0:
-            ranges.append({"stage": stage_name, "offset": offset, "size": size})
-    return _result_response(request_id, {"eid": eid, "push_constants": ranges}), True
+        pipe = get_pipeline_for_stage(pipe_state, stage_val)
+        entry = pipe_state.GetShaderEntryPoint(stage_val)
+        for idx, cb in enumerate(getattr(refl, "constantBlocks", [])):
+            if getattr(cb, "bufferBacked", True):
+                continue
+            bound = pipe_state.GetConstantBlock(stage_val, idx, 0)
+            desc = bound.descriptor
+            cbuffer_vars = controller.GetCBufferVariableContents(
+                pipe,
+                shader_id,
+                stage_val,
+                entry,
+                idx,
+                desc.resource,
+                desc.byteOffset,
+                desc.byteSize,
+            )
+            variables = [_flatten_shader_var(v) for v in cbuffer_vars]
+            push_constants.append(
+                {
+                    "stage": stage_name,
+                    "name": cb.name,
+                    "size": getattr(cb, "byteSize", 0),
+                    "variables": variables,
+                }
+            )
+    raw = getattr(pipe_state, "pushconsts", b"")
+    return _result_response(
+        request_id,
+        {"eid": eid, "push_constants": push_constants, "raw_bytes": raw.hex()},
+    ), True
 
 
 def _handle_pipe_rasterizer(

src/rdc/handlers/shader.py

@@ -8,6 +8,7 @@
     STAGE_MAP,
     _build_shader_cache,
     _error_response,
+    _flatten_shader_var,
     _result_response,
     _set_frame_event,
     get_default_disasm_target,
@@ -99,44 +100,6 @@ def _handle_shader_reflect(
     ), True
 
 
-def _flatten_shader_var(var: Any) -> dict[str, Any]:
-    """Recursively convert a ShaderVariable to a dict."""
-    members = getattr(var, "members", [])
-    if members:
-        return {
-            "name": var.name,
-            "type": str(getattr(var, "type", "")),
-            "rows": getattr(var, "rows", 0),
-            "columns": getattr(var, "columns", 0),
-            "value": None,
-            "members": [_flatten_shader_var(m) for m in members],
-        }
-
-    rows = getattr(var, "rows", 0)
-    columns = getattr(var, "columns", 0)
-    count = max(rows * columns, 1)
-
-    val = getattr(var, "value", None)
-    if val is None:
-        values: list[Any] = []
-    else:
-        type_str = str(getattr(var, "type", "")).lower()
-        if "uint" in type_str:
-            values = list(getattr(val, "u32v", [0.0] * 16)[:count])
-        elif "int" in type_str or "sint" in type_str:
-            values = list(getattr(val, "s32v", [0] * 16)[:count])
-        else:
-            values = list(getattr(val, "f32v", [0.0] * 16)[:count])
-
-    return {
-        "name": var.name,
-        "type": str(getattr(var, "type", "")),
-        "rows": rows,
-        "columns": columns,
-        "value": values,
-    }
-
-
 def _handle_shader_constants(
     request_id: int, params: dict[str, Any], state: DaemonState
 ) -> tuple[dict[str, Any], bool]:
@@ -165,15 +128,16 @@ def _handle_shader_constants(
     for idx, cb_def in enumerate(getattr(refl, "constantBlocks", [])):
         bind_point = getattr(cb_def, "fixedBindNumber", getattr(cb_def, "bindPoint", 0))
         bound = pipe_state.GetConstantBlock(stage_val, idx, 0)
+        desc = bound.descriptor
         cbuffer_vars = controller.GetCBufferVariableContents(
             pipe,
             shader_id,
             stage_val,
             entry,
             idx,
-            bound.resource,
-            bound.byteOffset,
-            bound.byteSize,
+            desc.resource,
+            desc.byteOffset,
+            desc.byteSize,
         )
         variables = [_flatten_shader_var(v) for v in cbuffer_vars]
         constants.append(

tests/mocks/mock_renderdoc.py

@@ -1286,6 +1286,7 @@ def __init__(
         self.rasterizer: RasterizerState | None = None
         self.depthStencil: DepthStencilState | None = None
         self.multisample: MultisampleState = MultisampleState()
+        self.pushconsts: bytes = b""
 
     def GetShader(self, stage: ShaderStage) -> ResourceId:
         return self._shaders.get(stage, ResourceId.Null())
@@ -1340,9 +1341,10 @@ def GetConstantBlock(
         stage: int,
         slot: int,
         array_idx: int,
-    ) -> Descriptor:
-        """Mock GetConstantBlock — returns descriptor with cbuffer resource."""
-        return self._cbuffer_descriptors.get((stage, slot), Descriptor())
+    ) -> UsedDescriptor:
+        """Mock GetConstantBlock — returns UsedDescriptor with cbuffer resource."""
+        desc = self._cbuffer_descriptors.get((stage, slot), Descriptor())
+        return UsedDescriptor(descriptor=desc)
 
     def GetAllUsedDescriptors(self, only_used: bool = True) -> list[UsedDescriptor]:
         """Mock GetAllUsedDescriptors — returns configured used descriptors."""

tests/unit/test_daemon_pipeline_extended.py

@@ -13,14 +13,18 @@
 from mock_renderdoc import (
     ActionDescription,
     ActionFlags,
+    ConstantBlock,
     DepthStencilState,
+    Descriptor,
     MockPipeState,
     MultisampleState,
     RasterizerState,
     ResourceDescription,
     ResourceId,
     ShaderReflection,
     ShaderStage,
+    ShaderValue,
+    ShaderVariable,
 )
 
 from rdc.adapter import RenderDocAdapter
@@ -46,6 +50,20 @@ def _req(method: str, **params: Any) -> dict[str, Any]:
 def _make_state(tmp_path: Path, pipe: MockPipeState) -> DaemonState:
     actions = _build_actions()
     resources = _build_resources()
+    cbvars: dict[tuple[int, int], list[Any]] = {}
+
+    def _get_cbuf(
+        _pipe: Any,
+        _sh: Any,
+        stage: Any,
+        _e: str,
+        idx: int,
+        _r: Any,
+        _o: int,
+        _s: int,
+    ) -> list[Any]:
+        return cbvars.get((int(stage), idx), [])
+
     controller = SimpleNamespace(
         GetRootActions=lambda: actions,
         GetResources=lambda: resources,
@@ -57,6 +75,8 @@ def _make_state(tmp_path: Path, pipe: MockPipeState) -> DaemonState:
         GetBuffers=lambda: [],
         GetDebugMessages=lambda: [],
         Shutdown=lambda: None,
+        _cbuffer_variables=cbvars,
+        GetCBufferVariableContents=_get_cbuf,
     )
     s = DaemonState(capture="test.rdc", current_eid=0, token="abcdef1234567890")
     s.adapter = RenderDocAdapter(controller=controller, version=(1, 41))
@@ -144,57 +164,91 @@ def test_empty_when_no_shaders(self, tmp_path: Path) -> None:
         resp, _ = _handle_request(_req("pipe_push_constants", eid=10), s)
         assert "error" not in resp
         assert resp["result"]["push_constants"] == []
-        assert resp["result"]["eid"] == 10
+        assert resp["result"]["raw_bytes"] == ""
 
-    def test_empty_when_size_is_zero(self, tmp_path: Path) -> None:
+    def test_empty_when_all_buffer_backed(self, tmp_path: Path) -> None:
         pipe = MockPipeState()
         refl = ShaderReflection(
             resourceId=ResourceId(5),
-            pushConstantRangeByteOffset=0,
-            pushConstantRangeByteSize=0,
+            constantBlocks=[ConstantBlock(name="ubo", bufferBacked=True, byteSize=64)],
         )
         pipe._shaders[ShaderStage.Vertex] = ResourceId(5)
         pipe._reflections[ShaderStage.Vertex] = refl
         s = _make_state(tmp_path, pipe)
         resp, _ = _handle_request(_req("pipe_push_constants", eid=10), s)
         assert resp["result"]["push_constants"] == []
 
-    def test_returns_range_when_size_nonzero(self, tmp_path: Path) -> None:
+    def test_single_stage_push_constants(self, tmp_path: Path) -> None:
         pipe = MockPipeState()
-        refl = ShaderReflection(
-            resourceId=ResourceId(5),
-            pushConstantRangeByteOffset=16,
-            pushConstantRangeByteSize=64,
-        )
+        cb = ConstantBlock(name="push_block", bufferBacked=False, byteSize=16)
+        refl = ShaderReflection(resourceId=ResourceId(5), constantBlocks=[cb])
         pipe._shaders[ShaderStage.Vertex] = ResourceId(5)
         pipe._reflections[ShaderStage.Vertex] = refl
+        pipe._cbuffer_descriptors[(ShaderStage.Vertex, 0)] = Descriptor(
+            resource=ResourceId(100),
+            byteSize=16,
+        )
+        val = ShaderValue()
+        val.f32v = [1.0, 2.0, 3.0, 4.0] + [0.0] * 12
+        var = ShaderVariable(name="color", type="vec4", rows=1, columns=4, value=val)
         s = _make_state(tmp_path, pipe)
+        s.adapter.controller._cbuffer_variables[(ShaderStage.Vertex, 0)] = [var]
         resp, _ = _handle_request(_req("pipe_push_constants", eid=10), s)
-        ranges = resp["result"]["push_constants"]
-        assert len(ranges) == 1
-        assert ranges[0]["stage"] == "vs"
-        assert ranges[0]["offset"] == 16
-        assert ranges[0]["size"] == 64
+        result = resp["result"]
+        assert len(result["push_constants"]) == 1
+        pc = result["push_constants"][0]
+        assert pc["stage"] == "vs"
+        assert pc["name"] == "push_block"
+        assert pc["size"] == 16
+        assert len(pc["variables"]) == 1
+        assert pc["variables"][0]["name"] == "color"
+        assert pc["variables"][0]["value"] == [1.0, 2.0, 3.0, 4.0]
 
     def test_multiple_stages(self, tmp_path: Path) -> None:
         pipe = MockPipeState()
-        for stage, stage_id in (
-            (ShaderStage.Vertex, 5),
-            (ShaderStage.Pixel, 6),
-        ):
-            refl = ShaderReflection(
-                resourceId=ResourceId(stage_id),
-                pushConstantRangeByteOffset=0,
-                pushConstantRangeByteSize=128,
-            )
-            pipe._shaders[stage] = ResourceId(stage_id)
+        for stage, sid in ((ShaderStage.Vertex, 5), (ShaderStage.Pixel, 6)):
+            cb = ConstantBlock(name="pc", bufferBacked=False, byteSize=8)
+            refl = ShaderReflection(resourceId=ResourceId(sid), constantBlocks=[cb])
+            pipe._shaders[stage] = ResourceId(sid)
             pipe._reflections[stage] = refl
         s = _make_state(tmp_path, pipe)
         resp, _ = _handle_request(_req("pipe_push_constants", eid=10), s)
-        ranges = resp["result"]["push_constants"]
-        stage_names = {r["stage"] for r in ranges}
-        assert "vs" in stage_names
-        assert "ps" in stage_names
+        stages = {pc["stage"] for pc in resp["result"]["push_constants"]}
+        assert "vs" in stages
+        assert "ps" in stages
+
+    def test_raw_bytes_present(self, tmp_path: Path) -> None:
+        pipe = MockPipeState()
+        pipe.pushconsts = b"\x01\x02\xab"
+        s = _make_state(tmp_path, pipe)
+        resp, _ = _handle_request(_req("pipe_push_constants", eid=10), s)
+        assert resp["result"]["raw_bytes"] == "0102ab"
+
+    def test_raw_bytes_empty_when_no_attr(self, tmp_path: Path) -> None:
+        pipe = MockPipeState()
+        delattr(pipe, "pushconsts")
+        s = _make_state(tmp_path, pipe)
+        resp, _ = _handle_request(_req("pipe_push_constants", eid=10), s)
+        assert resp["result"]["raw_bytes"] == ""
+
+    def test_mixed_buffer_backed_and_push(self, tmp_path: Path) -> None:
+        pipe = MockPipeState()
+        blocks = [
+            ConstantBlock(name="ubo", bufferBacked=True, byteSize=64),
+            ConstantBlock(name="pc", bufferBacked=False, byteSize=16),
+        ]
+        refl = ShaderReflection(resourceId=ResourceId(5), constantBlocks=blocks)
+        pipe._shaders[ShaderStage.Vertex] = ResourceId(5)
+        pipe._reflections[ShaderStage.Vertex] = refl
+        pipe._cbuffer_descriptors[(ShaderStage.Vertex, 1)] = Descriptor(
+            resource=ResourceId(200),
+            byteSize=16,
+        )
+        s = _make_state(tmp_path, pipe)
+        resp, _ = _handle_request(_req("pipe_push_constants", eid=10), s)
+        pcs = resp["result"]["push_constants"]
+        assert len(pcs) == 1
+        assert pcs[0]["name"] == "pc"
 
 
 # ── pipe_rasterizer ───────────────────────────────────────────────────────────