#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_H
#define NUCLEX_GRAPHICS_RASTERIZATION_DIRECT3D11RASTERIZER_H

#include "../Config.h"
#include "Rasterizer.h"

#if defined(NUCLEX_GRAPHICS_WINRT)
#include <agile.h>
#elif defined(NUCLEX_GRAPHICS_WIN32)
#define WIN32_LEAN_AND_MEAN
#define VC_EXTRALEAN
#define NO_MINMAX
#include <Windows.h>
#endif

namespace Nuclex { namespace Graphics { namespace Rasterization {

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

  ///<summary>Uses Direct3D 11 to render polygon-based scenes</summary>
  class Direct3D11Rasterizer : public Rasterizer {

#if defined(NUCLEX_GRAPHICS_WINRT)

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

#elif defined(NUCLEX_GRAPHICS_WIN32)

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

#endif

    /// <summary>Frees all resources owned by the rasterizer</summary>
    public: NUCLEX_GRAPHICS_API virtual ~Direct3D11Rasterizer();

    /// <summary>Checks whether Direct3D 11 is available on the system</summary>
    /// <returns>True if Direct3D 11 is available</returns>
    public: NUCLEX_GRAPHICS_API static bool IsAvailable();

    /// <summary>Accesses the settings management interface of the rasterizer</summary>
    /// <returns>The rasterizer's settings management</returns>
    public: NUCLEX_GRAPHICS_API const RasterizerSettings &Settings() const;

    /// <summary>Accesses the settings management interface of the rasterizer</summary>
    /// <returns>The rasterizer's settings management</returns>
    public: NUCLEX_GRAPHICS_API RasterizerSettings &Settings();

    /// <summary>Accesses the resource management interface of the rasterizer</summary>
    /// <returns>The rasterizer's resource management</returns>
    public: NUCLEX_GRAPHICS_API const RasterizerResources &Resources() const;

    /// <summary>Accesses the resource management interface of the rasterizer</summary>
    /// <returns>The rasterizer's resource management</returns>
    public: NUCLEX_GRAPHICS_API RasterizerResources &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: NUCLEX_GRAPHICS_API 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: NUCLEX_GRAPHICS_API 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: NUCLEX_GRAPHICS_API 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: NUCLEX_GRAPHICS_API const std::shared_ptr<GenericIndexBuffer> &GetIndexBuffer() const;

    /// <summary>Binds the index buffer that defines the vertex order</summary>
    /// <param name="indexBuffer">Index buffer that will be bound</param>
    public: NUCLEX_GRAPHICS_API void SetIndexBuffer(
      const std::shared_ptr<GenericIndexBuffer> &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: NUCLEX_GRAPHICS_API const std::shared_ptr<VertexShader> &GetVertexShader() const;

    /// <summary>Assigns the vertex shader that will be used to transform vertices</summary>
    /// <param name="vertexShader">Vertex shader the rasterizer will use</param>
    public: NUCLEX_GRAPHICS_API void SetVertexShader(
      const std::shared_ptr<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: NUCLEX_GRAPHICS_API const std::shared_ptr<PixelShader> &GetPixelShader() const;

    /// <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: NUCLEX_GRAPHICS_API void SetPixelShader(
      const std::shared_ptr<PixelShader> &pixelShader
    );

    /// <summary>Retrieves the render target for the primary rendering surface</summary>
    /// <returns>The render target representing the primary rendering surface</returns>
    public: NUCLEX_GRAPHICS_API const std::shared_ptr<RenderTarget2> &GetDefaultRenderTarget();

    /// <summary>Retrieves the current render target</summary>
    /// <returns>The current render target of  the rasterizer</returns>
    public: NUCLEX_GRAPHICS_API const std::shared_ptr<RenderTarget2> &GetRenderTarget();

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

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

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

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

    /// <summary>Sets the viewport the rasterizer will render to</summary>
    /// <param name="viewport">Viewport the rasterizer will render to</param>
    public: NUCLEX_GRAPHICS_API void SetViewport(const Viewport &viewport);

    /// <summary>Rasterizes primitives using the currently bound vertex buffers</summary>
    /// <param name="vertexBufferStartIndex">
    ///   Index in the vertex buffers at which resterization will begin
    /// </param>
    /// <param name="vertexCount">Number of vertices that will be rasterized</param>
    public: NUCLEX_GRAPHICS_API void Rasterize(
      std::size_t vertexBufferStartIndex = 0,
      std::size_t vertexCount = static_cast<std::size_t>(-1)
    );

    /// <summary>
    ///   Rasterizes primitives by indexing the bound vertex buffers through
    ///   the bound index buffers
    /// </summary>
    /// <param name="indexBufferStartIndex">
    ///   Position in the index buffer rasterization will begin at
    /// </param>
    /// <param name="indexCount">Number of indices that will used for rasterization</param>
    /// <param name="firstAccessedVertexIndex">
    ///   Index of the first vertex that will be accessed by this operation.
    ///   Providing this value can speed up hardware rasterization.
    /// </param>
    /// <param name="lastAccessedVertexIndex">
    ///   Index of the last vertex that will be accessed by this operation (exclusive).
    ///   Providing this value can speed up hardware rasterization.
    /// </param>
    public: NUCLEX_GRAPHICS_API void RasterizeIndexed(
      std::size_t indexBufferStartIndex = 0,
      std::size_t indexCount = static_cast<std::size_t>(-1),
      std::size_t firstAccessedVertexIndex = 0,
      std::size_t lastAccessedVertexIndex = static_cast<std::size_t>(-1)
    );

    /// <summary>Presents the rasterized image in the view</summary>
    public: NUCLEX_GRAPHICS_API void Present();

#if defined(NUCLEX_GRAPHICS_WINRT)
    /// <summary>Stores private implementation details</summary>
    private: ref struct Impl;
    /// <summary>Private implementation details of the rasterizer</summary>
    private: Impl ^impl;
#elif defined(NUCLEX_GRAPHICS_WIN32)
    /// <summary>Stores private implementation details</summary>
    private: struct Impl;
    /// <summary>Private implementation details of the rasterizer</summary>
    private: Impl *impl;
#endif

  };

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

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

#endif // NUCLEX_GRAPHICS_RASTERIZATION_DIRECT3D11RASTERIZER_H