#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_OPENGL3RASTERIZER_H
#define NUCLEX_GRAPHICS_RASTERIZATION_OPENGL3RASTERIZER_H

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

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

#include <GL/gl.h>

#if defined(NUCLEX_GRAPHICS_LINUX)
#include <GL/glx.h>
#endif

namespace Nuclex { namespace Graphics { namespace Rasterization {

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

  ///<summary>Uses OpenGL 3.0 (core profile) to render polygon-based scenes</summary>
  class OpenGL3Rasterizer : public Rasterizer {

#if defined(NUCLEX_GRAPHICS_WIN32)

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

#elif defined(NUCLEX_GRAPHICS_LINUX)

    /// <summary>Initializes a new OpenGL 3.0 polygon renderer</summary>
    /// <param name="display">Display the rasterizer will render on</param>
    /// <param name="visualInfo">Visual on which rendering will take place</param>
    /// <param name="direct">Whether to directly connect to the graphics system</param>
    public: NUCLEX_GRAPHICS_API OpenGL3Rasterizer(
      Display *display, XVisualInfo *visualInfo, bool direct = true
    );

#endif

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

    /// <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 {
      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: NUCLEX_GRAPHICS_API void SetIndexBuffer(
      const std::shared_ptr<GenericIndexBuffer> &indexBuffer
    ) {
      this->indexBuffer = indexBuffer;
      this->indexBufferChanged = true;
    }

    /// <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 {
      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: NUCLEX_GRAPHICS_API void SetVertexShader(
      const std::shared_ptr<VertexShader> &vertexShader
    ) {
      this->vertexShader = vertexShader;
      this->vertexShaderChanged = true;
    }

    /// <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 {
      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: NUCLEX_GRAPHICS_API void SetPixelShader(
      const std::shared_ptr<PixelShader> &pixelShader
    ) {
      this->pixelShader = pixelShader;
      this->pixelShaderChanged = true;
    }

    /// <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() {
      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: NUCLEX_GRAPHICS_API void SetRenderTarget(
      const std::shared_ptr<RenderTarget2> &renderTarget
    ) {
      this->renderTarget = renderTarget;
      this->renderTargetChanged = true;
    }

    /// <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 {
      return this->topology;
    }

    /// <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) {
      this->topology = topology;
    }

    /// <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();

    /// <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>Stores privates implementation details</summary>
    private: struct Impl;
    /// <summary>Private implementation details of the rasterizer</summary>
    private: Impl *impl;

    /// <summary>Manages the settings of the Direct3D 11 rasterizer</summary>
    private: std::unique_ptr<OpenGL3RasterizerSettings> settings;
    /// <summary>Controls resource management of the Direct3D 11 rasterizer</summary>
    private: std::unique_ptr<OpenGL3RasterizerResources> resources;

    /// <summary>Topology currently selected for any Rasterize() calls</summary>
    private: Topology::Enum topology;
    /// <summary>Vertex buffers the user has currently selected</summary>
    private: std::unique_ptr<std::shared_ptr<GenericVertexBuffer>[]> vertexBuffers;
    /// <summary>Whether the vertex buffers have changed since the last draw call</summary>
    private: bool vertexBuffersChanged;
    /// <summary>Index buffer the user has currently selected</summary>
    private: std::shared_ptr<GenericIndexBuffer> indexBuffer;
    /// <summary>Whether the index buffer has changed since the last draw call</summary>
    private: bool indexBufferChanged;
    /// <summary>Vertex shader that will be used to transform vertices</summary>
    private: std::shared_ptr<VertexShader> vertexShader;
    /// <summary>Whether the vertex shader has changed since the last draw call</summary>
    private: bool vertexShaderChanged;
    /// <summary>Pixel shader that will be used for rasterization</summary>
    private: std::shared_ptr<PixelShader> pixelShader;
    /// <summary>Whether the pixel shader has changed since the last draw call</summary>
    private: bool pixelShaderChanged;
    /// <summary>Render target onto which the rasterizer will draw</summary>
    private: std::shared_ptr<RenderTarget2> renderTarget;
    /// <summary>Whether the render target has changed since the last draw call</summary>
    private: bool renderTargetChanged;

  };

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

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

#endif // NUCLEX_GRAPHICS_RASTERIZATION_OPENGL3RASTERIZER_H