#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_RASTERIZER_H
#define NUCLEX_GRAPHICS_RASTERIZATION_RASTERIZER_H

#include "../Config.h"
#include "Topology.h"
#include "Viewport.h"

#include <memory>

namespace Nuclex { namespace Graphics { namespace Rasterization {

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

  class RenderTarget2;
  class GenericVertexBuffer;
  class GenericIndexBuffer;
  class VertexShader;
  class PixelShader;
  class RasterizerResources;
  class RasterizerSettings;

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

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

namespace Nuclex { namespace Graphics { namespace Rasterization {

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

  /// <summary>Turns polygon-based scene descriptions into pixel bitmaps</summary>
  /// <remarks>
  ///   Rasterizers must be accessed by only one thread at a time. 
  /// </remarks>
  class Rasterizer {

    /// <summary>Initializes a new rasterizer</summary>
    protected: NUCLEX_GRAPHICS_API Rasterizer() {}

    /// <summary>Frees all resources owned by the rasterizer</summary>
    public: NUCLEX_GRAPHICS_API virtual ~Rasterizer() {}

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

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

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

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

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

    /// <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: virtual const std::shared_ptr<GenericVertexBuffer> &GetVertexBuffer(
      std::size_t index
    ) const = 0;

    /// <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: virtual void SetVertexBuffer(
      std::size_t index, const std::shared_ptr<GenericVertexBuffer> &vertexBuffer
    ) = 0;

    /// <summary>Returns the index buffer currently bound</summary>
    /// <returns>The index buffer currently bound</returns>
    public: virtual const std::shared_ptr<GenericIndexBuffer> &GetIndexBuffer() const = 0;

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

    /// <summary>
    ///   Retrieves the vertex shader the rasterizer is using to transform vertices
    /// </summary>
    /// <returns>The vertex shader that the rasterizer is using</returns>
    public: virtual const std::shared_ptr<VertexShader> &GetVertexShader() const = 0;

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

    /// <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: virtual const std::shared_ptr<PixelShader> &GetPixelShader() const = 0;

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

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

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

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

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

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

    /// <summary>Retrieves the current viewport the rasterizer renders to</summary>
    /// <returns>The rasterizer's current viewport</returns>
    /// <remarks>
    ///   Do not use this method if you want to know the screen resolution or window size
    ///   you're rendering to. If you never call SetViewport() it will be identical, but
    ///   as soon as you call SetViewport() once it will stop updating. To determine the
    ///   resolution, call GetDefaultRenderTarget() and query its width and height!
    /// </remarks>
    public: virtual const Viewport &GetViewport() const = 0;

    /// <summary>Sets the viewport the rasterizer will render to</summary>
    /// <param name="viewport">Viewport the rasterizer will render to</param>
    /// <remarks>
    ///   If you never call this method, the rasterizer will assume that you are fine
    ///   with the default viewport which encompasses the entire screen and will update
    ///   the viewport accordingly. The moment you call this method, the rasterizer will
    ///   leave the viewport alone and it is up to you to update it if the screen
    ///   resolution or window size changes!
    /// </remarks>
    public: virtual void SetViewport(const Viewport &viewport) = 0;

    /// <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: virtual void Rasterize(
      std::size_t vertexBufferStartIndex = 0,
      std::size_t vertexCount = static_cast<std::size_t>(-1)
    ) = 0;

    /// <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: virtual 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)
    ) = 0;

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

    private: Rasterizer(const Rasterizer &);
    private: Rasterizer &operator =(const Rasterizer &);

  };

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

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

#endif // NUCLEX_GRAPHICS_RASTERIZATION_RASTERIZER_H