renderdoc_get_buffers

Instructions

Tool call template

This tool declares no required parameters. Add optional parameters from the input schema as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {},
    "name": "renderdoc_get_buffers"
  }
}

Implementation Reference

• src/renderdoc_mcp/server.py:333-353 (handler)

  The main handler for renderdoc_get_buffers tool. It checks if a capture is open, calls wrapper.get_buffers(), applies optional filtering by name, formats the buffer info, and returns the results as text content.

  elif name == "renderdoc_get_buffers":
      if not wrapper.current_file:
          return [TextContent(type="text", text="Error: No capture is currently open.")]
  
      buffers = wrapper.get_buffers()
      filter_pattern = arguments.get("filter", "").lower()
  
      if filter_pattern:
          buffers = [b for b in buffers if filter_pattern in b.name.lower()]
  
      if not buffers:
          return [TextContent(type="text", text="No buffers found.")]
  
      output = [f"Buffers ({len(buffers)} found):\n"]
      for buf in buffers[:100]:
          output.append(_format_buffer_info(buf))
  
      if len(buffers) > 100:
          output.append(f"\n... and {len(buffers) - 100} more")
  
      return [TextContent(type="text", text="\n".join(output))]

• src/renderdoc_mcp/server.py:94-107 (registration)

  Tool registration defining the renderdoc_get_buffers tool with its name, description, and input schema including an optional filter parameter for buffer names.

  Tool(
      name="renderdoc_get_buffers",
      description="Get a list of all buffers in the capture with their properties (size, type, etc.).",
      inputSchema={
          "type": "object",
          "properties": {
              "filter": {
                  "type": "string",
                  "description": "Optional filter pattern for buffer names.",
              },
          },
          "required": [],
      },
  ),

• src/renderdoc_mcp/renderdoc_wrapper.py:329-357 (handler)

  The get_buffers() implementation in RenderDocWrapper that retrieves all buffers from the open capture using the RenderDoc API, creates BufferInfo objects for each, and handles both native and fallback modes.

  def get_buffers(self) -> list[BufferInfo]:
      """
      Get list of all buffers in the capture.
  
      Returns:
          List of BufferInfo objects.
      """
      if self._use_fallback:
          return self._get_buffers_fallback()
  
      if not self.controller:
          raise RuntimeError("No capture is currently open")
  
      buffers = self.controller.GetBuffers()
      result = []
  
      for buf in buffers:
          result.append(BufferInfo(
              name=buf.name or f"Buffer_{buf.resourceId}",
              resource_id=str(buf.resourceId),
              byte_size=buf.byteSize,
              creation_flags=buf.creationFlags,
          ))
  
      return result
  
  def _get_buffers_fallback(self) -> list[BufferInfo]:
      """Get buffers using renderdoccmd as fallback."""
      return []

• src/renderdoc_mcp/renderdoc_wrapper.py:65-72 (schema)

  The BufferInfo dataclass schema defining the structure for buffer information including name, resource_id, byte_size, and creation_flags.

  @dataclass
  class BufferInfo:
      """Information about a buffer resource."""
      name: str
      resource_id: str
      byte_size: int
      creation_flags: int

• src/renderdoc_mcp/server.py:245-250 (helper)

  Helper function that formats BufferInfo objects into human-readable text output for display to the user.

  def _format_buffer_info(buf: BufferInfo) -> str:
      """Format buffer info for display."""
      size_kb = buf.byte_size / 1024
      return f"""- {buf.name} (ID: {buf.resource_id})
    Size: {size_kb:.2f} KB ({buf.byte_size} bytes)
    Flags: {buf.creation_flags}"""