#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_DEPTHSTENCILOPTIONS_H
#define NUCLEX_GRAPHICS_RASTERIZATION_DEPTHSTENCILOPTIONS_H

#include "../Config.h"
#include "Options.h"
#include "ComparisonFunction.h"

#include <cstddef>
#include <cstdint>

namespace Nuclex { namespace Graphics { namespace Rasterization {

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

  /// <summary>
  ///   Various options that influence how the depth and stencil buffers are used
  /// </summary>
  /// <remarks>
  ///   These options can be represented by hardware-accelerated rasterizer as state blocks,
  ///   meaning that changing one option requires the rasterizer to create a completely new
  ///   state block. Thus, it's most efficient if you can pinpoint a handful of option
  ///   combinations that your game uses, create one of these structures for each and keep
  ///   reusing them.
  /// </remarks>
  class DepthStencilOptions : public Options {

    /// <summary>Initializes a new depth and stencil buffer option set</summary>
    public: NUCLEX_GRAPHICS_API DepthStencilOptions();

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

    /// <summary>Whether the depth buffer should be used</summary>
    /// <returns>True if the depth buffer should be used</returns>
    public: NUCLEX_GRAPHICS_API bool IsDepthBufferEnabled() const {
      return this->isDepthBufferEnabled;
    }

    /// <summary>Enables or disables the depth buffer</summary>
    /// <param name="enable">True to use the depth buffer, false to ignore it</param>
    public: NUCLEX_GRAPHICS_API void EnableDepthBuffer(bool enable = true) {
      this->isDepthBufferEnabled = enable;
      OnChanged();
    }

    /// <summary>Whether the depth buffer should be written to</summary>
    /// <returns>True if the depth buffer should be written to</returns>
    public: NUCLEX_GRAPHICS_API bool IsDepthWriteEnabled() const {
      return this->isDepthWriteEnabled;
    }

    /// <summary>Enables or disables writing to the depth buffer</summary>
    /// <param name="enable">
    ///   True to enable writing to the depth buffer, false to disable
    /// </param>
    public: NUCLEX_GRAPHICS_API void EnableDepthWrite(bool enable = true) {
      this->isDepthWriteEnabled = enable;
      OnChanged();
    }

    /// <summary>Retrieves the current depth comparison function</summary>
    /// <returns>The depth comparison function to use against the depth buffer</returns>
    public: NUCLEX_GRAPHICS_API ComparisonFunction::Enum GetDepthComparisonFunction() const {
      return this->depthComparisonFunction;
    }

    /// <summary>Selects the current depth comparison function</summary>
    /// <param name="comparisonFunction">
    ///   Comparison function that will be used against the depth buffer
    /// </param>
    public: NUCLEX_GRAPHICS_API void SetDepthComparisonFunction(
      ComparisonFunction::Enum comparisonFunction
    ) {
      this->depthComparisonFunction = comparisonFunction;
      OnChanged();
    }

    /// <summary>Whether the stencil buffer should be used</summary>
    /// <returns>True if the stencil buffer should be used</returns>
    public: NUCLEX_GRAPHICS_API bool IsStencilBufferEnabled() const {
      return this->isStencilBufferEnabled;
    }

    /// <summary>Enables or disables the stencil buffer</summary>
    /// <param name="enable">True to use the stencil buffer, false to ignore it</param>
    public: NUCLEX_GRAPHICS_API void EnableStencilBuffer(bool enable = true) {
      this->isStencilBufferEnabled = enable;
      OnChanged();
    }

    /// <summary>Retrieves the bit mask for stencil buffer reads</summary>
    /// <returns>The mask to use for stencil buffer reads</returns>
    public: NUCLEX_GRAPHICS_API std::uint8_t GetStencilReadMask() const {
      return this->stencilReadMask;
    }

    /// <summary>Selects the bit mask for stencil buffer reads</summary>
    /// <param name="mask">Mask to apply to stencil buffer reads</param>
    public: NUCLEX_GRAPHICS_API void SetStencilReadMask(std::uint8_t mask) {
      this->stencilReadMask = mask;
      OnChanged();
    }

    /// <summary>Retrieves the bit mask for stencil buffer writes</summary>
    /// <returns>The mask to use for stencil buffer writes</returns>
    public: NUCLEX_GRAPHICS_API std::uint8_t GetStencilWriteMask() const {
      return this->stencilWriteMask;
    }

    /// <summary>Selects the bit mask for stencil buffer writes</summary>
    /// <param name="mask">Mask to apply to stencil buffer writes</param>
    public: NUCLEX_GRAPHICS_API void SetStencilWriteMask(std::uint8_t mask) {
      this->stencilWriteMask = mask;
      OnChanged();
    }

    // TODO: stencil operations for front face
    // TODO: stencil operation for back face

    /// <summary>Whether depth buffer checks are enabled</summary>
    private: bool isDepthBufferEnabled;
    /// <summary>Whether depth writes are enabled</summary>
    private: bool isDepthWriteEnabled;
    /// <summary>Comparison function that is performed against the depth buffer</summary>
    private: ComparisonFunction::Enum depthComparisonFunction;
    /// <summary>Whether stencil buffer interaction is enabled</summary>
    private: bool isStencilBufferEnabled;
    /// <summary>Bit mask for stencil buffer reads</summary>
    private: std::uint8_t stencilReadMask;
    /// <summary>Bit mask for stencil buffer writes</summary>
    private: std::uint8_t stencilWriteMask;

  };

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

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

#endif // NUCLEX_GRAPHICS_RASTERIZATION_DEPTHSTENCILOPTIONS_H