RasterConversion.cpp

#include "RasterConversion.h"
 
#if defined( _WIN32 )
  #pragma warning(push)
  #pragma warning(disable:4244)
#endif
 
#define STB_DXT_IMPLEMENTATION
#include "stb_dxt.h"
 
#if defined( _WIN32 )
  #pragma warning(pop)
#endif
 
#include "../ClipmapTerrainTypes.h"
 
bool Cogs::isCompressible(TextureFormat format)
{
  return format == TextureFormat::R8G8B8_UNORM ||
    format == TextureFormat::R8G8B8A8_UNORM ||
    format == TextureFormat::R8G8B8A8_UNORM_SRGB;
}
 
Cogs::TextureFormat Cogs::getCompressedFormat(TextureFormat format)
{
  switch (format)
  {
  case TextureFormat::R8G8B8_UNORM:
    return TextureFormat::BC3_UNORM;
  case TextureFormat::R8G8B8A8_UNORM:
    return TextureFormat::BC3_UNORM;
  case TextureFormat::R8G8B8A8_UNORM_SRGB:
    return TextureFormat::BC3_UNORM_SRGB;
  default:
    return TextureFormat::Unknown;
    break;
  }
}
 
bool Cogs::isConvertible(TextureFormat format)
{
  return format == TextureFormat::B8G8R8 ||
    format == TextureFormat::B8G8R8A8 ||
    format == TextureFormat::R8G8B8_UNORM;
}
 
Cogs::TextureFormat Cogs::compressTileData(std::vector<uint8_t> & destination,
  const uint8_t * source,
  TextureFormat sourceFormat,
  int width,
  int height)
{
  const auto targetFormat = getCompressedFormat(sourceFormat);
 
  const size_t numBlocksX = width / 4;
  const size_t numBlocksY = height / 4;
 
  const size_t bpp = Cogs::getBlockSize(sourceFormat);
  const bool hasAlpha = bpp == 4;
 
  const size_t rowStride = width * bpp;
 
  assert(destination.size() >= (numBlocksX * numBlocksY * 16) && "Destination buffer too small.");
 
  auto d = destination.data();
 
  for (size_t y = 0; y < numBlocksY; ++y) {
    for (size_t x = 0; x < numBlocksX; ++x) {
      uint8_t pixels[4 * 4 * 4];
 
      for (int yy = 0; yy < 4; ++yy) {
        for (int xx = 0; xx < 4; ++xx) {
          const size_t sourceIndex = (4 * y * rowStride) + (yy * rowStride) + (x * 4 * bpp) + xx * bpp;
 
          pixels[yy * 16 + xx * 4 + 0] = source[sourceIndex + 0];
          pixels[yy * 16 + xx * 4 + 1] = source[sourceIndex + 1];
          pixels[yy * 16 + xx * 4 + 2] = source[sourceIndex + 2];
          pixels[yy * 16 + xx * 4 + 3] = hasAlpha ? source[sourceIndex + 3] : 255;
        }
      }
 
      stb_compress_dxt_block(d, pixels, hasAlpha ? 1 : 0, STB_DXT_NORMAL);
      d += 16;
    }
  }
 
  return targetFormat;
}
 
Cogs::TextureFormat Cogs::convertBitmapData(const uint8_t * data,
  const TileData * tileData,
  std::vector<uint8_t> & destination)
{
  if (tileData->shouldConvert() && !Cogs::isConvertible(tileData->format)) {
    return TextureFormat::Unknown;
  }
 
  const bool swizzle = tileData->shouldConvert() &&
    (tileData->format == TextureFormat::B8G8R8 || tileData->format == TextureFormat::B8G8R8A8);
  const int r = swizzle ? 2 : 0;
  const int b = swizzle ? 0 : 2;
 
  auto targetFormat = tileData->shouldConvert() ?
    (tileData->isLinear() ? TextureFormat::R8G8B8A8_UNORM : TextureFormat::R8G8B8A8_UNORM_SRGB) :
    tileData->format;
 
  const size_t width = tileData->width;
  const size_t height = tileData->height;
  const size_t stride = tileData->stride;
  const bool flip = tileData->shouldFlip();
  const size_t bpp = Cogs::getBlockSize(tileData->format);
 
  destination.resize(getTextureSize(static_cast<int>(width), static_cast<int>(height), targetFormat));
 
  for (size_t y = 0; y < height; ++y) {
    size_t targetLine = flip ? (height - 1 - y) * width : y * width;
 
    for (size_t x = 0; x < width; ++x) {
      size_t i = bpp * x;
      size_t j = 4 * (targetLine + x);
 
      destination[j + 0] = data[i + r];
      destination[j + 1] = data[i + 1];
      destination[j + 2] = data[i + b];
      destination[j + 3] = bpp == 4 ? data[i + 3] : 255;
    }
 
    data += stride ? stride : width * 4;
  }
 
  return targetFormat;
}