CMake/Tests/VSWinStorePhone/Direct3DApp1/Direct3DBase.cpp

#include "pch.h"
#include "Direct3DBase.h"

using namespace DirectX;
using namespace Microsoft::WRL;
using namespace Windows::UI::Core;
using namespace Windows::Foundation;
using namespace Windows::Graphics::Display;

// Constructor.
Direct3DBase::Direct3DBase()
{
}

// Initialize the Direct3D resources required to run.
void Direct3DBase::Initialize(CoreWindow^ window)
{
  m_window = window;

  CreateDeviceResources();
  CreateWindowSizeDependentResources();
}

// Recreate all device resources and set them back to the current state.
void Direct3DBase::HandleDeviceLost()
{
  // Reset these member variables to ensure that UpdateForWindowSizeChange recreates all resources.
  m_windowBounds.Width = 0;
  m_windowBounds.Height = 0;
  m_swapChain = nullptr;

  CreateDeviceResources();
  UpdateForWindowSizeChange();
}

// These are the resources that depend on the device.
void Direct3DBase::CreateDeviceResources()
{
  // This flag adds support for surfaces with a different color channel ordering
  // than the API default. It is required for compatibility with Direct2D.
  UINT creationFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;

#if defined(_DEBUG)
  // If the project is in a debug build, enable debugging via SDK Layers with this flag.
  creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif

  // This array defines the set of DirectX hardware feature levels this app will support.
  // Note the ordering should be preserved.
  // Don't forget to declare your application's minimum required feature level in its
  // description.  All applications are assumed to support 9.1 unless otherwise stated.
  D3D_FEATURE_LEVEL featureLevels[] =
  {
    D3D_FEATURE_LEVEL_11_1,
    D3D_FEATURE_LEVEL_11_0,
    D3D_FEATURE_LEVEL_10_1,
    D3D_FEATURE_LEVEL_10_0,
    D3D_FEATURE_LEVEL_9_3,
    D3D_FEATURE_LEVEL_9_2,
    D3D_FEATURE_LEVEL_9_1
  };

  // Create the Direct3D 11 API device object and a corresponding context.
  ComPtr<ID3D11Device> device;
  ComPtr<ID3D11DeviceContext> context;
  DX::ThrowIfFailed(
    D3D11CreateDevice(
      nullptr, // Specify nullptr to use the default adapter.
      D3D_DRIVER_TYPE_HARDWARE,
      nullptr,
      creationFlags, // Set set debug and Direct2D compatibility flags.
      featureLevels, // List of feature levels this app can support.
      ARRAYSIZE(featureLevels),
      D3D11_SDK_VERSION, // Always set this to D3D11_SDK_VERSION for Windows Store apps.
      &device, // Returns the Direct3D device created.
      &m_featureLevel, // Returns feature level of device created.
      &context // Returns the device immediate context.
      )
    );

  // Get the Direct3D 11.1 API device and context interfaces.
  DX::ThrowIfFailed(
    device.As(&m_d3dDevice)
    );

  DX::ThrowIfFailed(
    context.As(&m_d3dContext)
    );
}

// Allocate all memory resources that change on a window SizeChanged event.
void Direct3DBase::CreateWindowSizeDependentResources()
{
  // Store the window bounds so the next time we get a SizeChanged event we can
  // avoid rebuilding everything if the size is identical.
  m_windowBounds = m_window->Bounds;

  // Calculate the necessary swap chain and render target size in pixels.
  float windowWidth = ConvertDipsToPixels(m_windowBounds.Width);
  float windowHeight = ConvertDipsToPixels(m_windowBounds.Height);

  // The width and height of the swap chain must be based on the window's
  // landscape-oriented width and height. If the window is in a portrait
  // orientation, the dimensions must be reversed.
#if WINVER > 0x0602
  m_orientation = DisplayInformation::GetForCurrentView()->CurrentOrientation;
#else
#if PHONE
  // WP8 doesn't support rotations so always make it landscape
  m_orientation = DisplayOrientations::Landscape;
#else
  m_orientation = DisplayProperties::CurrentOrientation;
#endif
#endif
  bool swapDimensions =
    m_orientation == DisplayOrientations::Portrait ||
    m_orientation == DisplayOrientations::PortraitFlipped;
  m_renderTargetSize.Width = swapDimensions ? windowHeight : windowWidth;
  m_renderTargetSize.Height = swapDimensions ? windowWidth : windowHeight;

  if(m_swapChain != nullptr)
  {
    // If the swap chain already exists, resize it.
    DX::ThrowIfFailed(
      m_swapChain->ResizeBuffers(
        2, // Double-buffered swap chain.
        static_cast<UINT>(m_renderTargetSize.Width),
        static_cast<UINT>(m_renderTargetSize.Height),
        DXGI_FORMAT_B8G8R8A8_UNORM,
        0
        )
      );
  }
  else
  {
    // Otherwise, create a new one using the same adapter as the existing Direct3D device.
    DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {0};
    swapChainDesc.Width = static_cast<UINT>(m_renderTargetSize.Width); // Match the size of the window.
    swapChainDesc.Height = static_cast<UINT>(m_renderTargetSize.Height);
    swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; // This is the most common swap chain format.
    swapChainDesc.Stereo = false;
    swapChainDesc.SampleDesc.Count = 1; // Don't use multi-sampling.
    swapChainDesc.SampleDesc.Quality = 0;
    swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
#if PHONE && WINVER <= 0x0602
    swapChainDesc.BufferCount = 1; // Use double-buffering to minimize latency.
    swapChainDesc.Scaling = DXGI_SCALING_STRETCH; // On phone, only stretch and aspect-ratio stretch scaling are allowed.
    swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; // On phone, no swap effects are supported.
#else
    swapChainDesc.BufferCount = 2; // Use double-buffering to minimize latency.
    swapChainDesc.Scaling = DXGI_SCALING_NONE;
    swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; // All Windows Store apps must use this SwapEffect.
#endif
    swapChainDesc.Flags = 0;

    ComPtr<IDXGIDevice1>  dxgiDevice;
    DX::ThrowIfFailed(
      m_d3dDevice.As(&dxgiDevice)
      );

    ComPtr<IDXGIAdapter> dxgiAdapter;
    DX::ThrowIfFailed(
      dxgiDevice->GetAdapter(&dxgiAdapter)
      );

    ComPtr<IDXGIFactory2> dxgiFactory;
    DX::ThrowIfFailed(
      dxgiAdapter->GetParent(
        __uuidof(IDXGIFactory2),
        &dxgiFactory
        )
      );

    Windows::UI::Core::CoreWindow^ window = m_window.Get();
    DX::ThrowIfFailed(
      dxgiFactory->CreateSwapChainForCoreWindow(
        m_d3dDevice.Get(),
        reinterpret_cast<IUnknown*>(window),
        &swapChainDesc,
        nullptr, // Allow on all displays.
        &m_swapChain
        )
      );

    // Ensure that DXGI does not queue more than one frame at a time. This both reduces latency and
    // ensures that the application will only render after each VSync, minimizing power consumption.
    DX::ThrowIfFailed(
      dxgiDevice->SetMaximumFrameLatency(1)
      );
  }

  // Set the proper orientation for the swap chain, and generate the
  // 3D matrix transformation for rendering to the rotated swap chain.
  DXGI_MODE_ROTATION rotation = DXGI_MODE_ROTATION_UNSPECIFIED;
  switch (m_orientation)
  {
    case DisplayOrientations::Landscape:
      rotation = DXGI_MODE_ROTATION_IDENTITY;
      m_orientationTransform3D = XMFLOAT4X4( // 0-degree Z-rotation
        1.0f, 0.0f, 0.0f, 0.0f,
        0.0f, 1.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 1.0f, 0.0f,
        0.0f, 0.0f, 0.0f, 1.0f
        );
      break;

    case DisplayOrientations::Portrait:
      rotation = DXGI_MODE_ROTATION_ROTATE270;
      m_orientationTransform3D = XMFLOAT4X4( // 90-degree Z-rotation
        0.0f, 1.0f, 0.0f, 0.0f,
        -1.0f, 0.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 1.0f, 0.0f,
        0.0f, 0.0f, 0.0f, 1.0f
        );
      break;

    case DisplayOrientations::LandscapeFlipped:
      rotation = DXGI_MODE_ROTATION_ROTATE180;
      m_orientationTransform3D = XMFLOAT4X4( // 180-degree Z-rotation
        -1.0f, 0.0f, 0.0f, 0.0f,
        0.0f, -1.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 1.0f, 0.0f,
        0.0f, 0.0f, 0.0f, 1.0f
        );
      break;

    case DisplayOrientations::PortraitFlipped:
      rotation = DXGI_MODE_ROTATION_ROTATE90;
      m_orientationTransform3D = XMFLOAT4X4( // 270-degree Z-rotation
        0.0f, -1.0f, 0.0f, 0.0f,
        1.0f, 0.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 1.0f, 0.0f,
        0.0f, 0.0f, 0.0f, 1.0f
        );
      break;

    default:
      throw ref new Platform::FailureException();
  }

#if !PHONE || WINVER > 0x0602
  DX::ThrowIfFailed(
    m_swapChain->SetRotation(rotation)
    );
#endif // !PHONE

  // Create a render target view of the swap chain back buffer.
  ComPtr<ID3D11Texture2D> backBuffer;
  DX::ThrowIfFailed(
    m_swapChain->GetBuffer(
      0,
      __uuidof(ID3D11Texture2D),
      &backBuffer
      )
    );

  DX::ThrowIfFailed(
    m_d3dDevice->CreateRenderTargetView(
      backBuffer.Get(),
      nullptr,
      &m_renderTargetView
      )
    );

  // Create a depth stencil view.
  CD3D11_TEXTURE2D_DESC depthStencilDesc(
    DXGI_FORMAT_D24_UNORM_S8_UINT,
    static_cast<UINT>(m_renderTargetSize.Width),
    static_cast<UINT>(m_renderTargetSize.Height),
    1,
    1,
    D3D11_BIND_DEPTH_STENCIL
    );

  ComPtr<ID3D11Texture2D> depthStencil;
  DX::ThrowIfFailed(
    m_d3dDevice->CreateTexture2D(
      &depthStencilDesc,
      nullptr,
      &depthStencil
      )
    );

  CD3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc(D3D11_DSV_DIMENSION_TEXTURE2D);
  DX::ThrowIfFailed(
    m_d3dDevice->CreateDepthStencilView(
      depthStencil.Get(),
      &depthStencilViewDesc,
      &m_depthStencilView
      )
    );

  // Set the rendering viewport to target the entire window.
  CD3D11_VIEWPORT viewport(
    0.0f,
    0.0f,
    m_renderTargetSize.Width,
    m_renderTargetSize.Height
    );

  m_d3dContext->RSSetViewports(1, &viewport);
}

// This method is called in the event handler for the SizeChanged event.
void Direct3DBase::UpdateForWindowSizeChange()
{
  if (m_window->Bounds.Width != m_windowBounds.Width ||
    m_window->Bounds.Height != m_windowBounds.Height ||
#if WINVER > 0x0602
    m_orientation != DisplayInformation::GetForCurrentView()->CurrentOrientation)
#else
    m_orientation != DisplayProperties::CurrentOrientation)
#endif
  {
    ID3D11RenderTargetView* nullViews[] = {nullptr};
    m_d3dContext->OMSetRenderTargets(ARRAYSIZE(nullViews), nullViews, nullptr);
    m_renderTargetView = nullptr;
    m_depthStencilView = nullptr;
    m_d3dContext->Flush();
    CreateWindowSizeDependentResources();
  }
}

void Direct3DBase::ReleaseResourcesForSuspending()
{
  // Phone applications operate in a memory-constrained environment, so when entering
  // the background it is a good idea to free memory-intensive objects that will be
  // easy to restore upon reactivation. The swapchain and backbuffer are good candidates
  // here, as they consume a large amount of memory and can be reinitialized quickly.
  m_swapChain = nullptr;
  m_renderTargetView = nullptr;
  m_depthStencilView = nullptr;
}

// Method to deliver the final image to the display.
void Direct3DBase::Present()
{
  // The first argument instructs DXGI to block until VSync, putting the application
  // to sleep until the next VSync. This ensures we don't waste any cycles rendering
  // frames that will never be displayed to the screen.
#if PHONE && WINVER <= 0x0602
  HRESULT hr = m_swapChain->Present(1, 0);
#else
  // The application may optionally specify "dirty" or "scroll"
  // rects to improve efficiency in certain scenarios.
  DXGI_PRESENT_PARAMETERS parameters = { 0 };
  parameters.DirtyRectsCount = 0;
  parameters.pDirtyRects = nullptr;
  parameters.pScrollRect = nullptr;
  parameters.pScrollOffset = nullptr;

  HRESULT hr = m_swapChain->Present1(1, 0 , &parameters);
#endif

  // Discard the contents of the render target.
  // This is a valid operation only when the existing contents will be entirely
  // overwritten. If dirty or scroll rects are used, this call should be removed.
  m_d3dContext->DiscardView(m_renderTargetView.Get());

  // Discard the contents of the depth stencil.
  m_d3dContext->DiscardView(m_depthStencilView.Get());

  // If the device was removed either by a disconnect or a driver upgrade, we
  // must recreate all device resources.
  if (hr == DXGI_ERROR_DEVICE_REMOVED)
  {
    HandleDeviceLost();
  }
  else
  {
    DX::ThrowIfFailed(hr);
  }
}

// Method to convert a length in device-independent pixels (DIPs) to a length in physical pixels.
float Direct3DBase::ConvertDipsToPixels(float dips)
{
  static const float dipsPerInch = 96.0f;
#if WINVER > 0x0602
  return floor(dips * DisplayInformation::GetForCurrentView()->LogicalDpi / dipsPerInch + 0.5f); // Round to nearest integer.
#else
  return floor(dips * DisplayProperties::LogicalDpi / dipsPerInch + 0.5f); // Round to nearest integer.
#endif
}