#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_HELPERS_PIXELFORMATCONVERTER_H
#error This file must be included through PixelFormatConverter.h
#endif

namespace Nuclex { namespace Graphics { namespace Rasterization {

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

  /// <summary>Converts pixels from one pixel format to another</summary>
  template<>
  class PixelFormatConverter<PixelFormat::R8_Unsigned, PixelFormat::R8_Unsigned> {
    /// <summary>Data type used by the input pixel format</summary>
    public: typedef std::uint8_t InputType;
    /// <summary>Data type used by the output pixel format</summary>
    public: typedef std::uint8_t OutputType;
    /// <summary>
    ///   Converts a pixel from the input pixel format into the output pixel format
    /// </summary>
    /// <param name="pixel">Pixel that will be converted</param>
    /// <returns>The pixel in the output pixel format</returns>
    public: static OutputType ConvertPixel(InputType pixel) { return pixel; }
  };

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

  /// <summary>Converts pixels from one pixel format to another</summary>
  template<>
  class PixelFormatConverter<PixelFormat::R8_Unsigned, PixelFormat::R8_G8_Signed> {
    /// <summary>Data type used by the input pixel format</summary>
    public: typedef std::uint8_t InputType;
    /// <summary>Data type used by the output pixel format</summary>
    public: typedef std::uint16_t OutputType;
    /// <summary>
    ///   Converts a pixel from the input pixel format into the output pixel format
    /// </summary>
    /// <param name="pixel">Pixel that will be converted</param>
    /// <returns>The pixel in the output pixel format</returns>
    public: static OutputType ConvertPixel(InputType pixel) {
      return 0x7F7F & (
        (static_cast<OutputType>(pixel) >> 1) |
        (static_cast<OutputType>(pixel) << 7)
      );
    }
  };

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

  /// <summary>Converts pixels from one pixel format to another</summary>
  template<>
  class PixelFormatConverter<PixelFormat::R8_Unsigned, PixelFormat::B5_G6_R5_Unsigned> {
    /// <summary>Data type used by the input pixel format</summary>
    public: typedef std::uint8_t InputType;
    /// <summary>Data type used by the output pixel format</summary>
    public: typedef std::uint16_t OutputType;
    /// <summary>
    ///   Converts a pixel from the input pixel format into the output pixel format
    /// </summary>
    /// <param name="pixel">Pixel that will be converted</param>
    /// <returns>The pixel in the output pixel format</returns>
    public: static OutputType ConvertPixel(InputType pixel) {
      return (
        ((static_cast<OutputType>(pixel) << 8) & 0xF800) |
        ((static_cast<OutputType>(pixel) << 3) & 0x07E0) |
        (static_cast<OutputType>(pixel) >> 3)
      );
    }
  };

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

  /// <summary>Converts pixels from one pixel format to another</summary>
  template<>
  class PixelFormatConverter<PixelFormat::R8_Unsigned, PixelFormat::B4_G4_R4_A4_Unsigned> {
    /// <summary>Data type used by the input pixel format</summary>
    public: typedef std::uint8_t InputType;
    /// <summary>Data type used by the output pixel format</summary>
    public: typedef std::uint16_t OutputType;
    /// <summary>
    ///   Converts a pixel from the input pixel format into the output pixel format
    /// </summary>
    /// <param name="pixel">Pixel that will be converted</param>
    /// <returns>The pixel in the output pixel format</returns>
    public: static OutputType ConvertPixel(InputType pixel) {
      return (
        ((static_cast<OutputType>(pixel) << 8) & 0xF000) |
        ((static_cast<OutputType>(pixel) << 4) & 0x0F00) |
        (static_cast<OutputType>(pixel) & 0x00F0) |
        0x000F
      );
    }
  };

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

  /// <summary>Converts pixels from one pixel format to another</summary>
  template<>
  class PixelFormatConverter<PixelFormat::R8_Unsigned, PixelFormat::R8_G8_B8_A8_Unsigned> {
    /// <summary>Data type used by the input pixel format</summary>
    public: typedef std::uint8_t InputType;
    /// <summary>Data type used by the output pixel format</summary>
    public: typedef std::uint32_t OutputType;
    /// <summary>
    ///   Converts a pixel from the input pixel format into the output pixel format
    /// </summary>
    /// <param name="pixel">Pixel that will be converted</param>
    /// <returns>The pixel in the output pixel format</returns>
    public: static OutputType ConvertPixel(InputType pixel) {
      return (
        (static_cast<OutputType>(pixel) << 24) |
        (static_cast<OutputType>(pixel) << 16) |
        (static_cast<OutputType>(pixel) << 8) |
        0x000000FF
      );
    }
  };

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

  /// <summary>Converts pixels from one pixel format to another</summary>
  template<>
  class PixelFormatConverter<PixelFormat::R8_Unsigned, PixelFormat::R8_G8_B8_A8_Signed> {
    /// <summary>Data type used by the input pixel format</summary>
    public: typedef std::uint8_t InputType;
    /// <summary>Data type used by the output pixel format</summary>
    public: typedef std::uint32_t OutputType;
    /// <summary>
    ///   Converts a pixel from the input pixel format into the output pixel format
    /// </summary>
    /// <param name="pixel">Pixel that will be converted</param>
    /// <returns>The pixel in the output pixel format</returns>
    public: static OutputType ConvertPixel(InputType pixel) {
      return 0x7F7F7F7F & (
        (static_cast<OutputType>(pixel) << 23) |
        (static_cast<OutputType>(pixel) << 15) |
        (static_cast<OutputType>(pixel) << 7) |
        0x0000007F
      );
    }
  };

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

  /// <summary>Converts pixels from one pixel format to another</summary>
  template<>
  class PixelFormatConverter<PixelFormat::R8_Unsigned, PixelFormat::BC1_Compressed> {
    // static_assert(false, "Compressed pixel formats need to be handled separately");
  };

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

  /// <summary>Converts pixels from one pixel format to another</summary>
  template<>
  class PixelFormatConverter<PixelFormat::R8_Unsigned, PixelFormat::BC2_Compressed> {
    // static_assert(false, "Compressed pixel formats need to be handled separately");
  };

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

  /// <summary>Converts pixels from one pixel format to another</summary>
  template<>
  class PixelFormatConverter<PixelFormat::R8_Unsigned, PixelFormat::BC3_Compressed> {
    // static_assert(false, "Compressed pixel formats need to be handled separately");
  };

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

  /// <summary>Converts pixels from one pixel format to another</summary>
  template<>
  class PixelFormatConverter<PixelFormat::R8_Unsigned, PixelFormat::Modern_A8_Unsigned> {
    /// <summary>Data type used by the input pixel format</summary>
    public: typedef std::uint8_t InputType;
    /// <summary>Data type used by the output pixel format</summary>
    public: typedef std::uint8_t OutputType;
    /// <summary>
    ///   Converts a pixel from the input pixel format into the output pixel format
    /// </summary>
    /// <returns>The pixel in the output pixel format</returns>
    public: static OutputType ConvertPixel(InputType) { return 0xFF; }
  };

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

  /// <summary>Converts pixels from one pixel format to another</summary>
  template<>
  class PixelFormatConverter<PixelFormat::R8_Unsigned, PixelFormat::Modern_R16_Unsigned> {
    /// <summary>Data type used by the input pixel format</summary>
    public: typedef std::uint8_t InputType;
    /// <summary>Data type used by the output pixel format</summary>
    public: typedef std::uint16_t OutputType;
    /// <summary>
    ///   Converts a pixel from the input pixel format into the output pixel format
    /// </summary>
    /// <param name="pixel">Pixel that will be converted</param>
    /// <returns>The pixel in the output pixel format</returns>
    public: static OutputType ConvertPixel(InputType pixel) {
      return (
        (static_cast<OutputType>(pixel) << 8) |
        static_cast<OutputType>(pixel)
      );
    }
  };

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

  /// <summary>Converts pixels from one pixel format to another</summary>
  template<>
  class PixelFormatConverter<PixelFormat::R8_Unsigned, PixelFormat::Modern_R16_G16_Unsigned> {
    /// <summary>Data type used by the input pixel format</summary>
    public: typedef std::uint8_t InputType;
    /// <summary>Data type used by the output pixel format</summary>
    public: typedef std::uint32_t OutputType;
    /// <summary>
    ///   Converts a pixel from the input pixel format into the output pixel format
    /// </summary>
    /// <param name="pixel">Pixel that will be converted</param>
    /// <returns>The pixel in the output pixel format</returns>
    public: static OutputType ConvertPixel(InputType pixel) {
      std::uint16_t intensity = (
        (static_cast<std::uint16_t>(pixel) << 8) |
        static_cast<std::uint16_t>(pixel)
      );
      return (
        (static_cast<OutputType>(intensity) << 16) |
        intensity
      );
    }
  };

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

  /// <summary>Converts pixels from one pixel format to another</summary>
  template<>
  class PixelFormatConverter<PixelFormat::R8_Unsigned, PixelFormat::Modern_R16_G16_Float> {
    /// <summary>Data type used by the input pixel format</summary>
    public: typedef std::uint8_t InputType;
    /// <summary>Data type used by the output pixel format</summary>
    public: typedef std::uint32_t OutputType;
    /// <summary>
    ///   Converts a pixel from the input pixel format into the output pixel format
    /// </summary>
    /// <param name="pixel">Pixel that will be converted</param>
    /// <returns>The pixel in the output pixel format</returns>
    public: static OutputType ConvertPixel(InputType pixel) {
      std::uint16_t intensity = Half::FromNormalizedByte(pixel);
      return (
        (static_cast<OutputType>(intensity) << 16) |
        intensity
      );
    }
  };

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

  /// <summary>Converts pixels from one pixel format to another</summary>
  template<>
  class PixelFormatConverter<PixelFormat::R8_Unsigned, PixelFormat::Modern_R32_Float> {
    /// <summary>Data type used by the input pixel format</summary>
    public: typedef std::uint8_t InputType;
    /// <summary>Data type used by the output pixel format</summary>
    public: typedef std::uint32_t OutputType;
    /// <summary>
    ///   Converts a pixel from the input pixel format into the output pixel format
    /// </summary>
    /// <param name="pixel">Pixel that will be converted</param>
    /// <returns>The pixel in the output pixel format</returns>
    public: static OutputType ConvertPixel(InputType pixel) {
      float result = static_cast<float>(pixel) / 255.0f;
      return *reinterpret_cast<std::uint32_t *>(&result);
    }
  };

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

  /// <summary>Converts pixels from one pixel format to another</summary>
  template<>
  class PixelFormatConverter<
    PixelFormat::R8_Unsigned, PixelFormat::Modern_R16_G16_B16_A16_Unsigned
  > {
    /// <summary>Data type used by the input pixel format</summary>
    public: typedef std::uint8_t InputType;
    /// <summary>Data type used by the output pixel format</summary>
    public: typedef std::uint64_t OutputType;
    /// <summary>
    ///   Converts a pixel from the input pixel format into the output pixel format
    /// </summary>
    /// <param name="pixel">Pixel that will be converted</param>
    /// <returns>The pixel in the output pixel format</returns>
    public: static OutputType ConvertPixel(InputType pixel) {
      std::uint16_t intensity = (
        (static_cast<std::uint16_t>(pixel) << 8) |
        static_cast<std::uint16_t>(pixel)
      );
      return (
        (static_cast<OutputType>(intensity) << 48) |
        (static_cast<OutputType>(intensity) << 32) |
        (static_cast<OutputType>(intensity) << 16) |
        0x000000000000FFFF
      );
    }
  };

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

  /// <summary>Converts pixels from one pixel format to another</summary>
  template<>
  class PixelFormatConverter<
    PixelFormat::R8_Unsigned, PixelFormat::Modern_R16_G16_B16_A16_Float
  > {
    /// <summary>Data type used by the input pixel format</summary>
    public: typedef std::uint8_t InputType;
    /// <summary>Data type used by the output pixel format</summary>
    public: typedef std::uint64_t OutputType;
    /// <summary>
    ///   Converts a pixel from the input pixel format into the output pixel format
    /// </summary>
    /// <param name="pixel">Pixel that will be converted</param>
    /// <returns>The pixel in the output pixel format</returns>
    public: static OutputType ConvertPixel(InputType pixel) {
      std::uint16_t intensity = Half::FromNormalizedByte(pixel);
      return (
        (static_cast<OutputType>(intensity) << 48) |
        (static_cast<OutputType>(intensity) << 32) |
        (static_cast<OutputType>(intensity) << 16) |
        static_cast<std::uint16_t>(Half::One)
      );
    }
  };

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

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