#pragma region CPL License
/*
Nuclex Native Framework
Copyright (C) 2002-2013 Nuclex Development Labs

This library is free software; you can redistribute it and/or
modify it under the terms of the IBM Common Public License as
published by the IBM Corporation; either version 1.0 of the
License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
IBM Common Public License for more details.

You should have received a copy of the IBM Common Public
License along with this library
*/
#pragma endregion // CPL License

#ifndef NUCLEX_GRAPHICS_RASTERIZATION_DIRECT3D11RASTERIZER_IMPL_H
#define NUCLEX_GRAPHICS_RASTERIZATION_DIRECT3D11RASTERIZER_IMPL_H

#include "Nuclex/Graphics/Config.h"
#include "Nuclex/Graphics/Size.h"
#include "Nuclex/Graphics/Rasterization/Direct3D11Rasterizer.h"
#include "Direct3D11RasterizerResources.h"
#include "Direct3D11RasterizerSettings.h"
#include "Direct3D11RasterizerState.h"
#include "Direct3D11InputLayoutManager.h"

// WinRT doesn't allow 'public' members in ref classes, so we need to use different
// access specifiers depending on whether we're Win32 + ISO C++ or WinRT + C++/CX.
#if defined(NUCLEX_GRAPHICS_WINRT)
  #define internal internal
#else
  #define internal public
#endif

namespace Nuclex { namespace Graphics { namespace Rasterization {

  // ------------------------------------------------------------------------------------------- //

#if defined(NUCLEX_GRAPHICS_WINRT)

  /// <summary>Manages the private implementation of the Direct3D 11 rasterizer</summary>
  ref struct Direct3D11Rasterizer::Impl {

    /// <summary>Initializes a new Direct3D 11 polygon renderer</summary>
    /// <param name="window">Window into which to render</param>
    internal: Impl(Windows::UI::Core::CoreWindow ^window);

#else

  /// <summary>Manages the private implementation of the Direct3D 11 rasterizer</summary>
  struct Direct3D11Rasterizer::Impl {

    /// <summary>Initializes a new Direct3D 11 polygon renderer</summary>
    /// <param name="windowHandle">Handle of the window into which to render</param>
    public: Impl(HWND windowHandle);

#endif

    /// <summary>Destroy the Direct3D 11 polygon renderer</summary>
    public: ~Impl();

    /// <summary>Retrieves the Direct3D device currently created</summary>
    /// <returns>The current Direct3D device</returns>
    internal: const ID3D11DeviceNPtr &GetDirect3DDevice() const;

    /// <summary>Retrieves the context of the current Direct3D device</summary>
    /// <returns>The context of the current Direct3D device</returns>
    internal: const ID3D11DeviceContextNPtr &GetDirect3DDeviceContext() const;

    /// <summary>Retrieves the swap chain used for the Direct3D device's view</summary>
    /// <returns>The swap chain used to present the view of the Direct3D device>/returns>
    internal: const IDXGISwapChainNPtr &GetSwapChain() const;

    /// <summary>Returns the size of the viewing area</summary>
    /// <returns>The size of the viewing area</returns>
    internal: Size GetViewSize() const;

    /// <summary>Prepares a default swap chain description</summary>
    /// <returns>The default swap chain description</returns>
    private: static DXGI_SWAP_CHAIN_DESCN getDefaultSwapChainDescription();

    /// <summary>Retrieves the Direct3D 11 device's graphics resource factory</summary>
    /// <param name="device">Direct3D 11 whose resource facotry will be returned</param>
    /// <returns>The graphics resource factory for the Direct3D 11 device</returns>
    private: static IDXGIFactoryNPtr getDxgiFactory(const ID3D11DevicePtr &device);

    /// <summary>Creates the Direct3D device the rasterizer will use</summary>
    private: void createDirect3DDevice();

    /// <summary>Creates the swap chain through which the image is presented</summary>
    private: void createSwapChain();

    /// <summary>Called when the window could have been resized</summary>
    /// <param name="width">New width of the window</param>
    /// <param name="height">New height of the window</param>
    private: void viewResized(std::size_t width, std::size_t height);

#if defined(NUCLEX_GRAPHICS_WINRT)

    /// <summary>Called when the size of the window has changed</summary>
    /// <param name="window">Window whose size has changed</param>
    /// <param name="arguments">Contains the new window size</param>
    private: void sizeChanged(
      Windows::UI::Core::CoreWindow ^window,
      Windows::UI::Core::WindowSizeChangedEventArgs ^arguments
    );

#else

    /// <summary>Subclasses the game's window to listen in on Window messages</summary>
    private: void subclassWindow();

    /// <summary>Unsubclasses the game's window again</summary>
    private: void unsubclassWindow();

    /// <summary>Message procedure used to intercept messages to the game's window</summary>
    /// <param name="windowHandle">Handle of the window received the message</param>
    /// <param name="message">Type of message being sent to the window</param>
    /// <param name="parameter1">First message-dependent parameter</param>
    /// <param name="parameter2">Second message-dependent parameter</param>
    private: static LRESULT CALLBACK windowProcedure(
      HWND windowHandle, UINT message, WPARAM parameter1, LPARAM parameter2
    );

#endif

    /// <summary>Responsible for the rasterizer's resource management</summary>
    internal: Direct3D11RasterizerResources Resources;
    /// <summary>Responsible for the rasterizer's settings management</summary>
    internal: Direct3D11RasterizerSettings Settings;
    /// <summary>Responsible for the rasterizer's state management</summary>
    internal: Direct3D11RasterizerState State;
    /// <summary>Responsible for creating and caching shader input layouts</summary>
    internal: Direct3D11InputLayoutManager InputLayouts;

#if defined(NUCLEX_GRAPHICS_WINRT)
    /// <summary>Window the rasterizer renders into</summary>
    private: Platform::Agile<Windows::UI::Core::CoreWindow> window;
    /// <summary>Token for the subscription to the SizeChanged event</summary>
    private: Windows::Foundation::EventRegistrationToken sizeChangedEventToken;
#else
    /// <summary>Handle of the window the rasterizer renders into</summary>
    private: HWND windowHandle;
    /// <summary>The subclassed window's old window message procedure</summary>
    private: WNDPROC oldWindowProc;
#endif
    /// <summary>Direct3D device the rasterizer uses for rendering</summary>
    private: ID3D11DeviceNPtr device;
    /// <summary>Direct3D device context through which state is managed</summary>
    private: ID3D11DeviceContextNPtr context;
    /// <summary>Swap chain used to present the rendered image on the screen</summary>
    private: IDXGISwapChainNPtr swapChain;
    /// <summary>Direct3D feature level the device actually supports</summary>
    private: D3D_FEATURE_LEVEL supportedFeatureLevel;
    /// <summary>Settings for the swap chain used to present the rendered image</summary>
    private: DXGI_SWAP_CHAIN_DESCN swapChainDescription;
    /// <summary>Current width of the rendering window's client rectangle</summary>
    private: std::size_t width;
    /// <summary>Current height of the rendering window's client rectangle</summary>
    private: std::size_t height;

  };

  // ------------------------------------------------------------------------------------------- //

}}} // namespace Nuclex::Graphics::Rasterization

#undef internal

#endif // NUCLEX_GRAPHICS_RASTERIZATION_DIRECT3D11RASTERIZER_IMPL_H