#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_CONSTANTBUFFER_H
#define NUCLEX_GRAPHICS_RASTERIZATION_CONSTANTBUFFER_H

#include "GenericConstantBuffer.h"

#include <cassert>

namespace Nuclex { namespace Graphics { namespace Rasterization {

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

  ///<summary>Stores constants that are used by vertex and pixel shader programs</summary>
  template<typename TContainer, typename TDescriptor = TContainer>
  class ConstantBuffer : public GenericConstantBuffer {

    /// <summary>Initializes a constant buffer for the container type</summary>
    public: ConstantBuffer() :
      GenericConstantBuffer(sizeof(TContainer)) {}

    /// <summary>Initializes a constant buffer by copying an existing constant buffer</summary>
    /// <param name="other">Constant buffer that will be copied</param>
    public: ConstantBuffer(const ConstantBuffer &other) :
      GenericConstantBuffer(other) {}

    /// <summary>Called when the constant buffer is being destroyed</summary>
    public: virtual ~ConstantBuffer() {
      OnDestroying();
    }

    /// <summary>Retrieves the contents of the constant buffer as a structure</summary>
    /// <returns>The contents of the constant buffer as a structure</returns>
    public: TContainer Get() const {
      TContainer container;

      auto containerMemory = reinterpret_cast<std::uint8_t *>(&container);
      std::copy_n(AccessMemory(), sizeof(TContainer), containerMemory);

      return container;
    }

    /// <summary>Updates the contents of the constant buffer from a structure</summary>
    /// <param name="container">Container structure the constant buffer will be set to</param>
    public: void Set(const TContainer &container) {
      auto containerMemory = reinterpret_cast<const std::uint8_t *>(&container);
      std::copy_n(containerMemory, sizeof(TContainer), AccessMemory());
      OnChanged(0, sizeof(TContainer));
    }

    /// <summary>Counts the number of elements stored in the constant buffer</summary>
    /// <returns>The number of elements stored in the constant buffer</returns>
    public: std::size_t CountElements() const {
      return TDescriptor::Describe().size();
    }

    /// <summary>
    ///   Retrieves an array describing the elements stored in the constant buffer
    /// </summary>
    /// <returns>An array describing the elements stored in the constant buffer</returns>
    public: const VertexElement *GetElements() const {
      return TDescriptor::Describe().data();
    }

  };

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

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

#endif // NUCLEX_GRAPHICS_RASTERIZATION_CONSTANTBUFFER_H