#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

// If the library is compiled as a DLL, this ensures symbols are exported
#define NUCLEX_GRAPHICS_SOURCE 1

#include "Direct3D11VertexShaderObserver.h"
#include "../Direct3D11RasterizerResources.h"
#include "Nuclex/Graphics/Rasterization/Usage.h"

#include <stdexcept>

namespace {

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

  /// <summary>Converts an agnostic usage into a Direct3D usage</summary>
  /// <param name="usage">Usage that will be converted</param>
  /// <returns>The equivalent Direct3D usage</returns>
  D3D11_USAGE direct3DUsageFromUsage(Nuclex::Graphics::Rasterization::Usage::Enum usage) {
    using namespace Nuclex::Graphics::Rasterization;

    switch(usage) {
      case Usage::Immutable: { return D3D11_USAGE_IMMUTABLE; }
      case Usage::GpuChangeable: { return D3D11_USAGE_DEFAULT; }
      case Usage::CpuToGpuTransfer: { return D3D11_USAGE_DYNAMIC; }
      case Usage::GpuToCpuTransfer: { return D3D11_USAGE_STAGING; }
      default: {
        throw std::runtime_error("Unsupported resource usage");
      }
    }
  }

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

  /// <summary>Converts an agnostic usage into a Direct3D CPU access flag</summary>
  /// <param name="usage">Usage that will be converted</param>
  /// <returns>The equivalent Direct3D CPU access flag</returns>
  D3D11_CPU_ACCESS_FLAG direct3DCpuAccessFromUsage(
    Nuclex::Graphics::Rasterization::Usage::Enum usage
  ) {
    using namespace Nuclex::Graphics::Rasterization;

    switch(usage) {
      case Usage::Immutable: { return D3D11_CPU_ACCESS_FLAG(0); }
      case Usage::GpuChangeable: { return D3D11_CPU_ACCESS_FLAG(0); }
      case Usage::CpuToGpuTransfer: { return D3D11_CPU_ACCESS_WRITE; }
      case Usage::GpuToCpuTransfer: { return D3D11_CPU_ACCESS_READ; }
      default: {
        throw std::runtime_error("Unsupported resource usage");
      }
    }
  }

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

} // anonymous namespace

namespace Nuclex { namespace Graphics { namespace Rasterization {

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

  Direct3D11VertexShaderObserver::Direct3D11VertexShaderObserver(
    Direct3D11RasterizerResources &resources, VertexShader *vertexShader
  ) :
    resources(resources),
    vertexShader(vertexShader) {

    HRESULT resultHandle = this->resources.GetDevice()->CreateVertexShader(
      this->vertexShader->AccessMemory(),
      this->vertexShader->GetProgramLengthInBytes(),
      nullptr,
      &this->direct3DVertexShader
    );
    if(FAILED(resultHandle)) {
      throw std::runtime_error("Could not create Direct3D 11 vertex shader");
    }
  }

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

  void Direct3D11VertexShaderObserver::Destroying() {
    this->resources.VertexShaderHolder.Evict(this->vertexShader, this);
    // Do not do anything below Evict(). It will delete this instance!
  }

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

  void Direct3D11VertexShaderObserver::ConstantBufferChanged(std::size_t) {
    // This implementation checks all constant buffers before rendering
    // so there is nothing to do here. Possible future optimization.
  }

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

  void Direct3D11VertexShaderObserver::TextureChanged(std::size_t) {
    // This implementation checks all texture before rendering
    // so there is nothing to do here. Possible future optimization.
  }

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

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