Texture.h

#pragma once
 
#include "ResourceBase.h"
 
#include "Rendering/TextureData.h"
 
#include "Foundation/UniqueValue.h"
 
#include <glm/glm.hpp>
 
namespace Cogs
{
  namespace Core
  {
    template<typename Element>
    inline TextureFormat getFormat() { return TextureFormat::Unknown; }
 
    template<>
    inline TextureFormat getFormat<glm::u8vec4>() { return TextureFormat::R8G8B8A8_UNORM; }
 
    template<>
    inline TextureFormat getFormat<glm::vec3>() { return TextureFormat::R32G32B32_FLOAT; }
 
    template<>
    inline TextureFormat getFormat<glm::vec4>() { return TextureFormat::R32G32B32A32_FLOAT; }
 
    struct Texture;
 
    template<typename Element>
    class MappedTexture
    {
    public:
      MappedTexture(Texture * texture, Element * data) : elements(data), texture(texture) {}
 
      MappedTexture(MappedTexture & other) = delete;
 
      MappedTexture(MappedTexture && other) = default;
 
      ~MappedTexture();
 
      Element & operator[](const size_t index)
      {
        return elements[index];
      }
 
      explicit operator Element *() { return data; }
 
      Element * data() { return elements; }
 
    private:
      Element * elements;
 
      Texture * texture;
    };
 
 
 
 
    struct Texture : public ResourceBase
    {
      Texture() = default;
 
      Texture(const Texture & other) = delete;
 
      Texture(Texture && other) = default;
 
      ~Texture();
 
      Texture & operator=(Texture && other) = default;
 
      MappedTexture<uint8_t> map(uint16_t width, uint16_t height, TextureFormat format, bool generateMipMap)
      {
        return MappedTexture<uint8_t>(this, static_cast<uint8_t *>(mapInternal(width, height, format, generateMipMap)));
      }
 
      template<typename Element>
      MappedTexture<Element> map(uint16_t width, uint16_t height, bool generateMipMap)
      {
        auto format = getFormat<Element>();
 
        assert(Cogs::getBlockSize(format) == sizeof(Element) && "Compatible format not found for element type.");
 
        return MappedTexture<Element>(this, static_cast<Element *>(mapInternal(width, height, format, generateMipMap)));
      }
 
      template<typename Element>
      MappedTexture<Element> map(uint16_t width, uint16_t height, TextureFormat format, bool generateMipMap)
      {
        assert(Cogs::getBlockSize(format) == sizeof(Element) && "Format not size compatible with element type.");
 
        return MappedTexture<Element>(this, static_cast<Element *>(mapInternal(width, height, format, generateMipMap)));
      }
 
      void unmap()
      {
        setChanged();
      }
 
      void setData(ResourceDimensions target, const void * data, size_t size, int width, int height, TextureFormat format, bool generateMipMap);
 
      void setData(ResourceDimensions target, const void * data, size_t size, int width, int height, int levels, TextureFormat format, bool generateMipMap);
 
      void COGSCORE_DLL_API 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);
 
      void clearData();
 
      bool empty() { return storage.data.size() == 0; }
 
      void * mapInternal(uint16_t width, uint16_t height, TextureFormat format, bool mipMap);
 
      TextureDescription description;
      TextureData storage;
      intptr_t externalHandle = 0;
      UniqueValue<bool> ownsExternalTexture{ false };
      bool hasAlpha = false;
    };
 
    template<typename Element>
    MappedTexture<Element>::~MappedTexture()
    {
      if (texture) {
        texture->unmap();
      }
    }
  }
}