#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_POLYGONOPTIONS_H
#define NUCLEX_GRAPHICS_RASTERIZATION_POLYGONOPTIONS_H

#include "../Config.h"
#include "Options.h"
#include "CullMode.h"
#include "FillMode.h"

#include <cstddef>

namespace Nuclex { namespace Graphics { namespace Rasterization {

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

  /// <summary>Various options that influence how polygons are rendered</summary>
  /// <remarks>
  ///   These are usually options you only set once and keep throughout your entire
  ///   game's existence.
  /// </remarks>
  class PolygonOptions : public Options {

    /// <summary>Initializes a new polygon option set</summary>
    public: NUCLEX_GRAPHICS_API PolygonOptions();

    /// <summary>Frees all resources owned by the instance</summary>
    public: NUCLEX_GRAPHICS_API ~PolygonOptions();

    /// <summary>Retrieves how polygons will be filled</summary>
    /// <returns>The selected fill mode</returns>
    public: NUCLEX_GRAPHICS_API FillMode::Enum GetFillMode() const { return this->fillMode; }

    /// <summary>Changes the polygon fill mode</summary>
    /// <param name="fillMode">New fill mode to select</param>
    public: NUCLEX_GRAPHICS_API void SetFillMode(FillMode::Enum fillMode) {
      this->fillMode = fillMode;
      OnChanged();
    }

    /// <summary>Retrieves how polygons will be culled based on their vertex order</summary>
    /// <returns>The selected culling mode</returns>
    public: NUCLEX_GRAPHICS_API CullMode::Enum GetCullMode() const { return this->cullMode; }

    /// <summary>Changes the culling mode</summary>
    /// <param name="cullMode">New culling mode to select</param>
    public: NUCLEX_GRAPHICS_API void SetCullMode(CullMode::Enum cullMode) {
      this->cullMode = cullMode;
      OnChanged();
    }

    /// <summary>Whether a clockwise face is considered the front face</summary>
    /// <returns>True if clockwise faces are considered to be front facing</returns>
    /// <remarks>
    ///   If false, counter-clockwise faces will be considered front facing.
    /// </remarks>
    public: NUCLEX_GRAPHICS_API bool IsFrontFaceClockwise() const {
      return this->isFrontFaceClockwise;
    }

    /// <summary>Changes whether a clockwise face is considered the front face</summary>
    /// <param name="isFrontFaceClockwise">
    ///   True to consider a clockwise face to be front facing
    /// </param>
    /// <remarks>
    ///   If false, counter-clockwise faces will be considered front facing.
    /// </remarks>
    public: NUCLEX_GRAPHICS_API void SetFrontFaceClockwise(bool isFrontFaceClockwise) {
      this->isFrontFaceClockwise = isFrontFaceClockwise;
      OnChanged();
    }

    /// <summary>Whether rasterized geometry is also clipped by depth</summary>
    /// <returns>True if geometry should be clipped by depth</returns>
    public: NUCLEX_GRAPHICS_API bool IsDepthClippingEnabled() const {
      return this->isDepthClippingEnabled;
    }

    /// <summary>Enables or disables depth clipping of rasterized geometry</summary>
    /// <param name="enable">Whether depth clipping should be performed</param>
    public: NUCLEX_GRAPHICS_API void EnableDepthClipping(bool enable = true) {
      this->isDepthClippingEnabled = enable;
      OnChanged();
    }

    /// <summary>Whether rendered geometry is limited to the scissor rectangle</summary>
    /// <returns>True if rendering should be restricted to the scissor rectangle</returns>
    public: NUCLEX_GRAPHICS_API bool IsScissorTestingEnabled() const {
      return this->isScissorTestingEnabled;
    }

    /// <summary>Switches whether rendering is restrict to the scissor rectangle</summary>
    /// <param name="enable">Whether to restrict rendering to the scissor rectangle</param>
    public: NUCLEX_GRAPHICS_API void EnableScissorTesting(bool enable = true) {
      this->isScissorTestingEnabled = enable;
      OnChanged();
    }


    /// <summary>Current fill mode</summary>
    private: FillMode::Enum fillMode;
    /// <summary>Current cull mode</summary>
    private: CullMode::Enum cullMode;
    /// <summary>Whether clockwise faces are considered to be front facing</summary>
    private: bool isFrontFaceClockwise;
    /// <summary>Whether depth clipping is enabled</summary>
    private: bool isDepthClippingEnabled;
    /// <summary>Whether rendering will be restricted to the scissor rectangle</summary>
    private: bool isScissorTestingEnabled;

  };

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

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

#endif // NUCLEX_GRAPHICS_RASTERIZATION_POLYGONOPTIONS_H