TextureData.h

Go to the documentation of this file.

#pragma once
 
#include "DataFormat.h"
 
#include "Foundation/Memory/MemoryBuffer.h"
 
namespace Cogs
{
  size_t COGSRENDERING_DLL_API getBlockSize(TextureFormat format);
  TextureExtent COGSRENDERING_DLL_API getBlockExtent(TextureFormat format);
  size_t COGSRENDERING_DLL_API getComponents(TextureFormat format);
  uint32_t COGSRENDERING_DLL_API getMipLevels(const uint32_t width, const uint32_t height);
  uint32_t COGSRENDERING_DLL_API getMipSize(uint32_t size, uint32_t level);
 
  enum class ResourceDimensions
  {
    Unknown = 0,
    Buffer,
    Texture1D,
    Texture1DArray,
    Texture2D,
    Texture2DArray,
    Texture2DMS,
    Texture2DMSArray,
    Texture3D,
    Texture3DArray,
    TextureCube,
    TextureCubeArray,
    RenderBuffer,
    ResourceDimensions_Size
  };
  COGSRENDERING_DLL_API const char* getResourceDimensionsName(ResourceDimensions target);
 
  struct TextureDescription
  {
    TextureDescription() = default;
 
    COGSRENDERING_DLL_API size_t estimateMemorySize() const;
 
    ResourceDimensions          target = ResourceDimensions::Texture2D;   //<! Type of texture this describes.
    uint32_t                    width = 0;                                //<! Pixel width of the texture.
    uint32_t                    height = 0;                               //<! Height of texture in pixels.
    uint32_t                    depth = 1;
    uint32_t                    layers = 1;                               //<! Number of entries in a texture array.
    uint32_t                    faces = 1;                                //<! Number of faces in a cube-map.
    uint32_t                    levels = 1;                               //<! Number of mipmap levels.
    uint32_t                    samples = 1;                              //<! Defines the number of samples a multisample texture will have.
    TextureFormat               format = TextureFormat::Unknown;          //<! Pixel format of this texture.
    TextureFlags::ETextureFlags flags = TextureFlags::Default;
  };
 
  struct COGSRENDERING_DLL_API TextureData
  {
    TextureData() = default;
    TextureData(TextureExtent extent, size_t layers, size_t faces, size_t levels, TextureFormat format, Memory::Allocator * allocator = Memory::Allocator::defaultAllocator());
    TextureData(const void * data, TextureExtent extent, size_t layers, size_t faces, size_t levels, TextureFormat format);
 
    TextureData(TextureData &&) = default;
    TextureData & operator=(TextureData &&) = default;
 
    void init(TextureExtent extent, size_t layers, size_t faces, size_t levels, TextureFormat format, Memory::Allocator * allocator = Memory::Allocator::defaultAllocator());
    void initExternal(intptr_t external);
    void initExternal(const void ** data, size_t layers, size_t faces, size_t levels);
    void clearData();
 
    void * getData(size_t layer, size_t face, size_t level);
    const void * getData(size_t layer, size_t face, size_t level) const;
 
    void * getData() { return getData(0, 0, 0); }
    const void * getData() const { return getData(0, 0, 0); }
 
    size_t getPitch(size_t level) const;
    size_t getLevelSize(size_t level) const;
    size_t getFaceSize(size_t baseLevel, size_t maxLevel) const;
    size_t getLayerSize(size_t baseFace, size_t maxFace, size_t baseLevel, size_t maxLevel) const;
    size_t getSize() const;
 
    TextureExtent getExtent(size_t level) const;
    TextureExtent getBlockCount(size_t level) const;
 
    size_t getOffset(size_t layer, size_t face, size_t level) const;
    void initOffsets(const void * data);
 
    TextureFormat format = Cogs::TextureFormat::Unknown;
 
    size_t layers = 0;
    size_t faces = 0;
    size_t levels = 0;
 
    size_t blockSize = 0;
    TextureExtent blockExtent;
    TextureExtent blockCount;
    TextureExtent extent;
 
    Collections::SmallVector<const void *, 16> offsets;
    Memory::MemoryBuffer data;
    intptr_t externalHandle = 0;
  };
}