swung0x48/MobileGL
1
0
Fork 0
mirror of https://github.com/MobileGL-Dev/MobileGL synced 2026-09-11 05:38:31 +09:00
Code Issues Packages Projects Releases Wiki Activity

[Feat] (MG_State/TextureState): refractor mipmap (TextureStorage)

Browse Source
This commit is contained in:
swung0x48
2025-11-25 00:10:13 +08:00
parent 73b583cc00
commit 419a67cd08
15 changed files with 520 additions and 312 deletions
Download Patch File Download Diff File Expand all files Collapse all files
MobileGL/MG_State/GLState/FramebufferState/FramebufferObject.cpp
+2 -1
View File
@@ -51,7 +51,8 @@ namespace MobileGL {
IntVec3 FramebufferAttachment::GetSize() const {
if (IsTexture()) {
return m_texture->GetMipmap(m_textureLevel).size;
// TODO: get correct upload target
return m_texture->GetMipmapTexelSize(TextureUploadTarget::Texture2D, m_textureLevel);
} else if (IsRenderbuffer()) {
// TODO
}
MobileGL/MG_State/GLState/TextureState/TextureEnum.h
+181
View File
@@ -0,0 +1,181 @@
#pragma once
namespace MobileGL {
enum class TextureTarget {
Texture1D,
Texture2D,
Texture3D,
TextureCubeMap,
TextureRectangle,
Texture2DMultisample,
TextureBuffer,
Texture1DArray,
Texture2DArray,
TextureCubeMapArray,
Texture2DMultisampleArray,
TextureTargetCount,
Unknown = -1
};
// Don't tinker with order in this enum
// it is used in TextureStorage
enum class TextureUploadTarget {
Texture2D,
ProxyTexture2D,
Texture1DArray,
ProxyTexture1DArray,
TextureRectangle,
ProxyTextureRectangle,
CubeMapPositiveX,
CubeMapNegativeX,
CubeMapPositiveY,
CubeMapNegativeY,
CubeMapPositiveZ,
CubeMapNegativeZ,
ProxyCubeMap,
Texture2DMultisample,
ProxyTexture2DMultisample,
TextureUploadTargetCount,
Unknown = -1
};
enum class TextureInputFormat {
Red,
RG,
RGB,
BGR,
RGBA,
BGRA,
RInteger,
RGInteger,
RGBInteger,
BGRInteger,
RGBAInteger,
BGRAInteger,
StencilIndex,
DepthComponent,
DepthStencil,
FormatCount,
Unknown = -1
};
enum class TextureInternalFormat {
R8,
R8Snorm,
R16,
R16Snorm,
RG8,
RG8Snorm,
RG16,
RG16Snorm,
R3G3B2,
RGB4,
RGB5,
RGB8,
RGB8Snorm,
RGB10,
RGB12,
RGB16Snorm,
RGBA2,
RGBA4,
RGB5A1,
RGBA8,
RGBA8Snorm,
RGB10A2,
RGB10A2UI,
RGBA12,
RGBA16,
SRGB8,
SRGB8Alpha8,
R16F,
RG16F,
RGB16F,
RGBA16F,
R32F,
RG32F,
RGB32F,
RGBA32F,
R11FG11FB10F,
RGB9E5,
R8I,
R8UI,
R16I,
R16UI,
R32I,
R32UI,
RG8I,
RG8UI,
RG16I,
RG16UI,
RG32I,
RG32UI,
RGB8I,
RGB8UI,
RGB16I,
RGB16UI,
RGB32I,
RGB32UI,
RGBA8I,
RGBA8UI,
RGBA16I,
RGBA16UI,
RGBA32I,
RGBA32UI,
DepthComponent16,
DepthComponent24,
DepthComponent32, // not a standard format in OpenGL core profile
DepthComponent32F,
Depth24Stencil8,
Depth32FStencil8,
DepthComponent,
DepthStencil,
Red,
RG,
RGB,
RGBA,
TextureInternalFormatCount,
Unknown = -1
};
enum class TexturePixelDataType {
UnsignedByte,
Byte,
UnsignedShort,
Short,
UnsignedInt,
Int,
Float,
UnsignedByte332,
UnsignedByte233Rev,
UnsignedShort565,
UnsignedShort565Rev,
UnsignedShort4444,
UnsignedShort4444Rev,
UnsignedShort5551,
UnsignedShort1555Rev,
UnsignedInt8888,
UnsignedInt8888Rev,
UnsignedInt1010102,
UnsignedInt2101010Rev,
UnsignedInt101111Rev, // not a standard type in OpenGL core profile
UnsignedInt5999Rev, // not a standard type in OpenGL core profile
TypeCount,
Unknown = -1
};
enum class TextureSwizzleParam {
Red,
Green,
Blue,
Alpha,
Zero,
One,
SwizzleParamCount,
Unknown = -1
};
}
MobileGL/MG_State/GLState/TextureState/TextureObject.cpp
+59 -23
View File
@@ -10,10 +10,45 @@ namespace MobileGL {
m_sampler = MakeShared<SamplerObject>(0);
}
void TextureObjectBase::SetMipmapLevel(const MipmapLevelInput& level) {
SetMipmapImpl(level);
Uint TextureObjectBase::GetMipmapLevelCount() const {
return m_textureStorage.GetLevelCount();
}
const IntVec3 TextureObjectBase::GetMipmapTexelSize(TextureUploadTarget target, Uint mipmapLevel) const {
return m_textureStorage.GetTexelSize(0, mipmapLevel);
}
const SizeT TextureObjectBase::GetMipmapByteSize(TextureUploadTarget target, Uint mipmapLevel) const {
return m_textureStorage.GetByteSize(0, mipmapLevel);
}
void TextureObjectBase::AllocateStorage(TextureUploadTarget uploadTarget, Uint mipmapLevel,
MipmapInput input) {
// don't care target, index always 0
m_textureStorage.AllocateLevel(0, mipmapLevel, input);
}
void TextureObjectBase::UpdateMipmapSubData(TextureUploadTarget uploadTarget, Uint mipmapLevel,
DataPtr input) {
// ditto
m_textureStorage.UpdateSubData(0, mipmapLevel, input);
}
void* TextureObjectBase::MapMipmapData(TextureUploadTarget uploadTarget, Uint mipmapLevel) {
return m_textureStorage.MapData(0, mipmapLevel);
}
void TextureObjectBase::MarkStorageDirty(TextureUploadTarget uploadTarget, Uint mipmapLevel, bool dirty) {
// ditto
m_textureStorage.MarkDirty(0, mipmapLevel, dirty);
}
bool TextureObjectBase::IsStorageDirty(TextureUploadTarget uploadTarget, Uint mipmapLevel) const {
return m_textureStorage.IsDirty(0, mipmapLevel);
}
// void TextureObjectBase::SetMipmapLevel(const MipmapLevelInput& level) {
// SetMipmapImpl(level);
// }
TextureInternalFormat TextureObjectBase::GetFormat() const {
return m_internalFormat;
}
@@ -23,32 +58,33 @@ namespace MobileGL {
}
IntVec3 TextureObjectBase::GetBaseSize() const {
if (m_mipmaps.empty()) {
if (m_textureStorage.GetLevelCount() == 0) {
return {0, 0, 0};
}
return m_mipmaps[0].size;
return m_textureStorage.GetTexelSize(0, 0);
}
SharedPtr<SamplerObject> TextureObjectBase::GetSamplerObject() const {
return m_sampler;
}
const Vector<MipmapLevelInternal>& TextureObjectBase::GetMipmaps() const {
return m_mipmaps;
}
// const Vector<MipmapLevelInternal>& TextureObjectBase::GetMipmaps() const {
// return m_mipmaps;
// }
Bool TextureObjectBase::IsComplete() const {
if (m_internalFormat == TextureInternalFormat::Unknown) {
return false;
}
if (m_mipmaps.empty()) {
SizeT levelCount = m_textureStorage.GetLevelCount();
if (levelCount == 0) {
return false;
}
for (size_t i = 0; i < m_mipmaps.size(); ++i) {
const auto& level = m_mipmaps[i];
if (level.size.x() <= 0 || level.size.y() <= 0 || level.size.z() <= 0) {
for (size_t i = 0; i < levelCount; ++i) {
const auto& levelSize = m_textureStorage.GetTexelSize(0, i);
if (levelSize.x() <= 0 || levelSize.y() <= 0 || levelSize.z() <= 0) {
return false;
}
}
@@ -57,23 +93,23 @@ namespace MobileGL {
return true;
}
MipmapLevelInternal& TextureObjectBase::GetMipmap(Int index) {
if (index >= m_mipmaps.size()) {
MOBILEGL_ASSERT(false, "GetMipmap: index %d out of bounds, returning last mipmap level", index);
index = static_cast<Int>(m_mipmaps.size() - 1);
}
return m_mipmaps[index];
}
// MipmapLevelInternal& TextureObjectBase::GetMipmap(TextureUploadTarget target, Int index) {
// if (index >= m_mipmaps.size()) {
// MOBILEGL_ASSERT(false, "GetMipmap: index %d out of bounds, returning last mipmap level", index);
// index = static_cast<Int>(m_mipmaps.size() - 1);
// }
// return m_mipmaps[index];
// }
void TextureObjectBase::SetInternalFormat(TextureInternalFormat format) {
m_internalFormat = format;
}
void TextureObjectBase::UnmarkMipmapDirty(Int index) {
if (index >= 0 && index < static_cast<Int>(m_mipmaps.size())) {
m_mipmaps[index].dirty = false;
}
}
// void TextureObjectBase::UnmarkMipmapDirty(Int index) {
// if (index >= 0 && index < static_cast<Int>(m_mipmaps.size())) {
// m_mipmaps[index].dirty = false;
// }
// }
Uint TextureObjectBase::GetExternalIndex() const {
return m_externalIndex;
MobileGL/MG_State/GLState/TextureState/TextureObject.h
+31 -186
View File
@@ -1,186 +1,12 @@
#pragma once
#include "TextureEnum.h"
#include "TextureStorage.h"
#include "MG_Util/Types.h"
#include "../SamplerState/SamplerObject.h"
#include <Includes.h>
#include <MG_Util/Math/VectorTypes.h>
namespace MobileGL {
enum class TextureTarget {
Texture1D,
Texture2D,
Texture3D,
TextureCubeMap,
TextureRectangle,
Texture2DMultisample,
TextureBuffer,
Texture1DArray,
Texture2DArray,
TextureCubeMapArray,
Texture2DMultisampleArray,
TextureTargetCount,
Unknown = -1
};
enum class TextureUploadTarget {
Texture2D,
ProxyTexture2D,
Texture1DArray,
ProxyTexture1DArray,
TextureRectangle,
ProxyTextureRectangle,
CubeMapPositiveX,
CubeMapNegativeX,
CubeMapPositiveY,
CubeMapNegativeY,
CubeMapPositiveZ,
CubeMapNegativeZ,
ProxyCubeMap,
Texture2DMultisample,
ProxyTexture2DMultisample,
TextureUploadTargetCount,
Unknown = -1
};
enum class TextureInputFormat {
Red,
RG,
RGB,
BGR,
RGBA,
BGRA,
RInteger,
RGInteger,
RGBInteger,
BGRInteger,
RGBAInteger,
BGRAInteger,
StencilIndex,
DepthComponent,
DepthStencil,
FormatCount,
Unknown = -1
};
enum class TextureInternalFormat {
R8,
R8Snorm,
R16,
R16Snorm,
RG8,
RG8Snorm,
RG16,
RG16Snorm,
R3G3B2,
RGB4,
RGB5,
RGB8,
RGB8Snorm,
RGB10,
RGB12,
RGB16Snorm,
RGBA2,
RGBA4,
RGB5A1,
RGBA8,
RGBA8Snorm,
RGB10A2,
RGB10A2UI,
RGBA12,
RGBA16,
SRGB8,
SRGB8Alpha8,
R16F,
RG16F,
RGB16F,
RGBA16F,
R32F,
RG32F,
RGB32F,
RGBA32F,
R11FG11FB10F,
RGB9E5,
R8I,
R8UI,
R16I,
R16UI,
R32I,
R32UI,
RG8I,
RG8UI,
RG16I,
RG16UI,
RG32I,
RG32UI,
RGB8I,
RGB8UI,
RGB16I,
RGB16UI,
RGB32I,
RGB32UI,
RGBA8I,
RGBA8UI,
RGBA16I,
RGBA16UI,
RGBA32I,
RGBA32UI,
DepthComponent16,
DepthComponent24,
DepthComponent32, // not a standard format in OpenGL core profile
DepthComponent32F,
Depth24Stencil8,
Depth32FStencil8,
DepthComponent,
DepthStencil,
Red,
RG,
RGB,
RGBA,
TextureInternalFormatCount,
Unknown = -1
};
enum class TexturePixelDataType {
UnsignedByte,
Byte,
UnsignedShort,
Short,
UnsignedInt,
Int,
Float,
UnsignedByte332,
UnsignedByte233Rev,
UnsignedShort565,
UnsignedShort565Rev,
UnsignedShort4444,
UnsignedShort4444Rev,
UnsignedShort5551,
UnsignedShort1555Rev,
UnsignedInt8888,
UnsignedInt8888Rev,
UnsignedInt1010102,
UnsignedInt2101010Rev,
UnsignedInt101111Rev, // not a standard type in OpenGL core profile
UnsignedInt5999Rev, // not a standard type in OpenGL core profile
TypeCount,
Unknown = -1
};
enum class TextureSwizzleParam {
Red,
Green,
Blue,
Alpha,
Zero,
One,
SwizzleParamCount,
Unknown = -1
};
namespace MG_State {
namespace GLState {
struct MipmapLevelBase {
@@ -217,10 +43,19 @@ namespace MobileGL {
using TargetEnum = TextureTarget;
virtual ~ITextureObject() = default;
virtual void SetMipmapLevel(const MipmapLevelInput& level) = 0;
virtual const Vector<MipmapLevelInternal>& GetMipmaps() const = 0;
virtual MipmapLevelInternal& GetMipmap(Int index) = 0;
virtual void UnmarkMipmapDirty(Int index) = 0;
// virtual void SetMipmapLevel(const MipmapLevelInput& level) = 0;
// virtual const Vector<MipmapLevelInternal>& GetMipmaps() const = 0;
// virtual MipmapLevelInternal& GetMipmap(Int index) = 0;
// virtual void UnmarkMipmapDirty(Int index) = 0;
virtual Uint GetMipmapLevelCount() const = 0;
virtual const IntVec3 GetMipmapTexelSize(TextureUploadTarget target, Uint mipmapLevel) const = 0;
virtual const SizeT GetMipmapByteSize(TextureUploadTarget target, Uint mipmapLevel) const = 0;
virtual void AllocateStorage(TextureUploadTarget uploadTarget, Uint mipmapLevel, MipmapInput input) = 0;
virtual void UpdateMipmapSubData(TextureUploadTarget uploadTarget, Uint mipmapLevel, DataPtr input) = 0;
virtual void* MapMipmapData(TextureUploadTarget uploadTarget, Uint mipmapLevel) = 0;
virtual void MarkStorageDirty(TextureUploadTarget uploadTarget, Uint mipmapLevel, bool dirty) = 0;
virtual bool IsStorageDirty(TextureUploadTarget uploadTarget, Uint mipmapLevel) const = 0;
virtual TextureInternalFormat GetFormat() const = 0;
virtual TextureTarget GetTarget() const = 0;
@@ -243,10 +78,19 @@ namespace MobileGL {
TextureObjectBase(TextureTarget target, Uint externalIndex);
virtual ~TextureObjectBase() = default;
void SetMipmapLevel(const MipmapLevelInput& level) override;
const Vector<MipmapLevelInternal>& GetMipmaps() const override;
MipmapLevelInternal& GetMipmap(Int index) override;
void UnmarkMipmapDirty(Int index) override;
// void SetMipmapLevel(const MipmapLevelInput& level) override;
// const Vector<MipmapLevelInternal>& GetMipmaps() const override;
// MipmapLevelInternal& GetMipmap(TextureUploadTarget target, Int index) override;
// void UnmarkMipmapDirty(Int index) override;
Uint GetMipmapLevelCount() const override;
const IntVec3 GetMipmapTexelSize(TextureUploadTarget target, Uint mipmapLevel) const override;
const SizeT GetMipmapByteSize(TextureUploadTarget target, Uint mipmapLevel) const override;
void AllocateStorage(TextureUploadTarget uploadTarget, Uint mipmapLevel, MipmapInput input) override;
void UpdateMipmapSubData(TextureUploadTarget uploadTarget, Uint mipmapLevel, DataPtr input) override;
void* MapMipmapData(TextureUploadTarget uploadTarget, Uint mipmapLevel) override;
void MarkStorageDirty(TextureUploadTarget uploadTarget, Uint mipmapLevel, bool dirty) override;
bool IsStorageDirty(TextureUploadTarget uploadTarget, Uint mipmapLevel) const override;
TextureInternalFormat GetFormat() const override;
TextureTarget GetTarget() const override;
@@ -264,12 +108,13 @@ namespace MobileGL {
void SetMaxLevel(Uint maxLevel) override;
protected:
virtual void SetMipmapImpl(const MipmapLevelInput& level) = 0;
// virtual void SetMipmapImpl(const MipmapLevelInput& level) = 0;
const Uint m_externalIndex;
const TextureTarget m_target = TextureTarget::Unknown;
TextureInternalFormat m_internalFormat = TextureInternalFormat::Unknown;
Vector<MipmapLevelInternal> m_mipmaps = {};
// Vector<MipmapLevelInternal> m_mipmaps = {};
TextureStorage<1> m_textureStorage;
SharedPtr<SamplerObject> m_sampler = nullptr;
FloatVec4 m_borderColor = {0.0f, 0.0f, 0.0f, 0.0f};
TextureSwizzleParam m_swizzleParams[4] = {TextureSwizzleParam::Red, TextureSwizzleParam::Green,
MobileGL/MG_State/GLState/TextureState/TextureObject1D.cpp
+5 -5
View File
@@ -6,11 +6,11 @@ namespace MobileGL {
TextureObject1D::TextureObject1D(Uint externalIndex)
: TextureObjectBase(TextureTarget::Texture1D, externalIndex) {}
void TextureObject1D::SetMipmapImpl(const MipmapLevelInput& level) {
if (level.size.x() > 0) {
m_mipmaps.push_back(MipmapLevelInternal(level));
}
}
// void TextureObject1D::SetMipmapImpl(const MipmapLevelInput& level) {
// if (level.size.x() > 0) {
// m_mipmaps.push_back(MipmapLevelInternal(level));
// }
// }
}
}
}
MobileGL/MG_State/GLState/TextureState/TextureObject1D.h
+1 -1
View File
@@ -9,7 +9,7 @@ namespace MobileGL {
explicit TextureObject1D(Uint externalIndex);
protected:
void SetMipmapImpl(const MipmapLevelInput& level) override;
// void SetMipmapImpl(const MipmapLevelInput& level) override;
};
}
}
MobileGL/MG_State/GLState/TextureState/TextureObject2D.cpp
+5 -5
View File
@@ -6,11 +6,11 @@ namespace MobileGL {
TextureObject2D::TextureObject2D(Uint externalIndex)
: TextureObjectBase(TextureTarget::Texture2D, externalIndex) {}
void TextureObject2D::SetMipmapImpl(const MipmapLevelInput& level) {
if (level.size.x() > 0 && level.size.y() > 0) {
m_mipmaps.push_back(MipmapLevelInternal(level));
}
}
// void TextureObject2D::SetMipmapImpl(const MipmapLevelInput& level) {
// if (level.size.x() > 0 && level.size.y() > 0) {
// m_mipmaps.push_back(MipmapLevelInternal(level));
// }
// }
}
}
}
MobileGL/MG_State/GLState/TextureState/TextureObject2D.h
+1 -1
View File
@@ -9,7 +9,7 @@ namespace MobileGL {
explicit TextureObject2D(Uint externalIndex);
protected:
void SetMipmapImpl(const MipmapLevelInput& level) override;
// void SetMipmapImpl(const MipmapLevelInput& level) override;
};
}
}
MobileGL/MG_State/GLState/TextureState/TextureObject3D.cpp
+5 -5
View File
@@ -6,11 +6,11 @@ namespace MobileGL {
TextureObject3D::TextureObject3D(Uint externalIndex)
: TextureObjectBase(TextureTarget::Texture3D, externalIndex) {}
void TextureObject3D::SetMipmapImpl(const MipmapLevelInput& level) {
if (level.size.x() > 0 && level.size.y() > 0 && level.size.z() > 0) {
m_mipmaps.push_back(MipmapLevelInternal(level));
}
}
// void TextureObject3D::SetMipmapImpl(const MipmapLevelInput& level) {
// if (level.size.x() > 0 && level.size.y() > 0 && level.size.z() > 0) {
// m_mipmaps.push_back(MipmapLevelInternal(level));
// }
// }
}
}
}
MobileGL/MG_State/GLState/TextureState/TextureObject3D.h
+1 -1
View File
@@ -9,7 +9,7 @@ namespace MobileGL {
explicit TextureObject3D(Uint externalIndex);
protected:
void SetMipmapImpl(const MipmapLevelInput& level) override;
// void SetMipmapImpl(const MipmapLevelInput& level) override;
};
}
}
MobileGL/MG_State/GLState/TextureState/TextureStorage.h
+103
View File
@@ -0,0 +1,103 @@
#pragma once
#include "TextureEnum.h"
#include "MG_Util/Types.h"
#include "MG_Util/Math/VectorTypes.h"
namespace MobileGL {
namespace MG_State {
namespace GLState {
struct MipmapInput {
IntVec3 texelSize = {0, 0, 0};
SizeT byteSize = 0;
};
template <SizeT TargetCount>
class TextureStorage {
public:
TextureStorage() {
static_assert(TargetCount > 0, "Mipmap size must be greater than zero");
}
void AllocateLevel(Uint targetIndex, Uint level, MipmapInput input) {
MOBILEGL_ASSERT(targetIndex < TargetCount, "AllocateLevel: target invalid");
auto& targetData = m_data[targetIndex];
targetData.reserve(std::bit_ceil(level + 1));
targetData.resize(level + 1);
auto& targetTexelSizes = m_texelSizes[targetIndex];
targetTexelSizes.reserve(std::bit_ceil(level + 1));
targetTexelSizes.resize(level + 1);
targetTexelSizes[level] = input.texelSize;
auto& dirtyArr = m_isDirty[targetIndex];
dirtyArr.resize(level + 1, true);
auto& data = targetData[level];
data.resize(input.byteSize, 0);
// if (input.texelData.data && input.texelData.size > 0) {
// const Uint8* src = static_cast<const Uint8*>(input.texelData.data);
// Memcpy(data.data(), src, input.texelData.size);
// }
}
void UpdateSubData(Uint targetIndex, Uint level, DataPtr input) {
MOBILEGL_ASSERT(targetIndex < TargetCount, "UpdateSubData: target invalid");
auto& targetData = m_data[targetIndex];
MOBILEGL_ASSERT(level < targetData.size(), "UpdateSubData: level out of range");
auto& levelData = targetData[level];
MOBILEGL_ASSERT(levelData.size() < input.size, "UpdateSubData: input data larger than allocated");
if (input.data && input.size > 0) {
const Uint8* src = static_cast<const Uint8*>(input.data);
Memcpy(levelData.data(), src, input.size);
m_isDirty[targetIndex][level] = false;
}
}
void* MapData(Uint targetIndex, Uint level) {
MOBILEGL_ASSERT(targetIndex < TargetCount, "UpdateSubData: target invalid");
auto& targetData = m_data[targetIndex];
MOBILEGL_ASSERT(level < targetData.size(), "UpdateSubData: level out of range");
auto& levelData = targetData[level];
return levelData.data();
}
IntVec3 GetTexelSize(Uint targetIndex, Uint level) const {
MOBILEGL_ASSERT(targetIndex < TargetCount, "GetTexelSize: target invalid");
auto& targetTexelSizes = m_texelSizes[targetIndex];
if (level >= targetTexelSizes.size())
return {0, 0, 0};
return targetTexelSizes[level];
}
SizeT GetByteSize(Uint targetIndex, Uint level) const {
MOBILEGL_ASSERT(targetIndex < TargetCount, "GetByteSize: target invalid");
auto& data = m_data[targetIndex];
return data[level].size();
}
SizeT GetLevelCount() const {
return m_data[0].size();
}
void MarkDirty(Uint targetIndex, Uint level, bool dirty) {
MOBILEGL_ASSERT(targetIndex < TargetCount, "MarkDirty: target invalid");
MOBILEGL_ASSERT(level < m_isDirty[targetIndex].size(), "MarkDirty: level out of range");
m_isDirty[targetIndex][level] = dirty;
}
bool IsDirty(Uint targetIndex, Uint level) const {
MOBILEGL_ASSERT(targetIndex < TargetCount, "IsDirty: target invalid");
MOBILEGL_ASSERT(level < m_isDirty[targetIndex].size(), "IsDirty: level out of range");
return m_isDirty[targetIndex][level];
}
protected:
Array<Vector<IntVec3>, TargetCount> m_texelSizes;
Array<Vector<Vector<Uint8>>, TargetCount> m_data;
Array<Vector<bool>, TargetCount> m_isDirty;
};
}
}
}