TextureData.cpp

#include "TextureData.h"
 
#include <cmath>
#include <algorithm>
 
namespace Cogs
{
 
  const char* getResourceDimensionsName(ResourceDimensions target)
  {
    static const char* names[] =
    {
      "Unknown",
      "Buffer",
      "Texture1D",
      "Texture1DArray",
      "Texture2D",
      "Texture2DArray",
      "Texture2DMS",
      "Texture2DMSArray",
      "Texture3D",
      "Texture3DArray",
      "TextureCube",
      "TextureCubeArray",
      "RenderBuffer",
      "<illegal>"
    };
    static_assert(sizeof(names) == sizeof(names[0]) * (size_t(ResourceDimensions::ResourceDimensions_Size) + 1));
    return names[size_t(target) < size_t(ResourceDimensions::ResourceDimensions_Size) ? size_t(target) : size_t(ResourceDimensions::ResourceDimensions_Size)];
  }
 
  size_t getBlockSize(TextureFormat format)
  {
    return getFormatInfo(format)->blockSize;
  }
 
  TextureExtent getBlockExtent(TextureFormat format)
  {
    return getFormatInfo(format)->blockExtent;
  }
 
  size_t getComponents(TextureFormat format)
  {
    return getFormatInfo(format)->elements;
  }
 
  uint32_t getMipLevels(const uint32_t width, const uint32_t height)
  {
    return 1 + static_cast<uint32_t>(std::floor(std::log2((double)std::max(width, height))));
  }
 
  uint32_t getMipSize(uint32_t size, uint32_t level)
  {
    return std::max(1u, size / static_cast<uint32_t>(std::pow(2, level)));
  }
 
  size_t TextureDescription::estimateMemorySize() const
  {
    size_t  size = getBlockSize(format) * width * height * depth * faces * layers;
 
    if (levels > 1) {
      size += (size / 3);   // Roughly.  :)
    }
    return size;
  }
 
  TextureData::TextureData(TextureExtent extent, size_t layers, size_t faces, size_t levels, TextureFormat format, Memory::Allocator * allocator) :
    format(format),
    layers(layers),
    faces(faces),
    levels(levels),
    blockSize(getBlockSize(format)),
    blockExtent(getBlockExtent(format)),
    blockCount(TextureExtent{ (extent.width + getBlockExtent(format).width - 1) / getBlockExtent(format).width, (extent.height + getBlockExtent(format).height - 1) / getBlockExtent(format).height, extent.depth / getBlockExtent(format).depth }),
    extent(extent),
    data(allocator)
  {
 
  }
 
  TextureData::TextureData(const void * data, TextureExtent extent, size_t layers, size_t faces, size_t levels, TextureFormat format) :
    TextureData(extent, layers, faces, levels, format)
  {
    initOffsets(data);
  }
 
  void TextureData::init(TextureExtent extent, size_t layers, size_t faces, size_t levels, TextureFormat format, Memory::Allocator * allocator)
  {
    this->format = format;
    this->layers = layers;
    this->faces = faces;
    this->levels = levels;
    blockSize = getBlockSize(format);
    blockExtent = getBlockExtent(format);
    blockCount = TextureExtent{ (extent.width + getBlockExtent(format).width -1) / getBlockExtent(format).width, (extent.height + getBlockExtent(format).height  - 1) / getBlockExtent(format).height, extent.depth / getBlockExtent(format).depth };
    this->extent = extent;
    data.reset(getSize(), allocator);
 
    initOffsets(data.data());
  }
 
  void TextureData::initExternal(intptr_t external)
  {
    externalHandle = external;
  }
 
  void TextureData::initExternal(const void ** data, size_t layers, size_t faces, size_t levels)
  {
    assert(this->layers == layers && "External data not compatible.");
    assert(this->faces == faces && "External data not compatible.");
    assert(this->levels == levels && "External data not compatible.");
 
    size_t numOffsets = layers * faces * levels;
    for (size_t i = 0; i < numOffsets; ++i) {
      offsets.push_back(data[i]);
    }
  }
 
  void TextureData::clearData()
  {
    format = Cogs::TextureFormat::Unknown;
 
    layers = 0;
    faces = 0;
    levels = 0;
 
    blockSize = 0;
    blockExtent = {};
    blockCount = {};
    extent = {};
 
    offsets.clear();
    data.resize(0, false, true); // forceRealloc to free data
    externalHandle = 0;
  }
 
  void * TextureData::getData(size_t layer, size_t face, size_t level)
  {
    assert(data.size() && "Cannot modify external data.");
 
    return static_cast<uint8_t *>(data.data()) + getOffset(layer, face, level);
  }
 
  const void * TextureData::getData(size_t layer, size_t face, size_t level) const
  {
    return offsets[layer * (faces * levels) + face * levels + level];
  }
 
  size_t TextureData::getPitch(size_t level) const
  {
    return blockSize * getBlockCount(level).width;
  }
 
  size_t TextureData::getLevelSize(size_t level) const
  {
    const auto levelBlocks = getBlockCount(level);
 
    return blockSize * levelBlocks.width * levelBlocks.height * levelBlocks.depth;
  }
 
  size_t TextureData::getFaceSize(size_t baseLevel, size_t maxLevel) const
  {
    size_t faceSize = 0;
    for (size_t i = baseLevel; i <= maxLevel; ++i) {
      faceSize += getLevelSize(i);
    }
    return faceSize;
  }
 
  size_t TextureData::getLayerSize(size_t baseFace, size_t maxFace, size_t baseLevel, size_t maxLevel) const
  {
    return getFaceSize(baseLevel, maxLevel) * (maxFace - baseFace + 1);
  }
 
  size_t TextureData::getSize() const
  {
    return layers * getLayerSize(0, faces - 1, 0, levels - 1);
  }
 
  TextureExtent TextureData::getExtent(size_t level) const
  {
    return TextureExtent{
      std::max(1u, extent.width >> (uint32_t)level),
      std::max(1u, extent.height >> (uint32_t)level),
      std::max(1u, extent.depth >> (uint32_t)level),
    };
  }
 
  TextureExtent TextureData::getBlockCount(size_t level) const
  {
    return TextureExtent{
      std::max(1u, ((blockCount.width + (1 << (uint32_t)level) - 1 )) >> (uint32_t)level),
      std::max(1u, ((blockCount.height + (1 << (uint32_t)level) - 1 )) >> (uint32_t)level),
      std::max(1u, ((blockCount.depth + (1 << (uint32_t)level) - 1 )) >> (uint32_t)level),
    };
  }
 
  size_t TextureData::getOffset(size_t layer, size_t face, size_t level) const
  {
    auto layerSize = getLayerSize(0, faces - 1, 0, levels - 1);
    auto faceSize = getFaceSize(0, levels - 1);
 
    size_t offset = layer * layerSize + face * faceSize;
 
    for (size_t i = 0; i < level; ++i) {
      offset += getLevelSize(i);
    }
 
    return offset;
  }
 
  void TextureData::initOffsets(const void * data)
  {
    for (size_t i = 0; i < layers; ++i) {
      for (size_t j = 0; j < faces; ++j) {
        for (size_t k = 0; k < levels; ++k) {
          offsets.push_back(static_cast<const uint8_t *>(data) + getOffset(i, j, k));
        }
      }
    }
  }
}