Texture.cpp

#include "Texture.h"
 
#include "Services/Variables.h"
#include "Context.h"
 
#include "Foundation/BitTwiddling/PowerOfTwo.h"
#include "Foundation/Logging/Logger.h"
 
namespace {
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("Texture");
}
 
namespace Cogs
{
  namespace Core
  {
    class TextureAllocator : public Memory::Allocator
    {
    public:
      ~TextureAllocator()
      {
#if 0
        assert(!allocationSize && "Texture memory leaked.");
#endif
      }
 
      void * allocate(size_t size, size_t alignment = 0, MemBlockType type = MemBlockType::Block) override
      {
        allocationSize += size;
 
        return Memory::Allocator::allocate(size, alignment, type);
      }
 
      void deallocate(void * ptr, size_t size, MemBlockType type = MemBlockType::Block) override
      {
        allocationSize -= size;
        
        Memory::Allocator::deallocate(ptr, size, type);
      }
 
    private:
      Atomic<size_t> allocationSize{ 0 };
    } textureAllocator;
  }
}
 
Cogs::Core::Texture::~Texture()
{
  if (ownsExternalTexture.value) {
    assert(externalHandle == 0);
  }
}
 
void Cogs::Core::Texture::setData(ResourceDimensions target, const void * data, size_t size, int width, int height, TextureFormat format, bool generateMipMap)
{
  setData(target, data, size, width, height, 1, format, generateMipMap);
}
 
void Cogs::Core::Texture::setData(ResourceDimensions target, const void * data, size_t size, int width, int height, int levels, TextureFormat format, bool generateMipMap)
{
  setData(target, data, size, width, height, 1, 1, 1, levels, format, generateMipMap);
}
 
void COGSCORE_DLL_API Cogs::Core::Texture::setData(ResourceDimensions target,
                                  const void * data,
                                  size_t size,
                                  uint32_t width,
                                  uint32_t height,
                                  uint32_t depth,
                                  uint32_t layers,
                                  uint32_t faces,
                                  uint32_t levels,
                                  TextureFormat format,
                                  bool generateMipMap)
{
  debug_assert(layers >= 1 && "Invalid number of layers.");
  debug_assert(faces == 1 || faces == 6 && "Invalid number of faces.");
  debug_assert(levels >= 1 && "Invalid number of levels.");
 
  description.target = target;
  description.width = width;
  description.height = height;
  description.depth = depth;
  description.layers = layers;
  description.faces = faces;
  description.levels = levels;
  description.format = format;
  description.flags = Cogs::TextureFlags::Default | Cogs::TextureFlags::Texture;
  if (generateMipMap) {
    description.flags |= TextureFlags::GenerateMipMaps;
  }
  if (faces == 6) {
    description.flags |= TextureFlags::CubeMap;
  }
 
  if(data){
    storage.init({ width, height, depth }, layers, faces, levels, format, &textureAllocator);
 
    auto textureData = storage.getData();
 
    std::memcpy(textureData, data, size);
  }
 
  if (!isSet(ResourceFlags::Loading)) {
    setChanged();
  }
}
 
void * Cogs::Core::Texture::mapInternal(uint16_t width, uint16_t height, TextureFormat format, bool generateMipMap)
{
  description.width = width;
  description.height = height;
  description.format = format;
  description.flags = Cogs::TextureFlags::Default | Cogs::TextureFlags::Texture;
  if (generateMipMap) {
    description.flags |= TextureFlags::GenerateMipMaps;
  }
 
  storage.init({ width, height, 1 }, 1, 1, 1, format, &textureAllocator);
 
  std::memset(storage.getData(), 0, storage.getSize());
 
  return storage.getData();
}
 
void Cogs::Core::Texture::clearData(){
  if (!keepStorage()) {
    storage.clearData();
  }
}