#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_DIRECT3D11RASTERIZERSTATE_H
#define NUCLEX_GRAPHICS_RASTERIZATION_DIRECT3D11RASTERIZERSTATE_H

#include "Nuclex/Graphics/Config.h"
#include "Nuclex/Graphics/Rasterization/Topology.h"
#include "Nuclex/Graphics/Rasterization/Viewport.h"
#include "Nuclex/Graphics/Rasterization/Shader.h"
#include "Direct3D11Api.h"

#include <cstddef>
#include <memory>

namespace Nuclex { namespace Graphics { namespace Rasterization {

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

  class GenericIndexBuffer;
  class GenericVertexBuffer;
  class VertexShader;
  class PixelShader;
  class RenderTarget2;

  class Direct3D11RasterizerResources;
  class Direct3D11InputLayoutManager;

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

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

namespace Nuclex { namespace Graphics { namespace Rasterization {

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

  ///<summary>Manages the selected resources of the rasterizer</summary>
  class Direct3D11RasterizerState {

    /// <summary>Initializes the rasterizer state management system</summary>
    public: Direct3D11RasterizerState();

    /// <summary>Frees all resources owned by the state management system</summary>
    public: ~Direct3D11RasterizerState();

    /// <summary>Sets the Direct3D device whose state will be managed</summary>
    /// <param name="device">Direct3D 11 device whose state will be managed</param>
    public: void SetDirect3DDevice(const ID3D11DeviceNPtr &device) {
      this->device = device;
    }
 
    /// <summary>Sets the Direct3D device context for which the state will be managed</summary>
    /// <param name="context">Direct3D 11 device context the state will be managed for</param>
    public: void SetDirect3DDeviceContext(const ID3D11DeviceContextNPtr &context) {
      this->context = context;
    }

    /// <summary>Sets the vertex input layout manager that will be used</summary>
    /// <param name="inputLayouts">Input layout manager the state manager will use</param>
    public: void SetInputLayouts(Direct3D11InputLayoutManager *inputLayouts) {
      this->inputLayouts = inputLayouts;
    }

    /// <summary>Creates the render target for the back buffer</summary>
    /// <param name="swapChain">Swap chain the back buffer belongs to</param>
    public: void CreateBackBufferRenderTarget(const IDXGISwapChainNPtr &swapChain);

    /// <summary>
    ///   Called by the rasterizer to shut down before the swap chain is recreated.
    /// </summary>
    public: void ShutdownForSwapChainRecreation();

    /// <summary>Called by the rasterizer after the swap chain has been recreated</summary>
    /// <param name="width">New width of the swap chain</param>
    /// <param name="height">New height of the swap chain</param>
    public: void RestoreAfterSwapChainRecreation(
      std::size_t width, std::size_t height
    );

    /// <summary>Sets the resource manager the state manager will use</summary>
    /// <param name="resources">Resource manager that will be used</param>
    public: void SetResorces(Direct3D11RasterizerResources *resources) {
      this->resources = resources;
    }

    /// <summary>Counts the number of vertex streams usable by the rasterizer</summary>
    /// <returns>The number of vertex streams the rasterizer can access</returns>
    public: std::size_t CountAvailableVertexStreams() const;

    /// <summary>Returns the vertex buffer currently bound to the specified stream</summary>
    /// <param name="index">Index of the stream whose bound vertex buffer is returned</param>
    /// <returns>The vertex buffer bound to the specified stream</returns>
    public: const std::shared_ptr<GenericVertexBuffer> &GetVertexBuffer(
      std::size_t index
    ) const;

    /// <summary>Binds a vertex buffer to the specified stream</summary>
    /// <param name="index">Index of the stream the vertex buffer will be bound to</param>
    /// <param name="vertexBuffer">Vertex buffer that will be bound to the stream</param>
    public: void SetVertexBuffer(
      std::size_t index, const std::shared_ptr<GenericVertexBuffer> &vertexBuffer
    );

    /// <summary>Returns the index buffer currently bound</summary>
    /// <returns>The index buffer currently bound</returns>
    public: const std::shared_ptr<GenericIndexBuffer> &GetIndexBuffer() const {
      return this->indexBuffer;
    }

    /// <summary>Binds the index buffer that defines the vertex order</summary>
    /// <param name="indexBuffer">Index buffer that will be bound</param>
    public: void SetIndexBuffer(const std::shared_ptr<GenericIndexBuffer> &indexBuffer) {
      this->indexBuffer = indexBuffer;
    }

    /// <summary>
    ///   Retrieves the vertex shader the rasterizer is using to transform vertices
    /// </summary>
    /// <returns>The vertex shader that the rasterizer is using</returns>
    public: const std::shared_ptr<VertexShader> &GetVertexShader() const {
      return this->vertexShader;
    }

    /// <summary>Assigns the vertex shader that will be used to transform vertices</summary>
    /// <param name="vertexShader">Vertex shader the rasterizer will use</param>
    public: void SetVertexShader(const std::shared_ptr<VertexShader> &vertexShader) {
      this->vertexShader = vertexShader;
    }

    /// <summary>
    ///   Retrieves the pixel shader the rasterizer is using to determine pixel colors
    /// </summary>
    /// <returns>The pixel shader that the rasterizer is using</returns>
    public: const std::shared_ptr<PixelShader> &GetPixelShader() const {
      return this->pixelShader;
    }

    /// <summary>Assigns the pixel shader that will be used to determine pixel colors</summary>
    /// <param name="pixelShader">Pixel shader the rasterizer will use</param>
    public: void SetPixelShader(const std::shared_ptr<PixelShader> &pixelShader) {
      this->pixelShader = pixelShader;
    }

    /// <summary>Retrieves the render target for the primary rendering surface</summary>
    /// <returns>The render target representing the primary rendering surface</returns>
    public: const std::shared_ptr<RenderTarget2> &GetDefaultRenderTarget() {
      return this->backBufferRenderTarget;
    }

    /// <summary>Retrieves the current render target</summary>
    /// <returns>The current render target of  the rasterizer</returns>
    public: const std::shared_ptr<RenderTarget2> &GetRenderTarget() {
      return this->renderTarget;
    }

    /// <summary>Selects the render target onto which the rasterize will draw</summary>
    /// <param name="renderTarget">New render target to draw on</param>
    public: void SetRenderTarget(const std::shared_ptr<RenderTarget2> &renderTarget) {
      this->renderTarget = renderTarget;
    }

    /// <summary>Returns the currently configured vertex topology</summary>
    /// <returns>The topology currently used to connect vertices</returns>
    public: Topology::Enum GetTopology() const {
      return this->topology;
    }

    /// <summary>Changes the configured vertex topology</summary>
    /// <param name="topology">The topology to be used for connecting vertices</param>
    public: void SetTopology(Topology::Enum topology) {
      this->topology = topology;
    }

    /// <summary>Retrieves the current viewport the rasterizer renders to</summary>
    /// <returns>The rasterizer's current viewport</returns>
    public: const Viewport &GetViewport() const {
      return this->viewport;
    }

    /// <summary>Sets the viewport the rasterizer will render to</summary>
    /// <param name="viewport">Viewport the rasterizer will render to</param>
    public: void SetViewport(const Viewport &viewport) {
      this->viewport = viewport;
      this->viewportChanged = true;
      this->isUsingDefaultViewport = false;
    }

    /// <summary>
    ///   Applies the changes affecting the rasterization of vertices to the device
    /// </summary>
    public: void ApplyChangesForVertexRasterization() {
      assignViewportIfChanged();
      assignTopologyIfChanged();
      assignVertexBufferIfChanged();
      assignVertexShaderConstantBufferIfChanged();
      assignVertexShaderTextureIfChanged();
      assignVertexShaderIfChanged();
      assignPixelShaderConstantBufferIfChanged();
      assignPixelShaderTextureIfChanged();
      assignPixelShaderIfChanged();
      assignRenderTargetIfChanged();
    }

    /// <summary>
    ///   Applies the changes affecting the rasterization of indexed vertices to the device
    /// </summary>
    public: void ApplyChangesForIndexedVertexRasterization() {
      assignViewportIfChanged();
      assignTopologyIfChanged();
      assignIndexBufferIfChanged();
      assignVertexBufferIfChanged();
      assignVertexShaderConstantBufferIfChanged();
      assignVertexShaderTextureIfChanged();
      assignVertexShaderIfChanged();
      assignPixelShaderConstantBufferIfChanged();
      assignPixelShaderTextureIfChanged();
      assignPixelShaderIfChanged();
      assignRenderTargetIfChanged();
    }

    /// <summary>Creates the render target responsible for the backbuffer</summary>
    private: void createBackBufferRenderTarget();
    /// <summary>Destroys the render target responsible for the backbuffer</summary>
    private: void destroyBackBufferRenderTarget();

    /// <summary>Assigns the topology to the Direct3D device if it has changed</summary>
    private: void assignViewportIfChanged();
    /// <summary>Assigns the topology to the Direct3D device if it has changed</summary>
    private: void assignTopologyIfChanged();
    /// <summary>Assigns the index buffer to the Direct3D device if it has changed</summary>
    private: void assignIndexBufferIfChanged();
    /// <summary>Assigns the vertex buffer to the Direct3D device if it has changed</summary>
    private: void assignVertexBufferIfChanged();
    /// <summary>Assigns the vertex shader to the Direct3D device if it has changed</summary>
    private: void assignVertexShaderIfChanged();
    /// <summary>Assigns the pixel shader to the Direct3D device if it has changed</summary>
    private: void assignPixelShaderIfChanged();
    /// <summary>Assigns the render target to the Direct3D device if it has changed</summary>
    private: void assignRenderTargetIfChanged();
    /// <summary>Assigns the constant buffer to the vertex shader if it has changed</summary>
    private: void assignVertexShaderConstantBufferIfChanged();
    /// <summary>Assigns the constant buffer to the pixel shader if it has changed</summary>
    private: void assignPixelShaderConstantBufferIfChanged();
    /// <summary>Assigns the texture to the vertex shader if it has changed</summary>
    private: void assignVertexShaderTextureIfChanged();
    /// <summary>Assigns the texture to the pixel shader if it has changed</summary>
    private: void assignPixelShaderTextureIfChanged();

    /// <summary>Topology currently selected for any Rasterize() calls</summary>
    private: Topology::Enum topology;
    /// <summary>Whether the topology has changed since the last draw call</summary>
    private: bool topologyChanged;

    /// <summary>Vertex buffers the user has currently selected</summary>
    private: std::unique_ptr<std::shared_ptr<GenericVertexBuffer>[]> vertexBuffers;
    /// <summary>Vertex buffers currently assigned to the graphics device</summary>
    private: std::unique_ptr<std::shared_ptr<GenericVertexBuffer>[]> pinnedVertexBuffers;
    /// <summary>Whether the user has changed any of the vertex buffers</summary>
    private: std::size_t highestChangedVertexBufferIndex;
    /// <summary>Constant buffers in the currently assigned vertex shader</summary>
    private: std::unique_ptr<
      std::shared_ptr<GenericConstantBuffer>[]
    > pinnedVertexShaderConstantBuffers;
    /// <summary>Constant buffers in the currently assigned pixel shader</summary>
    private: std::unique_ptr<
      std::shared_ptr<GenericConstantBuffer>[]
    > pinnedPixelShaderConstantBuffers;
    /// <summary>Textures in the currently assigned vertex shader</summary>
    private: std::unique_ptr<std::shared_ptr<Texture>[]> pinnedVertexShaderTextures;
    /// <summary>Textures in the currently assigned pixel shader</summary>
    private: std::unique_ptr<std::shared_ptr<Texture>[]> pinnedPixelShaderTextures;
    /// <summary>Index buffer the user has currently selected</summary>
    private: std::shared_ptr<GenericIndexBuffer> indexBuffer;
    /// <summary>Index buffer currently assigned to the graphics device</summary>
    private: std::shared_ptr<GenericIndexBuffer> pinnedIndexBuffer;
    /// <summary>Vertex shader that will be used to transform vertices</summary>
    private: std::shared_ptr<VertexShader> vertexShader;
    /// <summary>Vertex shader currently assigned to graphics device</summary>
    private: std::shared_ptr<VertexShader> pinnedVertexShader;
    /// <summary>Pixel shader that will be used for rasterization</summary>
    private: std::shared_ptr<PixelShader> pixelShader;
    /// <summary>Pixel shader currently assigned to the graphics device</summary>
    private: std::shared_ptr<PixelShader> pinnedPixelShader;
    /// <summary>Render target onto which the rasterizer will draw</summary>
    private: std::shared_ptr<RenderTarget2> renderTarget;
    /// <summary>Render target currently assigned to the graphics device</summary>
    private: std::shared_ptr<RenderTarget2> pinnedRenderTarget;
    /// <summary>Render target that represents the swap chain's back buffer</summary>
    private: std::shared_ptr<RenderTarget2> backBufferRenderTarget;
    /// <summary>Set when the render target used for the back buffer has changed</summary>
    private: bool backBufferRenderTargetChanged;
    /// <summary>Viewport into which rendering will take place</summary>
    private: Viewport viewport;
    /// <summary>Whether the viewport has changed since the last draw call</summary>
    private: bool viewportChanged;
    /// <summary>
    ///   Remains true until the user sets a custom viewport for the first time
    /// </summary>
    private: bool isUsingDefaultViewport;

    /// <summary>Direct3D device the state will be managed for</summary>
    private: ID3D11DeviceNPtr device;
    /// <summary>Direct3D device context that contains the device's state</summary>
    private: ID3D11DeviceContextNPtr context;
    /// <summary>Resource manager the state will pull its device objects from</summary>
    private: Direct3D11RasterizerResources *resources;
    /// <summary>Input layout manager used to generated input layouts for shaders</summary>
    private: Direct3D11InputLayoutManager *inputLayouts;

  };

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

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

#endif // NUCLEX_GRAPHICS_RASTERIZATION_DIRECT3D11RASTERIZERSTATE_H