D3D11 window up and spinning.

src/xenia/gpu/d3d11/d3d11_graphics_driver.cc

@@ -19,11 +19,15 @@ using namespace xe::gpu::d3d11;
 using namespace xe::gpu::xenos;
 
 
-D3D11GraphicsDriver::D3D11GraphicsDriver(xe_memory_ref memory) :
+D3D11GraphicsDriver::D3D11GraphicsDriver(
+    xe_memory_ref memory, ID3D11Device* device) :
     GraphicsDriver(memory) {
+  device_ = device;
+  device_->AddRef();
 }
 
 D3D11GraphicsDriver::~D3D11GraphicsDriver() {
+  device_->Release();
 }
 
 void D3D11GraphicsDriver::Initialize() {

src/xenia/gpu/d3d11/d3d11_graphics_driver.h

@@ -16,6 +16,8 @@
 #include <xenia/gpu/d3d11/d3d11-private.h>
 #include <xenia/gpu/xenos/xenos.h>
 
+#include <d3d11.h>
+
 
 namespace xe {
 namespace gpu {
@@ -24,7 +26,7 @@ namespace d3d11 {
 
 class D3D11GraphicsDriver : public GraphicsDriver {
 public:
-  D3D11GraphicsDriver(xe_memory_ref memory);
+  D3D11GraphicsDriver(xe_memory_ref memory, ID3D11Device* device);
   virtual ~D3D11GraphicsDriver();
 
   virtual void Initialize();
@@ -40,7 +42,8 @@ public:
       xenos::XE_GPU_PRIMITIVE_TYPE prim_type,
       uint32_t index_count);
 
-protected:
+private:
+  ID3D11Device*   device_;
 };
 
 

src/xenia/gpu/d3d11/d3d11_graphics_system.cc

@@ -11,6 +11,7 @@
 
 #include <xenia/gpu/gpu-private.h>
 #include <xenia/gpu/d3d11/d3d11_graphics_driver.h>
+#include <xenia/gpu/d3d11/d3d11_window.h>
 
 
 using namespace xe;
@@ -18,14 +19,120 @@ using namespace xe::gpu;
 using namespace xe::gpu::d3d11;
 
 
+namespace {
+
+}
+
+
 D3D11GraphicsSystem::D3D11GraphicsSystem(const CreationParams* params) :
+    window_(0), dxgi_factory_(0), device_(0),
     GraphicsSystem(params) {
 }
 
 D3D11GraphicsSystem::~D3D11GraphicsSystem() {
+  if (device_)        device_->Release();
+  if (dxgi_factory_)  dxgi_factory_->Release();
+  delete window_;
 }
 
 void D3D11GraphicsSystem::Initialize() {
+  GraphicsSystem::Initialize();
+
+  // Create DXGI factory so we can get a swap chain/etc.
+  HRESULT hr = CreateDXGIFactory1(__uuidof(IDXGIFactory1),
+                                  (void**)&dxgi_factory_);
+  if (FAILED(hr)) {
+    XELOGE("CreateDXGIFactory1 failed with %.8X", hr);
+    exit(1);
+    return;
+  }
+
+  // Find the best adapter.
+  // TODO(benvanik): enable nvperfhud/etc.
+  IDXGIAdapter1* adapter = 0;
+  UINT n = 0;
+  while (dxgi_factory_->EnumAdapters1(n, &adapter) != DXGI_ERROR_NOT_FOUND) {
+    DXGI_ADAPTER_DESC1 desc;
+    adapter->GetDesc1(&desc);
+    adapter->Release();
+    n++;
+  }
+  // Just go with the default for now.
+  adapter = 0;
+  
+  D3D_DRIVER_TYPE driver_type =
+      adapter ? D3D_DRIVER_TYPE_UNKNOWN : D3D_DRIVER_TYPE_HARDWARE;
+
+  UINT flags = 0;
+  // TODO(benvanik): runtime flag
+  flags |= D3D11_CREATE_DEVICE_DEBUG;
+
+  // Feature level 11.0+ only.
+  D3D_FEATURE_LEVEL feature_levels[] = {
+    D3D_FEATURE_LEVEL_11_0,
+  };
+
+  // Create device.
+  D3D_FEATURE_LEVEL actual_feature_level;
+  ID3D11DeviceContext* immediate_context;
+  hr = D3D11CreateDevice(
+      adapter,
+      driver_type,
+      0, // software driver HMODULE
+      flags,
+      feature_levels,
+      XECOUNT(feature_levels),
+      D3D11_SDK_VERSION,
+      &device_,
+      &actual_feature_level,
+      &immediate_context);
+  if (adapter) {
+    adapter->Release();
+    adapter = 0;
+  }
+  if (immediate_context) {
+    immediate_context->Release();
+    immediate_context = 0;
+  }
+  if (FAILED(hr)) {
+    XELOGE("D3D11CreateDevice failed with %.8X", hr);
+    exit(1);
+    return;
+  }
+
+  // Create the window.
+  // This will pump through the run-loop and and be where our swapping
+  // will take place.
+  XEASSERTNULL(window_);
+  window_ = new D3D11Window(run_loop_, dxgi_factory_, device_);
+  window_->set_title(XETEXT("Xenia D3D11"));
+
+  // Listen for alt-enter/etc.
+  dxgi_factory_->MakeWindowAssociation(window_->handle(), 0);
+
+  // Create the driver.
+  // This runs in the worker thread and builds command lines to present
+  // in the window.
   XEASSERTNULL(driver_);
-  driver_ = new D3D11GraphicsDriver(memory_);
+  driver_ = new D3D11GraphicsDriver(memory_, device_);
+
+  // Initial vsync kick.
+  DispatchInterruptCallback();
+}
+
+void D3D11GraphicsSystem::Pump() {
+  if (swap_pending_) {
+    swap_pending_ = false;
+
+    // Swap window.
+    // If we are set to vsync this will block.
+    window_->Swap();
+
+    // Dispatch interrupt callback to let the game know it can keep drawing.
+    DispatchInterruptCallback();
+  }
+}
+
+void D3D11GraphicsSystem::Shutdown() {
+  GraphicsSystem::Shutdown();
 }

src/xenia/gpu/d3d11/d3d11_graphics_system.h

@@ -15,11 +15,15 @@
 #include <xenia/gpu/graphics_system.h>
 #include <xenia/gpu/d3d11/d3d11-private.h>
 
+#include <d3d11.h>
+
 
 namespace xe {
 namespace gpu {
 namespace d3d11 {
 
+class D3D11Window;
+
 
 GraphicsSystem* Create(const CreationParams* params);
 
@@ -29,7 +33,15 @@ public:
   D3D11GraphicsSystem(const CreationParams* params);
   virtual ~D3D11GraphicsSystem();
 
+protected:
   virtual void Initialize();
+  virtual void Pump();
+  virtual void Shutdown();
+
+private:
+  IDXGIFactory1*  dxgi_factory_;
+  ID3D11Device*   device_;
+  D3D11Window*    window_;
 };
 
 

src/xenia/gpu/d3d11/d3d11_shader.cc

@@ -0,0 +1,22 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2013 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#include <xenia/gpu/d3d11/d3d11_shader.h>
+
+
+using namespace xe;
+using namespace xe::gpu;
+using namespace xe::gpu::d3d11;
+
+
+D3D11Shader::D3D11Shader() {
+}
+
+D3D11Shader::~D3D11Shader() {
+}

src/xenia/gpu/d3d11/d3d11_shader.h

@@ -0,0 +1,35 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2013 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#ifndef XENIA_GPU_D3D11_D3D11_SHADER_H_
+#define XENIA_GPU_D3D11_D3D11_SHADER_H_
+
+#include <xenia/core.h>
+
+#include <xenia/gpu/shader.h>
+
+
+namespace xe {
+namespace gpu {
+namespace d3d11 {
+
+
+class D3D11Shader : public Shader {
+public:
+  D3D11Shader();
+  virtual ~D3D11Shader();
+};
+
+
+}  // namespace d3d11
+}  // namespace gpu
+}  // namespace xe
+
+
+#endif  // XENIA_GPU_D3D11_D3D11_SHADER_H_

src/xenia/gpu/d3d11/d3d11_shader_cache.cc

@@ -0,0 +1,22 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2013 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#include <xenia/gpu/d3d11/d3d11_shader_cache.h>
+
+
+using namespace xe;
+using namespace xe::gpu;
+using namespace xe::gpu::d3d11;
+
+
+D3D11ShaderCache::D3D11ShaderCache() {
+}
+
+D3D11ShaderCache::~D3D11ShaderCache() {
+}

src/xenia/gpu/d3d11/d3d11_shader_cache.h

@@ -0,0 +1,35 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2013 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#ifndef XENIA_GPU_D3D11_D3D11_SHADER_CACHE_H_
+#define XENIA_GPU_D3D11_D3D11_SHADER_CACHE_H_
+
+#include <xenia/core.h>
+
+#include <xenia/gpu/shader_cache.h>
+
+
+namespace xe {
+namespace gpu {
+namespace d3d11 {
+
+
+class D3D11ShaderCache : public ShaderCache {
+public:
+  D3D11ShaderCache();
+  virtual ~D3D11ShaderCache();
+};
+
+
+}  // namespace d3d11
+}  // namespace gpu
+}  // namespace xe
+
+
+#endif  // XENIA_GPU_D3D11_D3D11_SHADER_CACHE_H_

src/xenia/gpu/d3d11/d3d11_window.cc

@@ -0,0 +1,124 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2013 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#include <xenia/gpu/d3d11/d3d11_window.h>
+
+
+using namespace xe;
+using namespace xe::core;
+using namespace xe::gpu;
+using namespace xe::gpu::d3d11;
+
+
+D3D11Window::D3D11Window(
+    xe_run_loop_ref run_loop,
+    IDXGIFactory1* dxgi_factory, ID3D11Device* device) :
+    Win32Window(run_loop) {
+  dxgi_factory_ = dxgi_factory;
+  dxgi_factory_->AddRef();
+  device_ = device;
+  device_->AddRef();
+  device_->GetImmediateContext(&context_);
+
+  swap_chain_ = 0;
+  render_target_view_ = 0;
+
+  // Setup swap chain.
+  DXGI_SWAP_CHAIN_DESC desc;
+  xe_zero_struct(&desc, sizeof(desc));
+  desc.OutputWindow       = handle_;
+  desc.Windowed           = TRUE;
+  desc.SwapEffect         = DXGI_SWAP_EFFECT_DISCARD;
+  desc.Flags              = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
+
+  // Setup buffers.
+  desc.BufferCount        = 2;
+  desc.BufferUsage        = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+  desc.BufferDesc.Width   = width_;
+  desc.BufferDesc.Height  = height_;
+  desc.BufferDesc.Format  = DXGI_FORMAT_R8G8B8A8_UNORM;
+  desc.BufferDesc.RefreshRate.Numerator   = 60;
+  desc.BufferDesc.RefreshRate.Denominator = 1;
+
+  // Disable multisampling.
+  desc.SampleDesc.Count   = 1;
+  desc.SampleDesc.Quality = 0;
+
+  // Create!
+  HRESULT hr = dxgi_factory_->CreateSwapChain(
+      device_,
+      &desc,
+      &swap_chain_);
+  if (FAILED(hr)) {
+    XELOGE("CreateSwapChain failed with %.8X", hr);
+    exit(1);
+    return;
+  }
+
+  // Create a render target view to draw into.
+  ID3D11Texture2D* back_buffer = 0;
+  hr = swap_chain_->GetBuffer(
+      0, __uuidof(ID3D11Texture2D), (void**)&back_buffer);
+  if (FAILED(hr)) {
+    XELOGE("GetBuffer (back_buffer) failed with %.8X", hr);
+    exit(1);
+    return;
+  }
+  hr = device_->CreateRenderTargetView(
+      back_buffer, NULL, &render_target_view_);
+  back_buffer->Release();
+  if (FAILED(hr)) {
+    XELOGE("CreateRenderTargetView (back_buffer) failed with %.8X", hr);
+    exit(1);
+    return;
+  }
+  context_->OMSetRenderTargets(1, &render_target_view_, NULL);
+}
+
+D3D11Window::~D3D11Window() {
+  if (render_target_view_)  render_target_view_->Release();
+  if (context_) {
+    context_->ClearState();
+    context_->Release();
+  }
+  if (swap_chain_)    swap_chain_->Release();
+  if (device_)        device_->Release();
+  if (dxgi_factory_)  dxgi_factory_->Release();
+}
+
+void D3D11Window::Swap() {
+  // Setup the viewport.
+  //D3D11_VIEWPORT viewport;
+  //viewport.MinDepth = 0.0f;
+  //viewport.MaxDepth = 1.0f;
+  //viewport.TopLeftX = 0;
+  //viewport.TopLeftY = 0;
+  //viewport.Width    = (FLOAT)width_;
+  //viewport.Height   = (FLOAT)height_;
+  //context_->RSSetViewports(1, &viewport);
+
+  // Swap buffers.
+  // TODO(benvanik): control vsync with flag.
+  bool vsync = true;
+  HRESULT hr = swap_chain_->Present(vsync ? 1 : 0, 0);
+  if (FAILED(hr)) {
+    XELOGE("Present failed with %.8X", hr);
+  }
+}
+
+void D3D11Window::OnResize(uint32_t width, uint32_t height) {
+  Win32Window::OnResize(width, height);
+
+  // TODO(benvanik): resize swap buffers?
+}
+
+void D3D11Window::OnClose() {
+  // We are the master window - if they close us, quit!
+  xe_run_loop_quit(run_loop_);
+}

src/xenia/gpu/d3d11/d3d11_window.h

@@ -0,0 +1,50 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2013 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#ifndef XENIA_GPU_D3D11_D3D11_WINDOW_H_
+#define XENIA_GPU_D3D11_D3D11_WINDOW_H_
+
+#include <xenia/core.h>
+
+#include <d3d11.h>
+
+
+namespace xe {
+namespace gpu {
+namespace d3d11 {
+
+
+class D3D11Window : public xe::core::Win32Window {
+public:
+  D3D11Window(
+      xe_run_loop_ref run_loop,
+      IDXGIFactory1* dxgi_factory, ID3D11Device* device);
+  virtual ~D3D11Window();
+
+  void Swap();
+
+protected:
+  virtual void OnResize(uint32_t width, uint32_t height);
+  virtual void OnClose();
+
+private:
+  IDXGIFactory1*          dxgi_factory_;
+  ID3D11Device*           device_;
+  IDXGISwapChain*         swap_chain_;
+  ID3D11DeviceContext*    context_;
+  ID3D11RenderTargetView* render_target_view_;
+};
+
+
+}  // namespace d3d11
+}  // namespace gpu
+}  // namespace xe
+
+
+#endif  // XENIA_GPU_D3D11_D3D11_WINDOW_H_

src/xenia/gpu/d3d11/sources.gypi

@@ -8,5 +8,11 @@
     'd3d11_graphics_driver.h',
     'd3d11_graphics_system.cc',
     'd3d11_graphics_system.h',
+    'd3d11_shader.cc',
+    'd3d11_shader.h',
+    'd3d11_shader_cache.cc',
+    'd3d11_shader_cache.h',
+    'd3d11_window.cc',
+    'd3d11_window.h',
   ],
 }