VideoBackends: Add AbstractShader and AbstractPipeline classes

Source/Core/VideoBackends/D3D/DXShader.cpp

@@ -0,0 +1,183 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include "Common/Assert.h"
+
+#include "VideoBackends/D3D/D3DBase.h"
+#include "VideoBackends/D3D/D3DShader.h"
+#include "VideoBackends/D3D/DXShader.h"
+
+namespace DX11
+{
+DXShader::DXShader(D3DBlob* bytecode, ID3D11VertexShader* vs)
+    : AbstractShader(ShaderStage::Vertex), m_bytecode(bytecode), m_shader(vs)
+{
+}
+
+DXShader::DXShader(D3DBlob* bytecode, ID3D11GeometryShader* gs)
+    : AbstractShader(ShaderStage::Geometry), m_bytecode(bytecode), m_shader(gs)
+{
+}
+
+DXShader::DXShader(D3DBlob* bytecode, ID3D11PixelShader* ps)
+    : AbstractShader(ShaderStage::Pixel), m_bytecode(bytecode), m_shader(ps)
+{
+}
+
+DXShader::DXShader(D3DBlob* bytecode, ID3D11ComputeShader* cs)
+    : AbstractShader(ShaderStage::Compute), m_bytecode(bytecode), m_shader(cs)
+{
+}
+
+DXShader::~DXShader()
+{
+  m_shader->Release();
+  m_bytecode->Release();
+}
+
+D3DBlob* DXShader::GetByteCode() const
+{
+  return m_bytecode;
+}
+
+ID3D11VertexShader* DXShader::GetD3DVertexShader() const
+{
+  _dbg_assert_(VIDEO, m_stage == ShaderStage::Vertex);
+  return static_cast<ID3D11VertexShader*>(m_shader);
+}
+
+ID3D11GeometryShader* DXShader::GetD3DGeometryShader() const
+{
+  _dbg_assert_(VIDEO, m_stage == ShaderStage::Geometry);
+  return static_cast<ID3D11GeometryShader*>(m_shader);
+}
+
+ID3D11PixelShader* DXShader::GetD3DPixelShader() const
+{
+  _dbg_assert_(VIDEO, m_stage == ShaderStage::Pixel);
+  return static_cast<ID3D11PixelShader*>(m_shader);
+}
+
+ID3D11ComputeShader* DXShader::GetD3DComputeShader() const
+{
+  _dbg_assert_(VIDEO, m_stage == ShaderStage::Compute);
+  return static_cast<ID3D11ComputeShader*>(m_shader);
+}
+
+bool DXShader::HasBinary() const
+{
+  _assert_(m_bytecode);
+  return true;
+}
+
+AbstractShader::BinaryData DXShader::GetBinary() const
+{
+  return BinaryData(m_bytecode->Data(), m_bytecode->Data() + m_bytecode->Size());
+}
+
+std::unique_ptr<DXShader> DXShader::CreateFromBlob(ShaderStage stage, D3DBlob* bytecode)
+{
+  switch (stage)
+  {
+  case ShaderStage::Vertex:
+  {
+    ID3D11VertexShader* vs = D3D::CreateVertexShaderFromByteCode(bytecode);
+    if (vs)
+      return std::make_unique<DXShader>(bytecode, vs);
+  }
+  break;
+
+  case ShaderStage::Geometry:
+  {
+    ID3D11GeometryShader* gs = D3D::CreateGeometryShaderFromByteCode(bytecode);
+    if (gs)
+      return std::make_unique<DXShader>(bytecode, gs);
+  }
+  break;
+
+  case ShaderStage::Pixel:
+  {
+    ID3D11PixelShader* ps = D3D::CreatePixelShaderFromByteCode(bytecode);
+    if (ps)
+      return std::make_unique<DXShader>(bytecode, ps);
+  }
+  break;
+
+  case ShaderStage::Compute:
+  {
+    ID3D11ComputeShader* cs = D3D::CreateComputeShaderFromByteCode(bytecode);
+    if (cs)
+      return std::make_unique<DXShader>(bytecode, cs);
+  }
+  break;
+
+  default:
+    break;
+  }
+
+  return nullptr;
+}
+
+std::unique_ptr<DXShader> DXShader::CreateFromSource(ShaderStage stage, const char* source,
+                                                     size_t length)
+{
+  D3DBlob* bytecode;
+  switch (stage)
+  {
+  case ShaderStage::Vertex:
+  {
+    if (!D3D::CompileVertexShader(std::string(source, length), &bytecode))
+      return nullptr;
+  }
+  break;
+
+  case ShaderStage::Geometry:
+  {
+    if (!D3D::CompileGeometryShader(std::string(source, length), &bytecode))
+      return nullptr;
+  }
+  break;
+
+  case ShaderStage::Pixel:
+  {
+    if (!D3D::CompilePixelShader(std::string(source, length), &bytecode))
+      return nullptr;
+  }
+  break;
+
+  case ShaderStage::Compute:
+  {
+    if (!D3D::CompileComputeShader(std::string(source, length), &bytecode))
+      return nullptr;
+  }
+
+  default:
+    return nullptr;
+  }
+
+  std::unique_ptr<DXShader> shader = CreateFromBlob(stage, bytecode);
+  if (!shader)
+  {
+    bytecode->Release();
+    return nullptr;
+  }
+
+  return shader;
+}
+
+std::unique_ptr<DXShader> DXShader::CreateFromBinary(ShaderStage stage, const void* data,
+                                                     size_t length)
+{
+  D3DBlob* bytecode = new D3DBlob(static_cast<unsigned int>(length), static_cast<const u8*>(data));
+  std::unique_ptr<DXShader> shader = CreateFromBlob(stage, bytecode);
+  if (!shader)
+  {
+    bytecode->Release();
+    return nullptr;
+  }
+
+  return shader;
+}
+
+}  // namespace DX11