ImageHeader.h

#pragma once
 
#include <Foundation/Basics/Assert.h>
#include <Foundation/Math/Color8UNorm.h>
#include <Foundation/Math/Math.h>
 
#include <Texture/Image/ImageFormat.h>
#include <Texture/TextureDLL.h>
 
class PL_TEXTURE_DLL plImageHeader
{
public:
  plImageHeader() { Clear(); }
 
  void Clear()
  {
    m_uiNumMipLevels = 1;
    m_uiNumFaces = 1;
    m_uiNumArrayIndices = 1;
    m_uiWidth = 0;
    m_uiHeight = 0;
    m_uiDepth = 1;
    m_Format = plImageFormat::UNKNOWN;
  }
 
  void SetImageFormat(const plImageFormat::Enum& format) { m_Format = format; }
 
  plImageFormat::Enum GetImageFormat() const { return m_Format; }
 
  void SetWidth(plUInt32 uiWidth) { m_uiWidth = uiWidth; }
 
  plUInt32 GetWidth(plUInt32 uiMipLevel = 0) const
  {
    PL_ASSERT_DEV(uiMipLevel < m_uiNumMipLevels, "Invalid mip level");
    return plMath::Max(m_uiWidth >> uiMipLevel, 1U);
  }
 
  void SetHeight(plUInt32 uiHeight) { m_uiHeight = uiHeight; }
 
  plUInt32 GetHeight(plUInt32 uiMipLevel = 0) const
  {
    PL_ASSERT_DEV(uiMipLevel < m_uiNumMipLevels, "Invalid mip level");
    return plMath::Max(m_uiHeight >> uiMipLevel, 1U);
  }
 
  void SetDepth(plUInt32 uiDepth) { m_uiDepth = uiDepth; }
 
  plUInt32 GetDepth(plUInt32 uiMipLevel = 0) const
  {
    PL_ASSERT_DEV(uiMipLevel < m_uiNumMipLevels, "Invalid mip level");
    return plMath::Max(m_uiDepth >> uiMipLevel, 1U);
  }
 
  void SetNumMipLevels(plUInt32 uiNumMipLevels) { m_uiNumMipLevels = uiNumMipLevels; }
 
  plUInt32 GetNumMipLevels() const { return m_uiNumMipLevels; }
 
  void SetNumFaces(plUInt32 uiNumFaces) { m_uiNumFaces = uiNumFaces; }
 
  plUInt32 GetNumFaces() const { return m_uiNumFaces; }
 
  void SetNumArrayIndices(plUInt32 uiNumArrayIndices) { m_uiNumArrayIndices = uiNumArrayIndices; }
 
  plUInt32 GetNumArrayIndices() const { return m_uiNumArrayIndices; }
 
  plUInt32 GetPlaneCount() const
  {
    return plImageFormat::GetPlaneCount(m_Format);
  }
 
  plUInt32 GetNumBlocksX(plUInt32 uiMipLevel = 0, plUInt32 uiPlaneIndex = 0) const
  {
    return plImageFormat::GetNumBlocksX(m_Format, GetWidth(uiMipLevel), uiPlaneIndex);
  }
 
  plUInt32 GetNumBlocksY(plUInt32 uiMipLevel = 0, plUInt32 uiPlaneIndex = 0) const
  {
    return plImageFormat::GetNumBlocksY(m_Format, GetHeight(uiMipLevel), uiPlaneIndex);
  }
 
  plUInt32 GetNumBlocksZ(plUInt32 uiMipLevel = 0, plUInt32 uiPlaneIndex = 0) const
  {
    return plImageFormat::GetNumBlocksZ(m_Format, GetDepth(uiMipLevel), uiPlaneIndex);
  }
 
  plUInt64 GetRowPitch(plUInt32 uiMipLevel = 0, plUInt32 uiPlaneIndex = 0) const
  {
    return plImageFormat::GetRowPitch(m_Format, GetWidth(uiMipLevel), uiPlaneIndex);
  }
 
  plUInt64 GetDepthPitch(plUInt32 uiMipLevel = 0, plUInt32 uiPlaneIndex = 0) const
  {
    return plImageFormat::GetDepthPitch(m_Format, GetWidth(uiMipLevel), GetHeight(uiMipLevel), uiPlaneIndex);
  }
 
  plUInt64 ComputeDataSize() const
  {
    plUInt64 uiDataSize = 0;
 
    for (plUInt32 uiMipLevel = 0; uiMipLevel < GetNumMipLevels(); uiMipLevel++)
    {
      for (plUInt32 uiPlaneIndex = 0; uiPlaneIndex < GetPlaneCount(); ++uiPlaneIndex)
      {
        uiDataSize += GetDepthPitch(uiMipLevel, uiPlaneIndex) * static_cast<plUInt64>(GetDepth(uiMipLevel));
      }
    }
 
    return plMath::SafeMultiply64(uiDataSize, plMath::SafeMultiply32(GetNumArrayIndices(), GetNumFaces()));
  }
 
  plUInt32 ComputeNumberOfMipMaps() const
  {
    plUInt32 numMipMaps = 1;
    plUInt32 width = GetWidth();
    plUInt32 height = GetHeight();
    plUInt32 depth = GetDepth();
 
    while (width > 1 || height > 1 || depth > 1)
    {
      width = plMath::Max(1u, width / 2);
      height = plMath::Max(1u, height / 2);
      depth = plMath::Max(1u, depth / 2);
 
      numMipMaps++;
    }
 
    return numMipMaps;
  }
 
    bool operator==(const plImageHeader& other) const
  {
    return
      m_uiNumMipLevels == other.m_uiNumMipLevels &&
      m_uiNumFaces == other.m_uiNumFaces &&
      m_uiNumArrayIndices == other.m_uiNumArrayIndices &&
      m_uiWidth == other.m_uiWidth &&
      m_uiHeight == other.m_uiHeight &&
      m_uiDepth == other.m_uiDepth &&
      m_Format == other.m_Format;
  }
 
  bool operator!=(const plImageHeader& other) const
  {
    return !operator==(other);
  }
 
protected:
  plUInt32 m_uiNumMipLevels;
  plUInt32 m_uiNumFaces;
  plUInt32 m_uiNumArrayIndices;
 
  plUInt32 m_uiWidth;
  plUInt32 m_uiHeight;
  plUInt32 m_uiDepth;
 
  plImageFormat::Enum m_Format;
};