Remove nested structs from D3D11 pipeline state and move to namespace

* Moving into a namespace makes it easier to give the structs non-clumsy
  names while still being unique and not overlapping with the other API
  pipeline states.

qrenderdoc/Code/CaptureContext.cpp

@@ -534,7 +534,7 @@ void CaptureContext::CloseLogfile()
   m_Textures.clear();
   m_TextureList.clear();
 
-  CurD3D11PipelineState = D3D11PipelineState();
+  CurD3D11PipelineState = D3D11Pipe::State();
   CurD3D12PipelineState = D3D12PipelineState();
   CurGLPipelineState = GLPipelineState();
   CurVulkanPipelineState = VulkanPipelineState();

qrenderdoc/Code/CaptureContext.h

@@ -164,7 +164,7 @@ public:
   QWidget *createToolWindow(const QString &objectName);
   void windowClosed(QWidget *window);
 
-  D3D11PipelineState CurD3D11PipelineState;
+  D3D11Pipe::State CurD3D11PipelineState;
   D3D12PipelineState CurD3D12PipelineState;
   GLPipelineState CurGLPipelineState;
   VulkanPipelineState CurVulkanPipelineState;

qrenderdoc/Code/CommonPipelineState.cpp

@@ -818,7 +818,7 @@ void CommonPipelineState::GetConstantBuffer(ShaderStage stage, uint32_t BufIdx,
   {
     if(IsLogD3D11())
     {
-      const D3D11PipelineState::Shader &s = GetD3D11Stage(stage);
+      const D3D11Pipe::Shader &s = GetD3D11Stage(stage);
 
       if(BufIdx < (uint32_t)s.ConstantBuffers.count)
       {
@@ -923,7 +923,7 @@ QMap<BindpointMap, QVector<BoundResource>> CommonPipelineState::GetReadOnlyResou
   {
     if(IsLogD3D11())
     {
-      const D3D11PipelineState::Shader &s = GetD3D11Stage(stage);
+      const D3D11Pipe::Shader &s = GetD3D11Stage(stage);
 
       for(int i = 0; i < s.SRVs.count; i++)
       {

qrenderdoc/Code/CommonPipelineState.h

@@ -81,7 +81,7 @@ class CommonPipelineState
 {
 public:
   CommonPipelineState() {}
-  void SetStates(APIProperties props, D3D11PipelineState *d3d11, D3D12PipelineState *d3d12,
+  void SetStates(APIProperties props, D3D11Pipe::State *d3d11, D3D12PipelineState *d3d12,
                  GLPipelineState *gl, VulkanPipelineState *vk)
   {
     m_APIProps = props;
@@ -171,13 +171,13 @@ public:
   QVector<BoundResource> GetOutputTargets();
 
 private:
-  D3D11PipelineState *m_D3D11 = NULL;
+  D3D11Pipe::State *m_D3D11 = NULL;
   D3D12PipelineState *m_D3D12 = NULL;
   GLPipelineState *m_GL = NULL;
   VulkanPipelineState *m_Vulkan = NULL;
   APIProperties m_APIProps;
 
-  const D3D11PipelineState::Shader &GetD3D11Stage(ShaderStage stage)
+  const D3D11Pipe::Shader &GetD3D11Stage(ShaderStage stage)
   {
     if(stage == ShaderStage::Vertex)
       return m_D3D11->m_VS;

qrenderdoc/Windows/PipelineState/D3D11PipelineStateViewer.cpp

@@ -63,14 +63,10 @@ struct ViewTag
   };
 
   ViewTag() {}
-  ViewTag(ResType t, int i, const D3D11PipelineState::Shader::ResourceView &r)
-      : type(t), index(i), res(r)
-  {
-  }
-
+  ViewTag(ResType t, int i, const D3D11Pipe::View &r) : type(t), index(i), res(r) {}
   ResType type;
   int index;
-  D3D11PipelineState::Shader::ResourceView res;
+  D3D11Pipe::View res;
 };
 
 Q_DECLARE_METATYPE(ViewTag);
@@ -385,8 +381,7 @@ void D3D11PipelineStateViewer::setEmptyRow(QTreeWidgetItem *node)
     node->setBackgroundColor(i, QColor(255, 70, 70));
 }
 
-bool D3D11PipelineStateViewer::HasImportantViewParams(
-    const D3D11PipelineState::Shader::ResourceView &view, FetchTexture *tex)
+bool D3D11PipelineStateViewer::HasImportantViewParams(const D3D11Pipe::View &view, FetchTexture *tex)
 {
   // we don't count 'upgrade typeless to typed' as important, we just display the typed format
   // in the row since there's no real hidden important information there. The formats can't be
@@ -406,8 +401,7 @@ bool D3D11PipelineStateViewer::HasImportantViewParams(
   return false;
 }
 
-bool D3D11PipelineStateViewer::HasImportantViewParams(
-    const D3D11PipelineState::Shader::ResourceView &view, FetchBuffer *buf)
+bool D3D11PipelineStateViewer::HasImportantViewParams(const D3D11Pipe::View &view, FetchBuffer *buf)
 {
   if(view.FirstElement > 0 || view.NumElements * view.ElementSize < buf->length)
     return true;
@@ -423,7 +417,7 @@ void D3D11PipelineStateViewer::setViewDetails(QTreeWidgetItem *node, const ViewT
 
   QString text;
 
-  const D3D11PipelineState::Shader::ResourceView &res = view.res;
+  const D3D11Pipe::View &res = view.res;
 
   bool viewdetails = false;
 
@@ -495,7 +489,7 @@ void D3D11PipelineStateViewer::setViewDetails(QTreeWidgetItem *node, const ViewT
 
   QString text;
 
-  const D3D11PipelineState::Shader::ResourceView &res = view.res;
+  const D3D11Pipe::View &res = view.res;
 
   if((res.FirstElement * res.ElementSize) > 0 || (res.NumElements * res.ElementSize) < buf->length)
   {
@@ -526,7 +520,7 @@ void D3D11PipelineStateViewer::addResourceRow(const ViewTag &view, const ShaderR
   const QIcon &action = Icons::action();
   const QIcon &action_hover = Icons::action_hover();
 
-  const D3D11PipelineState::Shader::ResourceView &r = view.res;
+  const D3D11Pipe::View &r = view.res;
 
   bool viewDetails = false;
 
@@ -679,7 +673,7 @@ bool D3D11PipelineStateViewer::showNode(bool usedSlot, bool filledSlot)
   return false;
 }
 
-const D3D11PipelineState::Shader *D3D11PipelineStateViewer::stageForSender(QWidget *widget)
+const D3D11Pipe::Shader *D3D11PipelineStateViewer::stageForSender(QWidget *widget)
 {
   if(!m_Ctx.LogLoaded())
     return NULL;
@@ -784,7 +778,7 @@ void D3D11PipelineStateViewer::clearState()
   ui->stencils->clear();
 }
 
-void D3D11PipelineStateViewer::setShaderState(const D3D11PipelineState::Shader &stage, QLabel *shader,
+void D3D11PipelineStateViewer::setShaderState(const D3D11Pipe::Shader &stage, QLabel *shader,
                                               RDTreeWidget *resources, RDTreeWidget *samplers,
                                               RDTreeWidget *cbuffers, RDTreeWidget *classes)
 {
@@ -841,7 +835,7 @@ void D3D11PipelineStateViewer::setShaderState(const D3D11PipelineState::Shader &
   samplers->clear();
   for(int i = 0; i < stage.Samplers.count; i++)
   {
-    const D3D11PipelineState::Shader::Sampler &s = stage.Samplers[i];
+    const D3D11Pipe::Sampler &s = stage.Samplers[i];
 
     const ShaderResource *shaderInput = NULL;
 
@@ -938,7 +932,7 @@ void D3D11PipelineStateViewer::setShaderState(const D3D11PipelineState::Shader &
   cbuffers->clear();
   for(int i = 0; i < stage.ConstantBuffers.count; i++)
   {
-    const D3D11PipelineState::Shader::CBuffer &b = stage.ConstantBuffers[i];
+    const D3D11Pipe::CBuffer &b = stage.ConstantBuffers[i];
 
     const ConstantBlock *shaderCBuf = NULL;
 
@@ -1039,7 +1033,7 @@ void D3D11PipelineStateViewer::setState()
     return;
   }
 
-  const D3D11PipelineState &state = m_Ctx.CurD3D11PipelineState;
+  const D3D11Pipe::State &state = m_Ctx.CurD3D11PipelineState;
   const FetchDrawcall *draw = m_Ctx.CurDrawcall();
 
   const QPixmap &tick = Pixmaps::tick();
@@ -1156,7 +1150,7 @@ void D3D11PipelineStateViewer::setState()
   ui->iaLayouts->clear();
   {
     int i = 0;
-    for(const D3D11PipelineState::InputAssembler::LayoutInput &l : state.m_IA.layouts)
+    for(const D3D11Pipe::Layout &l : state.m_IA.layouts)
     {
       QString byteOffs = QString::number(l.ByteOffset);
 
@@ -1309,7 +1303,7 @@ void D3D11PipelineStateViewer::setState()
 
   for(int i = 0; i < state.m_IA.vbuffers.count; i++)
   {
-    const D3D11PipelineState::InputAssembler::VertexBuffer &v = state.m_IA.vbuffers[i];
+    const D3D11Pipe::VB &v = state.m_IA.vbuffers[i];
 
     bool filledSlot = (v.Buffer != ResourceId());
     bool usedSlot = (usedVBuffers[i]);
@@ -1402,7 +1396,7 @@ void D3D11PipelineStateViewer::setState()
   ui->gsStreamOut->clear();
   for(int i = 0; i < state.m_SO.Outputs.count; i++)
   {
-    const D3D11PipelineState::Streamout::Output &s = state.m_SO.Outputs[i];
+    const D3D11Pipe::SOBind &s = state.m_SO.Outputs[i];
 
     bool filledSlot = (s.Buffer != ResourceId());
     bool usedSlot = (filledSlot);
@@ -1456,7 +1450,7 @@ void D3D11PipelineStateViewer::setState()
   ui->viewports->clear();
   for(int i = 0; i < state.m_RS.Viewports.count; i++)
   {
-    const D3D11PipelineState::Rasterizer::Viewport &v = state.m_RS.Viewports[i];
+    const D3D11Pipe::Viewport &v = state.m_RS.Viewports[i];
 
     if(v.Enabled || ui->showEmpty->isChecked())
     {
@@ -1481,7 +1475,7 @@ void D3D11PipelineStateViewer::setState()
   ui->scissors->clear();
   for(int i = 0; i < state.m_RS.Scissors.count; i++)
   {
-    const D3D11PipelineState::Rasterizer::Scissor &s = state.m_RS.Scissors[i];
+    const D3D11Pipe::Scissor &s = state.m_RS.Scissors[i];
 
     if(s.Enabled || ui->showEmpty->isChecked())
     {
@@ -1541,9 +1535,9 @@ void D3D11PipelineStateViewer::setState()
       // this search will just boil down to only PS.
       // When multiple stages use the UAV, we allow the last stage to 'win' and define its type,
       // although it would be very surprising if the types were actually different anyway.
-      const D3D11PipelineState::Shader *nonCS[] = {&state.m_VS, &state.m_DS, &state.m_HS,
-                                                   &state.m_GS, &state.m_PS};
-      for(const D3D11PipelineState::Shader *stage : nonCS)
+      const D3D11Pipe::Shader *nonCS[] = {&state.m_VS, &state.m_DS, &state.m_HS, &state.m_GS,
+                                          &state.m_PS};
+      for(const D3D11Pipe::Shader *stage : nonCS)
       {
         if(stage->ShaderDetails)
         {
@@ -1572,8 +1566,7 @@ void D3D11PipelineStateViewer::setState()
   ui->blends->clear();
   {
     int i = 0;
-    for(const D3D11PipelineState::OutputMerger::BlendState::RTBlend &blend :
-        state.m_OM.m_BlendState.Blends)
+    for(const D3D11Pipe::Blend &blend : state.m_OM.m_BlendState.Blends)
     {
       bool filledSlot = (blend.Enabled || targets[i]);
       bool usedSlot = (targets[i]);
@@ -1706,7 +1699,7 @@ QString D3D11PipelineStateViewer::formatMembers(int indent, const QString &namep
 
 void D3D11PipelineStateViewer::resource_itemActivated(QTreeWidgetItem *item, int column)
 {
-  const D3D11PipelineState::Shader *stage = stageForSender(item->treeWidget());
+  const D3D11Pipe::Shader *stage = stageForSender(item->treeWidget());
 
   if(stage == NULL)
     return;
@@ -1801,13 +1794,13 @@ void D3D11PipelineStateViewer::resource_itemActivated(QTreeWidgetItem *item, int
     // bound in the PS but only in an earlier stage.
     if(view.type == ViewTag::UAV && stage->stage != ShaderStage::Compute)
     {
-      const D3D11PipelineState &state = m_Ctx.CurD3D11PipelineState;
-      const D3D11PipelineState::Shader *nonCS[] = {&state.m_VS, &state.m_DS, &state.m_HS,
-                                                   &state.m_GS, &state.m_PS};
+      const D3D11Pipe::State &state = m_Ctx.CurD3D11PipelineState();
+      const D3D11Pipe::Shader *nonCS[] = {&state.m_VS, &state.m_DS, &state.m_HS, &state.m_GS,
+                                          &state.m_PS};
 
       bind += state.m_OM.UAVStartSlot;
 
-      for(const D3D11PipelineState::Shader *searchstage : nonCS)
+      for(const D3D11Pipe::Shader *searchstage : nonCS)
       {
         if(searchstage->ShaderDetails)
         {
@@ -1960,7 +1953,7 @@ void D3D11PipelineStateViewer::resource_itemActivated(QTreeWidgetItem *item, int
 
 void D3D11PipelineStateViewer::cbuffer_itemActivated(QTreeWidgetItem *item, int column)
 {
-  const D3D11PipelineState::Shader *stage = stageForSender(item->treeWidget());
+  const D3D11Pipe::Shader *stage = stageForSender(item->treeWidget());
 
   if(stage == NULL)
     return;
@@ -2023,7 +2016,7 @@ void D3D11PipelineStateViewer::highlightIABind(int slot)
 {
   int idx = ((slot + 1) * 21) % 32;    // space neighbouring colours reasonably distinctly
 
-  const D3D11PipelineState::InputAssembler &IA = m_Ctx.CurD3D11PipelineState.m_IA;
+  const D3D11Pipe::IA &IA = m_Ctx.CurD3D11PipelineState.m_IA;
 
   QColor col = QColor::fromHslF(float(idx) / 32.0f, 1.0f, 0.95f);
 
@@ -2080,7 +2073,7 @@ void D3D11PipelineStateViewer::on_iaLayouts_mouseMove(QMouseEvent *e)
 
   vertex_leave(NULL);
 
-  const D3D11PipelineState::InputAssembler &IA = m_Ctx.CurD3D11PipelineState.m_IA;
+  const D3D11Pipe::IA &IA = m_Ctx.CurD3D11PipelineState.m_IA;
 
   if(idx.isValid())
   {
@@ -2194,7 +2187,7 @@ void D3D11PipelineStateViewer::shaderView_clicked()
   }
   else
   {
-    const D3D11PipelineState::Shader *stage = stageForSender(sender);
+    const D3D11Pipe::Shader *stage = stageForSender(sender);
 
     if(stage == NULL || stage->Object == ResourceId())
       return;
@@ -2218,7 +2211,7 @@ void D3D11PipelineStateViewer::shaderView_clicked()
 void D3D11PipelineStateViewer::shaderEdit_clicked()
 {
   QWidget *sender = qobject_cast<QWidget *>(QObject::sender());
-  const D3D11PipelineState::Shader *stage = stageForSender(sender);
+  const D3D11Pipe::Shader *stage = stageForSender(sender);
 
   if(!stage || stage->Object == ResourceId())
     return;
@@ -2253,8 +2246,7 @@ void D3D11PipelineStateViewer::shaderEdit_clicked()
 
 void D3D11PipelineStateViewer::shaderSave_clicked()
 {
-  const D3D11PipelineState::Shader *stage =
-      stageForSender(qobject_cast<QWidget *>(QObject::sender()));
+  const D3D11Pipe::Shader *stage = stageForSender(qobject_cast<QWidget *>(QObject::sender()));
 
   if(stage == NULL)
     return;

qrenderdoc/Windows/PipelineState/D3D11PipelineStateViewer.h

@@ -77,7 +77,7 @@ private:
   CaptureContext &m_Ctx;
   PipelineStateViewer &m_Common;
 
-  void setShaderState(const D3D11PipelineState::Shader &stage, QLabel *shader, RDTreeWidget *tex,
+  void setShaderState(const D3D11Pipe::Shader &stage, QLabel *shader, RDTreeWidget *tex,
                       RDTreeWidget *samp, RDTreeWidget *cbuffer, RDTreeWidget *classes);
 
   void addResourceRow(const ViewTag &view, const ShaderResource *shaderInput,
@@ -94,11 +94,10 @@ private:
 
   QString formatMembers(int indent, const QString &nameprefix,
                         const rdctype::array<ShaderConstant> &vars);
-  const D3D11PipelineState::Shader *stageForSender(QWidget *widget);
+  const D3D11Pipe::Shader *stageForSender(QWidget *widget);
 
-  bool HasImportantViewParams(const D3D11PipelineState::Shader::ResourceView &view,
-                              FetchTexture *tex);
-  bool HasImportantViewParams(const D3D11PipelineState::Shader::ResourceView &view, FetchBuffer *buf);
+  bool HasImportantViewParams(const D3D11Pipe::View &view, FetchTexture *tex);
+  bool HasImportantViewParams(const D3D11Pipe::View &view, FetchBuffer *buf);
 
   void setViewDetails(QTreeWidgetItem *node, const ViewTag &view, FetchTexture *tex);
   void setViewDetails(QTreeWidgetItem *node, const ViewTag &view, FetchBuffer *buf);

renderdoc/api/replay/d3d11_pipestate.h

@@ -27,308 +27,340 @@
 
 #include "shader_types.h"
 
-struct D3D11PipelineState
+namespace D3D11Pipe
 {
-  D3D11PipelineState() {}
-  struct InputAssembler
+struct Layout
+{
+  Layout()
+      : SemanticIndex(0), InputSlot(0), ByteOffset(0), PerInstance(false), InstanceDataStepRate(0)
   {
-    InputAssembler() : Bytecode(NULL), customName(false) {}
-    struct LayoutInput
-    {
-      LayoutInput()
-          : SemanticIndex(0), InputSlot(0), ByteOffset(0), PerInstance(false), InstanceDataStepRate(0)
-      {
-      }
-      rdctype::str SemanticName;
-      uint32_t SemanticIndex;
-      ResourceFormat Format;
-      uint32_t InputSlot;
-      uint32_t ByteOffset;
-      bool32 PerInstance;
-      uint32_t InstanceDataStepRate;
-    };
-    rdctype::array<LayoutInput> layouts;
-    ResourceId layout;
-    ShaderReflection *Bytecode;
-    bool32 customName;
-    rdctype::str LayoutName;
-
-    struct VertexBuffer
-    {
-      VertexBuffer() : Buffer(), Stride(0), Offset(0) {}
-      ResourceId Buffer;
-      uint32_t Stride;
-      uint32_t Offset;
-    };
-    rdctype::array<VertexBuffer> vbuffers;
-
-    struct IndexBuffer
-    {
-      IndexBuffer() : Buffer(), Offset(0) {}
-      ResourceId Buffer;
-      uint32_t Offset;
-    } ibuffer;
-  } m_IA;
-
-  struct Shader
-  {
-    Shader() : Object(), customName(false), ShaderDetails(NULL), stage(ShaderStage::Vertex) {}
-    ResourceId Object;
-    rdctype::str ShaderName;
-    bool32 customName;
-    ShaderReflection *ShaderDetails;
-    ShaderBindpointMapping BindpointMapping;
-
-    ShaderStage stage;
-
-    struct ResourceView
-    {
-      ResourceView()
-          : View(),
-            Resource(),
-            Format(),
-            Structured(false),
-            BufferStructCount(0),
-            ElementSize(0),
-            ElementOffset(0),
-            ElementWidth(0),
-            FirstElement(0),
-            NumElements(1),
-            Flags(D3DBufferViewFlags::NoFlags),
-            HighestMip(0),
-            NumMipLevels(1),
-            ArraySize(1),
-            FirstArraySlice(0)
-      {
-      }
-
-      ResourceId View;
-      ResourceId Resource;
-      rdctype::str Type;
-      ResourceFormat Format;
-
-      bool32 Structured;
-      uint32_t BufferStructCount;
-      uint32_t ElementSize;
-
-      // Buffer (SRV)
-      uint32_t ElementOffset;
-      uint32_t ElementWidth;
-
-      // Buffer (UAV)
-      uint32_t FirstElement;
-      uint32_t NumElements;
-
-      // BufferEx
-      D3DBufferViewFlags Flags;
-
-      // Texture
-      uint32_t HighestMip;
-      uint32_t NumMipLevels;
-
-      // Texture Array
-      uint32_t ArraySize;
-      uint32_t FirstArraySlice;
-    };
-    rdctype::array<ResourceView> SRVs;
-    rdctype::array<ResourceView> UAVs;
-
-    struct Sampler
-    {
-      Sampler()
-          : Samp(),
-            customSamplerName(false),
-            UseBorder(false),
-            UseComparison(false),
-            MaxAniso(0),
-            MaxLOD(0.0f),
-            MinLOD(0.0f),
-            MipLODBias(0.0f)
-      {
-        BorderColor[0] = BorderColor[1] = BorderColor[2] = BorderColor[3] = 0.0f;
-      }
-      ResourceId Samp;
-      rdctype::str SamplerName;
-      bool32 customSamplerName;
-      rdctype::str AddressU, AddressV, AddressW;
-      float BorderColor[4];
-      rdctype::str Comparison;
-      rdctype::str Filter;
-      bool32 UseBorder;
-      bool32 UseComparison;
-      uint32_t MaxAniso;
-      float MaxLOD;
-      float MinLOD;
-      float MipLODBias;
-    };
-    rdctype::array<Sampler> Samplers;
-
-    struct CBuffer
-    {
-      CBuffer() : Buffer(), VecOffset(0), VecCount(0) {}
-      ResourceId Buffer;
-      uint32_t VecOffset;
-      uint32_t VecCount;
-    };
-    rdctype::array<CBuffer> ConstantBuffers;
-
-    rdctype::array<rdctype::str> ClassInstances;
-  } m_VS, m_HS, m_DS, m_GS, m_PS, m_CS;
-
-  struct Streamout
-  {
-    struct Output
-    {
-      Output() : Buffer(), Offset(0) {}
-      ResourceId Buffer;
-      uint32_t Offset;
-    };
-    rdctype::array<Output> Outputs;
-  } m_SO;
-
-  struct Rasterizer
-  {
-    struct Viewport
-    {
-      Viewport() : Width(0.0f), Height(0.0f), MinDepth(0.0f), MaxDepth(0.0f), Enabled(false)
-      {
-        TopLeft[0] = 0.0f;
-        TopLeft[1] = 0.0f;
-      }
-      Viewport(float TX, float TY, float W, float H, float MN, float MX, bool en)
-          : Width(W), Height(H), MinDepth(MN), MaxDepth(MX), Enabled(en)
-      {
-        TopLeft[0] = TX;
-        TopLeft[1] = TY;
-      }
-      float TopLeft[2];
-      float Width, Height;
-      float MinDepth, MaxDepth;
-      bool32 Enabled;
-    };
-    rdctype::array<Viewport> Viewports;
-
-    struct Scissor
-    {
-      Scissor() : left(0), top(0), right(0), bottom(0), Enabled(false) {}
-      Scissor(int l, int t, int r, int b, bool en)
-          : left(l), top(t), right(r), bottom(b), Enabled(en)
-      {
-      }
-      int32_t left, top, right, bottom;
-      bool32 Enabled;
-    };
-    rdctype::array<Scissor> Scissors;
-
-    struct RasterizerState
-    {
-      RasterizerState()
-          : State(),
-            fillMode(FillMode::Solid),
-            cullMode(CullMode::NoCull),
-            FrontCCW(false),
-            DepthBias(0),
-            DepthBiasClamp(0.0f),
-            SlopeScaledDepthBias(0.0f),
-            DepthClip(false),
-            ScissorEnable(false),
-            MultisampleEnable(false),
-            AntialiasedLineEnable(false),
-            ForcedSampleCount(0),
-            ConservativeRasterization(false)
-      {
-      }
-      ResourceId State;
-      FillMode fillMode;
-      CullMode cullMode;
-      bool32 FrontCCW;
-      int32_t DepthBias;
-      float DepthBiasClamp;
-      float SlopeScaledDepthBias;
-      bool32 DepthClip;
-      bool32 ScissorEnable;
-      bool32 MultisampleEnable;
-      bool32 AntialiasedLineEnable;
-      uint32_t ForcedSampleCount;
-      bool32 ConservativeRasterization;
-    } m_State;
-  } m_RS;
-
-  struct OutputMerger
-  {
-    OutputMerger() : UAVStartSlot(0), DepthReadOnly(false), StencilReadOnly(false) {}
-    struct DepthStencilState
-    {
-      DepthStencilState()
-          : State(),
-            DepthEnable(false),
-            DepthWrites(false),
-            StencilEnable(false),
-            StencilReadMask(0),
-            StencilWriteMask(0),
-            StencilRef(0)
-      {
-      }
-      ResourceId State;
-      bool32 DepthEnable;
-      rdctype::str DepthFunc;
-      bool32 DepthWrites;
-      bool32 StencilEnable;
-      byte StencilReadMask;
-      byte StencilWriteMask;
-
-      struct StencilOp
-      {
-        rdctype::str FailOp;
-        rdctype::str DepthFailOp;
-        rdctype::str PassOp;
-        rdctype::str Func;
-      } m_FrontFace, m_BackFace;
-
-      uint32_t StencilRef;
-    } m_State;
-
-    struct BlendState
-    {
-      BlendState() : AlphaToCoverage(false), IndependentBlend(false), SampleMask(0)
-      {
-        BlendFactor[0] = BlendFactor[1] = BlendFactor[2] = BlendFactor[3] = 0.0f;
-      }
-
-      ResourceId State;
-
-      bool32 AlphaToCoverage;
-      bool32 IndependentBlend;
-
-      struct RTBlend
-      {
-        RTBlend() : Enabled(false), LogicEnabled(false), WriteMask(0) {}
-        struct BlendOp
-        {
-          rdctype::str Source;
-          rdctype::str Destination;
-          rdctype::str Operation;
-        } m_Blend, m_AlphaBlend;
-
-        rdctype::str LogicOp;
-
-        bool32 Enabled;
-        bool32 LogicEnabled;
-        byte WriteMask;
-      };
-      rdctype::array<RTBlend> Blends;
-
-      float BlendFactor[4];
-      uint32_t SampleMask;
-    } m_BlendState;
-
-    rdctype::array<Shader::ResourceView> RenderTargets;
-
-    uint32_t UAVStartSlot;
-    rdctype::array<Shader::ResourceView> UAVs;
-
-    Shader::ResourceView DepthTarget;
-    bool32 DepthReadOnly;
-    bool32 StencilReadOnly;
-  } m_OM;
+  }
+  rdctype::str SemanticName;
+  uint32_t SemanticIndex;
+  ResourceFormat Format;
+  uint32_t InputSlot;
+  uint32_t ByteOffset;
+  bool32 PerInstance;
+  uint32_t InstanceDataStepRate;
 };
+
+struct VB
+{
+  VB() : Buffer(), Stride(0), Offset(0) {}
+  ResourceId Buffer;
+  uint32_t Stride;
+  uint32_t Offset;
+};
+
+struct IB
+{
+  IB() : Buffer(), Offset(0) {}
+  ResourceId Buffer;
+  uint32_t Offset;
+};
+
+struct IA
+{
+  IA() : Bytecode(NULL), customName(false) {}
+  rdctype::array<Layout> layouts;
+  ResourceId layout;
+  ShaderReflection *Bytecode;
+  bool32 customName;
+  rdctype::str LayoutName;
+
+  rdctype::array<VB> vbuffers;
+
+  IB ibuffer;
+};
+
+struct View
+{
+  View()
+      : Object(),
+        Resource(),
+        Format(),
+        Structured(false),
+        BufferStructCount(0),
+        ElementSize(0),
+        ElementOffset(0),
+        ElementWidth(0),
+        FirstElement(0),
+        NumElements(1),
+        Flags(D3DBufferViewFlags::NoFlags),
+        HighestMip(0),
+        NumMipLevels(1),
+        ArraySize(1),
+        FirstArraySlice(0)
+  {
+  }
+
+  ResourceId Object;
+  ResourceId Resource;
+  rdctype::str Type;
+  ResourceFormat Format;
+
+  bool32 Structured;
+  uint32_t BufferStructCount;
+  uint32_t ElementSize;
+
+  // Buffer (SRV)
+  uint32_t ElementOffset;
+  uint32_t ElementWidth;
+
+  // Buffer (UAV)
+  uint32_t FirstElement;
+  uint32_t NumElements;
+
+  // BufferEx
+  D3DBufferViewFlags Flags;
+
+  // Texture
+  uint32_t HighestMip;
+  uint32_t NumMipLevels;
+
+  // Texture Array
+  uint32_t ArraySize;
+  uint32_t FirstArraySlice;
+};
+
+struct Sampler
+{
+  Sampler()
+      : Samp(),
+        customSamplerName(false),
+        UseBorder(false),
+        UseComparison(false),
+        MaxAniso(0),
+        MaxLOD(0.0f),
+        MinLOD(0.0f),
+        MipLODBias(0.0f)
+  {
+    BorderColor[0] = BorderColor[1] = BorderColor[2] = BorderColor[3] = 0.0f;
+  }
+  ResourceId Samp;
+  rdctype::str SamplerName;
+  bool32 customSamplerName;
+  rdctype::str AddressU, AddressV, AddressW;
+  float BorderColor[4];
+  rdctype::str Comparison;
+  rdctype::str Filter;
+  bool32 UseBorder;
+  bool32 UseComparison;
+  uint32_t MaxAniso;
+  float MaxLOD;
+  float MinLOD;
+  float MipLODBias;
+};
+
+struct CBuffer
+{
+  CBuffer() : Buffer(), VecOffset(0), VecCount(0) {}
+  ResourceId Buffer;
+  uint32_t VecOffset;
+  uint32_t VecCount;
+};
+
+struct Shader
+{
+  Shader() : Object(), customName(false), ShaderDetails(NULL), stage(ShaderStage::Vertex) {}
+  ResourceId Object;
+  rdctype::str ShaderName;
+  bool32 customName;
+  ShaderReflection *ShaderDetails;
+  ShaderBindpointMapping BindpointMapping;
+
+  ShaderStage stage;
+
+  rdctype::array<View> SRVs;
+  rdctype::array<View> UAVs;
+
+  rdctype::array<Sampler> Samplers;
+
+  rdctype::array<CBuffer> ConstantBuffers;
+
+  rdctype::array<rdctype::str> ClassInstances;
+};
+
+struct SOBind
+{
+  SOBind() : Buffer(), Offset(0) {}
+  ResourceId Buffer;
+  uint32_t Offset;
+};
+
+struct SO
+{
+  rdctype::array<SOBind> Outputs;
+};
+
+struct Viewport
+{
+  Viewport() : Width(0.0f), Height(0.0f), MinDepth(0.0f), MaxDepth(0.0f), Enabled(false)
+  {
+    TopLeft[0] = 0.0f;
+    TopLeft[1] = 0.0f;
+  }
+  Viewport(float TX, float TY, float W, float H, float MN, float MX, bool en)
+      : Width(W), Height(H), MinDepth(MN), MaxDepth(MX), Enabled(en)
+  {
+    TopLeft[0] = TX;
+    TopLeft[1] = TY;
+  }
+  float TopLeft[2];
+  float Width, Height;
+  float MinDepth, MaxDepth;
+  bool32 Enabled;
+};
+
+struct Scissor
+{
+  Scissor() : left(0), top(0), right(0), bottom(0), Enabled(false) {}
+  Scissor(int l, int t, int r, int b, bool en) : left(l), top(t), right(r), bottom(b), Enabled(en)
+  {
+  }
+  int32_t left, top, right, bottom;
+  bool32 Enabled;
+};
+
+struct RasterizerState
+{
+  RasterizerState()
+      : State(),
+        fillMode(FillMode::Solid),
+        cullMode(CullMode::NoCull),
+        FrontCCW(false),
+        DepthBias(0),
+        DepthBiasClamp(0.0f),
+        SlopeScaledDepthBias(0.0f),
+        DepthClip(false),
+        ScissorEnable(false),
+        MultisampleEnable(false),
+        AntialiasedLineEnable(false),
+        ForcedSampleCount(0),
+        ConservativeRasterization(false)
+  {
+  }
+  ResourceId State;
+  FillMode fillMode;
+  CullMode cullMode;
+  bool32 FrontCCW;
+  int32_t DepthBias;
+  float DepthBiasClamp;
+  float SlopeScaledDepthBias;
+  bool32 DepthClip;
+  bool32 ScissorEnable;
+  bool32 MultisampleEnable;
+  bool32 AntialiasedLineEnable;
+  uint32_t ForcedSampleCount;
+  bool32 ConservativeRasterization;
+};
+
+struct Rasterizer
+{
+  rdctype::array<Viewport> Viewports;
+  rdctype::array<Scissor> Scissors;
+
+  RasterizerState m_State;
+};
+
+struct StencilOp
+{
+  rdctype::str FailOp;
+  rdctype::str DepthFailOp;
+  rdctype::str PassOp;
+  rdctype::str Func;
+};
+
+struct DepthStencilState
+{
+  DepthStencilState()
+      : State(),
+        DepthEnable(false),
+        DepthWrites(false),
+        StencilEnable(false),
+        StencilReadMask(0),
+        StencilWriteMask(0),
+        StencilRef(0)
+  {
+  }
+  ResourceId State;
+  bool32 DepthEnable;
+  rdctype::str DepthFunc;
+  bool32 DepthWrites;
+  bool32 StencilEnable;
+  byte StencilReadMask;
+  byte StencilWriteMask;
+
+  StencilOp m_FrontFace, m_BackFace;
+
+  uint32_t StencilRef;
+};
+
+struct BlendOp
+{
+  rdctype::str Source;
+  rdctype::str Destination;
+  rdctype::str Operation;
+};
+
+struct Blend
+{
+  Blend() : Enabled(false), LogicEnabled(false), WriteMask(0) {}
+  BlendOp m_Blend, m_AlphaBlend;
+
+  rdctype::str LogicOp;
+
+  bool32 Enabled;
+  bool32 LogicEnabled;
+  byte WriteMask;
+};
+
+struct BlendState
+{
+  BlendState() : AlphaToCoverage(false), IndependentBlend(false), SampleMask(0)
+  {
+    BlendFactor[0] = BlendFactor[1] = BlendFactor[2] = BlendFactor[3] = 0.0f;
+  }
+
+  ResourceId State;
+
+  bool32 AlphaToCoverage;
+  bool32 IndependentBlend;
+
+  rdctype::array<Blend> Blends;
+
+  float BlendFactor[4];
+  uint32_t SampleMask;
+};
+
+struct OM
+{
+  OM() : UAVStartSlot(0), DepthReadOnly(false), StencilReadOnly(false) {}
+  DepthStencilState m_State;
+  BlendState m_BlendState;
+
+  rdctype::array<View> RenderTargets;
+
+  uint32_t UAVStartSlot;
+  rdctype::array<View> UAVs;
+
+  View DepthTarget;
+  bool32 DepthReadOnly;
+  bool32 StencilReadOnly;
+};
+
+struct State
+{
+  State() {}
+  IA m_IA;
+
+  Shader m_VS, m_HS, m_DS, m_GS, m_PS, m_CS;
+
+  SO m_SO;
+
+  Rasterizer m_RS;
+
+  OM m_OM;
+};
+
+};    // namespace D3D11Pipe

renderdoc/api/replay/renderdoc_replay.h

@@ -222,7 +222,7 @@ struct IReplayRenderer
   virtual bool InitResolver() = 0;
 
   virtual bool SetFrameEvent(uint32_t eventID, bool force) = 0;
-  virtual bool GetD3D11PipelineState(D3D11PipelineState *state) = 0;
+  virtual bool GetD3D11PipelineState(D3D11Pipe::State *state) = 0;
   virtual bool GetD3D12PipelineState(D3D12PipelineState *state) = 0;
   virtual bool GetGLPipelineState(GLPipelineState *state) = 0;
   virtual bool GetVulkanPipelineState(VulkanPipelineState *state) = 0;
@@ -298,7 +298,7 @@ extern "C" RENDERDOC_API bool32 RENDERDOC_CC ReplayRenderer_SetFrameEvent(IRepla
                                                                           uint32_t eventID,
                                                                           bool32 force);
 extern "C" RENDERDOC_API bool32 RENDERDOC_CC
-ReplayRenderer_GetD3D11PipelineState(IReplayRenderer *rend, D3D11PipelineState *state);
+ReplayRenderer_GetD3D11PipelineState(IReplayRenderer *rend, D3D11Pipe::State *state);
 extern "C" RENDERDOC_API bool32 RENDERDOC_CC
 ReplayRenderer_GetD3D12PipelineState(IReplayRenderer *rend, D3D12PipelineState *state);
 extern "C" RENDERDOC_API bool32 RENDERDOC_CC ReplayRenderer_GetGLPipelineState(IReplayRenderer *rend,

renderdoc/core/image_viewer.cpp

@@ -147,7 +147,7 @@ public:
   // handle a couple of operations ourselves to return a simple fake log
   APIProperties GetAPIProperties() { return m_Props; }
   FetchFrameRecord GetFrameRecord() { return m_FrameRecord; }
-  D3D11PipelineState GetD3D11PipelineState() { return m_PipelineState; }
+  D3D11Pipe::State GetD3D11PipelineState() { return m_PipelineState; }
   // other operations are dropped/ignored, to avoid confusion
   void ReadLogInitialisation() {}
   void RenderMesh(uint32_t eventID, const vector<MeshFormat> &secondaryDraws, const MeshDisplay &cfg)
@@ -265,7 +265,7 @@ private:
 
   APIProperties m_Props;
   FetchFrameRecord m_FrameRecord;
-  D3D11PipelineState m_PipelineState;
+  D3D11Pipe::State m_PipelineState;
   IReplayDriver *m_Proxy;
   string m_Filename;
   ResourceId m_TextureID;

renderdoc/core/replay_proxy.cpp

@@ -300,7 +300,7 @@ void Serialiser::Serialise(const char *name, ShaderDebugTrace &el)
 #pragma region D3D11 pipeline state
 
 template <>
-void Serialiser::Serialise(const char *name, D3D11PipelineState::InputAssembler::LayoutInput &el)
+void Serialiser::Serialise(const char *name, D3D11Pipe::Layout &el)
 {
   Serialise("", el.SemanticName);
   Serialise("", el.SemanticIndex);
@@ -314,7 +314,7 @@ void Serialiser::Serialise(const char *name, D3D11PipelineState::InputAssembler:
 }
 
 template <>
-void Serialiser::Serialise(const char *name, D3D11PipelineState::InputAssembler &el)
+void Serialiser::Serialise(const char *name, D3D11Pipe::IA &el)
 {
   Serialise("", el.ibuffer.Buffer);
   Serialise("", el.ibuffer.Offset);
@@ -329,9 +329,9 @@ void Serialiser::Serialise(const char *name, D3D11PipelineState::InputAssembler
 }
 
 template <>
-void Serialiser::Serialise(const char *name, D3D11PipelineState::Shader::ResourceView &el)
+void Serialiser::Serialise(const char *name, D3D11Pipe::View &el)
 {
-  Serialise("", el.View);
+  Serialise("", el.Object);
   Serialise("", el.Resource);
   Serialise("", el.Type);
   Serialise("", el.Format);
@@ -353,7 +353,7 @@ void Serialiser::Serialise(const char *name, D3D11PipelineState::Shader::Resourc
 }
 
 template <>
-void Serialiser::Serialise(const char *name, D3D11PipelineState::Shader::Sampler &el)
+void Serialiser::Serialise(const char *name, D3D11Pipe::Sampler &el)
 {
   Serialise("", el.Samp);
   Serialise("", el.SamplerName);
@@ -375,7 +375,7 @@ void Serialiser::Serialise(const char *name, D3D11PipelineState::Shader::Sampler
 }
 
 template <>
-void Serialiser::Serialise(const char *name, D3D11PipelineState::Shader &el)
+void Serialiser::Serialise(const char *name, D3D11Pipe::Shader &el)
 {
   Serialise("", el.Object);
   Serialise("", el.stage);
@@ -397,7 +397,7 @@ void Serialiser::Serialise(const char *name, D3D11PipelineState::Shader &el)
 }
 
 template <>
-void Serialiser::Serialise(const char *name, D3D11PipelineState::Rasterizer &el)
+void Serialiser::Serialise(const char *name, D3D11Pipe::Rasterizer &el)
 {
   Serialise("", el.m_State);
   Serialise("", el.Scissors);
@@ -407,7 +407,7 @@ void Serialiser::Serialise(const char *name, D3D11PipelineState::Rasterizer &el)
 }
 
 template <>
-void Serialiser::Serialise(const char *name, D3D11PipelineState::OutputMerger::BlendState::RTBlend &el)
+void Serialiser::Serialise(const char *name, D3D11Pipe::Blend &el)
 {
   Serialise("", el.m_Blend.Source);
   Serialise("", el.m_Blend.Destination);
@@ -427,7 +427,7 @@ void Serialiser::Serialise(const char *name, D3D11PipelineState::OutputMerger::B
 }
 
 template <>
-void Serialiser::Serialise(const char *name, D3D11PipelineState::OutputMerger &el)
+void Serialiser::Serialise(const char *name, D3D11Pipe::OM &el)
 {
   {
     Serialise("", el.m_State.State);
@@ -472,7 +472,7 @@ void Serialiser::Serialise(const char *name, D3D11PipelineState::OutputMerger &e
 }
 
 template <>
-void Serialiser::Serialise(const char *name, D3D11PipelineState &el)
+void Serialiser::Serialise(const char *name, D3D11Pipe::State &el)
 {
   Serialise("", el.m_IA);
 
@@ -1778,38 +1778,32 @@ string ToStrHelper<false, GraphicsAPI>::Get(const GraphicsAPI &el)
 
 // these structures we can just serialise as a blob, since they're POD.
 template <>
-string ToStrHelper<false, D3D11PipelineState::InputAssembler::VertexBuffer>::Get(
-    const D3D11PipelineState::InputAssembler::VertexBuffer &el)
+string ToStrHelper<false, D3D11Pipe::VB>::Get(const D3D11Pipe::VB &el)
 {
   return "<...>";
 }
 template <>
-string ToStrHelper<false, D3D11PipelineState::Rasterizer::RasterizerState>::Get(
-    const D3D11PipelineState::Rasterizer::RasterizerState &el)
+string ToStrHelper<false, D3D11Pipe::RasterizerState>::Get(const D3D11Pipe::RasterizerState &el)
 {
   return "<...>";
 }
 template <>
-string ToStrHelper<false, D3D11PipelineState::Shader::CBuffer>::Get(
-    const D3D11PipelineState::Shader::CBuffer &el)
+string ToStrHelper<false, D3D11Pipe::CBuffer>::Get(const D3D11Pipe::CBuffer &el)
 {
   return "<...>";
 }
 template <>
-string ToStrHelper<false, D3D11PipelineState::Rasterizer::Scissor>::Get(
-    const D3D11PipelineState::Rasterizer::Scissor &el)
+string ToStrHelper<false, D3D11Pipe::Scissor>::Get(const D3D11Pipe::Scissor &el)
 {
   return "<...>";
 }
 template <>
-string ToStrHelper<false, D3D11PipelineState::Rasterizer::Viewport>::Get(
-    const D3D11PipelineState::Rasterizer::Viewport &el)
+string ToStrHelper<false, D3D11Pipe::Viewport>::Get(const D3D11Pipe::Viewport &el)
 {
   return "<...>";
 }
 template <>
-string ToStrHelper<false, D3D11PipelineState::Streamout::Output>::Get(
-    const D3D11PipelineState::Streamout::Output &el)
+string ToStrHelper<false, D3D11Pipe::SOBind>::Get(const D3D11Pipe::SOBind &el)
 {
   return "<...>";
 }
@@ -2398,7 +2392,7 @@ void ReplayProxy::SavePipelineState()
     if(!SendReplayCommand(eReplayProxy_SavePipelineState))
       return;
 
-    m_D3D11PipelineState = D3D11PipelineState();
+    m_D3D11PipelineState = D3D11Pipe::State();
     m_D3D12PipelineState = D3D12PipelineState();
     m_GLPipelineState = GLPipelineState();
     m_VulkanPipelineState = VulkanPipelineState();

renderdoc/core/replay_proxy.h

@@ -397,7 +397,7 @@ public:
   vector<DebugMessage> GetDebugMessages();
 
   void SavePipelineState();
-  D3D11PipelineState GetD3D11PipelineState() { return m_D3D11PipelineState; }
+  D3D11Pipe::State GetD3D11PipelineState() { return m_D3D11PipelineState; }
   D3D12PipelineState GetD3D12PipelineState() { return m_D3D12PipelineState; }
   GLPipelineState GetGLPipelineState() { return m_GLPipelineState; }
   VulkanPipelineState GetVulkanPipelineState() { return m_VulkanPipelineState; }
@@ -551,7 +551,7 @@ private:
 
   APIProperties m_APIProps;
 
-  D3D11PipelineState m_D3D11PipelineState;
+  D3D11Pipe::State m_D3D11PipelineState;
   D3D12PipelineState m_D3D12PipelineState;
   GLPipelineState m_GLPipelineState;
   VulkanPipelineState m_VulkanPipelineState;

renderdoc/driver/d3d11/d3d11_replay.cpp

@@ -439,11 +439,11 @@ vector<ResourceId> D3D11Replay::GetTextures()
   return ret;
 }
 
-D3D11PipelineState D3D11Replay::MakePipelineState()
+D3D11Pipe::State D3D11Replay::MakePipelineState()
 {
   D3D11RenderState *rs = m_pDevice->GetImmediateContext()->GetCurrentPipelineState();
 
-  D3D11PipelineState ret;
+  D3D11Pipe::State ret;
 
   /////////////////////////////////////////////////
   // Input Assembler
@@ -477,7 +477,7 @@ D3D11PipelineState D3D11Replay::MakePipelineState()
 
     for(size_t i = 0; i < vec.size(); i++)
     {
-      D3D11PipelineState::InputAssembler::LayoutInput &l = ret.m_IA.layouts[i];
+      D3D11Pipe::Layout &l = ret.m_IA.layouts[i];
 
       l.ByteOffset = vec[i].AlignedByteOffset;
       l.Format = MakeResourceFormat(vec[i].Format);
@@ -493,7 +493,7 @@ D3D11PipelineState D3D11Replay::MakePipelineState()
 
   for(size_t i = 0; i < ARRAY_COUNT(rs->IA.VBs); i++)
   {
-    D3D11PipelineState::InputAssembler::VertexBuffer &vb = ret.m_IA.vbuffers[i];
+    D3D11Pipe::VB &vb = ret.m_IA.vbuffers[i];
 
     vb.Buffer = rm->GetOriginalID(GetIDForResource(rs->IA.VBs[i]));
     vb.Offset = rs->IA.Offsets[i];
@@ -508,8 +508,8 @@ D3D11PipelineState D3D11Replay::MakePipelineState()
   /////////////////////////////////////////////////
 
   {
-    D3D11PipelineState::Shader *dstArr[] = {&ret.m_VS, &ret.m_HS, &ret.m_DS,
-                                            &ret.m_GS, &ret.m_PS, &ret.m_CS};
+    D3D11Pipe::Shader *dstArr[] = {&ret.m_VS, &ret.m_HS, &ret.m_DS,
+                                   &ret.m_GS, &ret.m_PS, &ret.m_CS};
     const D3D11RenderState::shader *srcArr[] = {&rs->VS, &rs->HS, &rs->DS,
                                                 &rs->GS, &rs->PS, &rs->CS};
 
@@ -517,7 +517,7 @@ D3D11PipelineState D3D11Replay::MakePipelineState()
 
     for(size_t stage = 0; stage < 6; stage++)
     {
-      D3D11PipelineState::Shader &dst = *dstArr[stage];
+      D3D11Pipe::Shader &dst = *dstArr[stage];
       const D3D11RenderState::shader &src = *srcArr[stage];
 
       dst.stage = (ShaderStage)stage;
@@ -611,7 +611,7 @@ D3D11PipelineState D3D11Replay::MakePipelineState()
       create_array_uninit(dst.Samplers, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT);
       for(size_t s = 0; s < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; s++)
       {
-        D3D11PipelineState::Shader::Sampler &samp = dst.Samplers[s];
+        D3D11Pipe::Sampler &samp = dst.Samplers[s];
 
         samp.Samp = rm->GetOriginalID(GetIDForResource(src.Samplers[s]));
 
@@ -657,11 +657,11 @@ D3D11PipelineState D3D11Replay::MakePipelineState()
       create_array_uninit(dst.SRVs, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT);
       for(size_t s = 0; s < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; s++)
       {
-        D3D11PipelineState::Shader::ResourceView &view = dst.SRVs[s];
+        D3D11Pipe::View &view = dst.SRVs[s];
 
-        view.View = rm->GetOriginalID(GetIDForResource(src.SRVs[s]));
+        view.Object = rm->GetOriginalID(GetIDForResource(src.SRVs[s]));
 
-        if(view.View != ResourceId())
+        if(view.Object != ResourceId())
         {
           D3D11_SHADER_RESOURCE_VIEW_DESC desc;
           src.SRVs[s]->GetDesc(&desc);
@@ -760,11 +760,11 @@ D3D11PipelineState D3D11Replay::MakePipelineState()
       create_array(dst.UAVs, D3D11_1_UAV_SLOT_COUNT);
       for(size_t s = 0; dst.stage == ShaderStage::Compute && s < D3D11_1_UAV_SLOT_COUNT; s++)
       {
-        D3D11PipelineState::Shader::ResourceView &view = dst.UAVs[s];
+        D3D11Pipe::View &view = dst.UAVs[s];
 
-        view.View = rm->GetOriginalID(GetIDForResource(rs->CSUAVs[s]));
+        view.Object = rm->GetOriginalID(GetIDForResource(rs->CSUAVs[s]));
 
-        if(view.View != ResourceId())
+        if(view.Object != ResourceId())
         {
           D3D11_UNORDERED_ACCESS_VIEW_DESC desc;
           rs->CSUAVs[s]->GetDesc(&desc);
@@ -943,22 +943,22 @@ D3D11PipelineState D3D11Replay::MakePipelineState()
     size_t i = 0;
     create_array_uninit(ret.m_RS.Scissors, D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE);
     for(i = 0; i < rs->RS.NumScissors; i++)
-      ret.m_RS.Scissors[i] = D3D11PipelineState::Rasterizer::Scissor(
-          rs->RS.Scissors[i].left, rs->RS.Scissors[i].top, rs->RS.Scissors[i].right,
-          rs->RS.Scissors[i].bottom, true);
+      ret.m_RS.Scissors[i] =
+          D3D11Pipe::Scissor(rs->RS.Scissors[i].left, rs->RS.Scissors[i].top,
+                             rs->RS.Scissors[i].right, rs->RS.Scissors[i].bottom, true);
 
     for(; i < D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE; i++)
-      ret.m_RS.Scissors[i] = D3D11PipelineState::Rasterizer::Scissor(0, 0, 0, 0, false);
+      ret.m_RS.Scissors[i] = D3D11Pipe::Scissor(0, 0, 0, 0, false);
 
     create_array_uninit(ret.m_RS.Viewports, D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE);
     for(i = 0; i < rs->RS.NumViews; i++)
-      ret.m_RS.Viewports[i] = D3D11PipelineState::Rasterizer::Viewport(
-          rs->RS.Viewports[i].TopLeftX, rs->RS.Viewports[i].TopLeftY, rs->RS.Viewports[i].Width,
-          rs->RS.Viewports[i].Height, rs->RS.Viewports[i].MinDepth, rs->RS.Viewports[i].MaxDepth,
-          true);
+      ret.m_RS.Viewports[i] =
+          D3D11Pipe::Viewport(rs->RS.Viewports[i].TopLeftX, rs->RS.Viewports[i].TopLeftY,
+                              rs->RS.Viewports[i].Width, rs->RS.Viewports[i].Height,
+                              rs->RS.Viewports[i].MinDepth, rs->RS.Viewports[i].MaxDepth, true);
 
     for(; i < D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE; i++)
-      ret.m_RS.Viewports[i] = D3D11PipelineState::Rasterizer::Viewport(0, 0, 0, 0, 0, 0, false);
+      ret.m_RS.Viewports[i] = D3D11Pipe::Viewport(0, 0, 0, 0, 0, 0, false);
   }
 
   /////////////////////////////////////////////////
@@ -969,11 +969,11 @@ D3D11PipelineState D3D11Replay::MakePipelineState()
     create_array_uninit(ret.m_OM.RenderTargets, D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT);
     for(size_t i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
     {
-      D3D11PipelineState::Shader::ResourceView &view = ret.m_OM.RenderTargets[i];
+      D3D11Pipe::View &view = ret.m_OM.RenderTargets[i];
 
-      view.View = rm->GetOriginalID(GetIDForResource(rs->OM.RenderTargets[i]));
+      view.Object = rm->GetOriginalID(GetIDForResource(rs->OM.RenderTargets[i]));
 
-      if(view.View != ResourceId())
+      if(view.Object != ResourceId())
       {
         D3D11_RENDER_TARGET_VIEW_DESC desc;
         rs->OM.RenderTargets[i]->GetDesc(&desc);
@@ -1037,11 +1037,11 @@ D3D11PipelineState D3D11Replay::MakePipelineState()
     create_array_uninit(ret.m_OM.UAVs, D3D11_1_UAV_SLOT_COUNT);
     for(size_t s = 0; s < D3D11_1_UAV_SLOT_COUNT; s++)
     {
-      D3D11PipelineState::Shader::ResourceView view;
+      D3D11Pipe::View view;
 
-      view.View = rm->GetOriginalID(GetIDForResource(rs->OM.UAVs[s]));
+      view.Object = rm->GetOriginalID(GetIDForResource(rs->OM.UAVs[s]));
 
-      if(view.View != ResourceId())
+      if(view.Object != ResourceId())
       {
         D3D11_UNORDERED_ACCESS_VIEW_DESC desc;
         rs->OM.UAVs[s]->GetDesc(&desc);
@@ -1117,11 +1117,11 @@ D3D11PipelineState D3D11Replay::MakePipelineState()
     }
 
     {
-      D3D11PipelineState::Shader::ResourceView &view = ret.m_OM.DepthTarget;
+      D3D11Pipe::View &view = ret.m_OM.DepthTarget;
 
-      view.View = rm->GetOriginalID(GetIDForResource(rs->OM.DepthView));
+      view.Object = rm->GetOriginalID(GetIDForResource(rs->OM.DepthView));
 
-      if(view.View != ResourceId())
+      if(view.Object != ResourceId())
       {
         D3D11_DEPTH_STENCIL_VIEW_DESC desc;
         rs->OM.DepthView->GetDesc(&desc);
@@ -1204,8 +1204,7 @@ D3D11PipelineState D3D11Replay::MakePipelineState()
       create_array_uninit(ret.m_OM.m_BlendState.Blends, 8);
       for(size_t i = 0; i < 8; i++)
       {
-        D3D11PipelineState::OutputMerger::BlendState::RTBlend &blend =
-            ret.m_OM.m_BlendState.Blends[i];
+        D3D11Pipe::Blend &blend = ret.m_OM.m_BlendState.Blends[i];
 
         blend.Enabled = desc.RenderTarget[i].BlendEnable == TRUE;
 
@@ -1230,7 +1229,7 @@ D3D11PipelineState D3D11Replay::MakePipelineState()
       ret.m_OM.m_BlendState.AlphaToCoverage = false;
       ret.m_OM.m_BlendState.IndependentBlend = false;
 
-      D3D11PipelineState::OutputMerger::BlendState::RTBlend blend;
+      D3D11Pipe::Blend blend;
 
       blend.Enabled = false;
 
@@ -1585,12 +1584,12 @@ bool D3D11Replay::IsRenderOutput(ResourceId id)
 {
   for(size_t i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
   {
-    if(m_CurPipelineState.m_OM.RenderTargets[i].View == id ||
+    if(m_CurPipelineState.m_OM.RenderTargets[i].Object == id ||
        m_CurPipelineState.m_OM.RenderTargets[i].Resource == id)
       return true;
   }
 
-  if(m_CurPipelineState.m_OM.DepthTarget.View == id ||
+  if(m_CurPipelineState.m_OM.DepthTarget.Object == id ||
      m_CurPipelineState.m_OM.DepthTarget.Resource == id)
     return true;
 

renderdoc/driver/d3d11/d3d11_replay.h

@@ -63,7 +63,7 @@ public:
   FetchFrameRecord GetFrameRecord();
 
   void SavePipelineState() { m_CurPipelineState = MakePipelineState(); }
-  D3D11PipelineState GetD3D11PipelineState() { return m_CurPipelineState; }
+  D3D11Pipe::State GetD3D11PipelineState() { return m_CurPipelineState; }
   D3D12PipelineState GetD3D12PipelineState() { return D3D12PipelineState(); }
   GLPipelineState GetGLPipelineState() { return GLPipelineState(); }
   VulkanPipelineState GetVulkanPipelineState() { return VulkanPipelineState(); }
@@ -165,7 +165,7 @@ public:
   Callstack::StackResolver *GetCallstackResolver();
 
 private:
-  D3D11PipelineState MakePipelineState();
+  D3D11Pipe::State MakePipelineState();
 
   bool m_WARP;
   bool m_Proxy;
@@ -174,5 +174,5 @@ private:
 
   WrappedID3D11Device *m_pDevice;
 
-  D3D11PipelineState m_CurPipelineState;
+  D3D11Pipe::State m_CurPipelineState;
 };

renderdoc/driver/d3d12/d3d12_replay.h

@@ -61,7 +61,7 @@ public:
   FetchFrameRecord GetFrameRecord();
 
   void SavePipelineState() { MakePipelineState(); }
-  D3D11PipelineState GetD3D11PipelineState() { return D3D11PipelineState(); }
+  D3D11Pipe::State GetD3D11PipelineState() { return D3D11Pipe::State(); }
   D3D12PipelineState GetD3D12PipelineState() { return m_PipelineState; }
   GLPipelineState GetGLPipelineState() { return GLPipelineState(); }
   VulkanPipelineState GetVulkanPipelineState() { return VulkanPipelineState(); }

renderdoc/driver/gl/gl_replay.h

@@ -108,7 +108,7 @@ public:
   FetchFrameRecord GetFrameRecord();
 
   void SavePipelineState();
-  D3D11PipelineState GetD3D11PipelineState() { return D3D11PipelineState(); }
+  D3D11Pipe::State GetD3D11PipelineState() { return D3D11Pipe::State(); }
   D3D12PipelineState GetD3D12PipelineState() { return D3D12PipelineState(); }
   GLPipelineState GetGLPipelineState() { return m_CurPipelineState; }
   VulkanPipelineState GetVulkanPipelineState() { return VulkanPipelineState(); }

renderdoc/driver/vulkan/vk_replay.h

@@ -150,7 +150,7 @@ public:
   vector<DebugMessage> GetDebugMessages();
 
   void SavePipelineState();
-  D3D11PipelineState GetD3D11PipelineState() { return D3D11PipelineState(); }
+  D3D11Pipe::State GetD3D11PipelineState() { return D3D11Pipe::State(); }
   D3D12PipelineState GetD3D12PipelineState() { return D3D12PipelineState(); }
   GLPipelineState GetGLPipelineState() { return GLPipelineState(); }
   VulkanPipelineState GetVulkanPipelineState() { return m_VulkanPipelineState; }

renderdoc/replay/replay_driver.h

@@ -96,7 +96,7 @@ public:
   virtual vector<EventUsage> GetUsage(ResourceId id) = 0;
 
   virtual void SavePipelineState() = 0;
-  virtual D3D11PipelineState GetD3D11PipelineState() = 0;
+  virtual D3D11Pipe::State GetD3D11PipelineState() = 0;
   virtual D3D12PipelineState GetD3D12PipelineState() = 0;
   virtual GLPipelineState GetGLPipelineState() = 0;
   virtual VulkanPipelineState GetVulkanPipelineState() = 0;

renderdoc/replay/replay_renderer.cpp

@@ -183,7 +183,7 @@ bool ReplayRenderer::SetFrameEvent(uint32_t eventID, bool force)
   return true;
 }
 
-bool ReplayRenderer::GetD3D11PipelineState(D3D11PipelineState *state)
+bool ReplayRenderer::GetD3D11PipelineState(D3D11Pipe::State *state)
 {
   if(state)
   {
@@ -1625,7 +1625,7 @@ void ReplayRenderer::FetchPipelineState()
   m_VulkanPipelineState = m_pDevice->GetVulkanPipelineState();
 
   {
-    D3D11PipelineState::Shader *stages[] = {
+    D3D11Pipe::Shader *stages[] = {
         &m_D3D11PipelineState.m_VS, &m_D3D11PipelineState.m_HS, &m_D3D11PipelineState.m_DS,
         &m_D3D11PipelineState.m_GS, &m_D3D11PipelineState.m_PS, &m_D3D11PipelineState.m_CS,
     };
@@ -1719,7 +1719,7 @@ extern "C" RENDERDOC_API bool32 RENDERDOC_CC ReplayRenderer_SetFrameEvent(IRepla
   return rend->SetFrameEvent(eventID, force != 0);
 }
 extern "C" RENDERDOC_API bool32 RENDERDOC_CC
-ReplayRenderer_GetD3D11PipelineState(IReplayRenderer *rend, D3D11PipelineState *state)
+ReplayRenderer_GetD3D11PipelineState(IReplayRenderer *rend, D3D11Pipe::State *state)
 {
   return rend->GetD3D11PipelineState(state);
 }

renderdoc/replay/replay_renderer.h

@@ -137,7 +137,7 @@ public:
 
   void FetchPipelineState();
 
-  bool GetD3D11PipelineState(D3D11PipelineState *state);
+  bool GetD3D11PipelineState(D3D11Pipe::State *state);
   bool GetD3D12PipelineState(D3D12PipelineState *state);
   bool GetGLPipelineState(GLPipelineState *state);
   bool GetVulkanPipelineState(VulkanPipelineState *state);
@@ -209,7 +209,7 @@ private:
 
   uint32_t m_EventID;
 
-  D3D11PipelineState m_D3D11PipelineState;
+  D3D11Pipe::State m_D3D11PipelineState;
   D3D12PipelineState m_D3D12PipelineState;
   GLPipelineState m_GLPipelineState;
   VulkanPipelineState m_VulkanPipelineState;