[Feat] (MG_State/TextureObject): implement GetIndexOfTextureUploadTarget()

MobileGL/MG_State/GLState/TextureState/TextureEnum.h

@@ -20,7 +20,9 @@ namespace MobileGL {
     // Don't tinker with order in this enum
     // it is used in TextureStorage
     enum class TextureUploadTarget {
+        Texture1D,
         Texture2D,
+        Texture3D,
         ProxyTexture2D,
         Texture1DArray,
         ProxyTexture1DArray,

MobileGL/MG_State/GLState/TextureState/TextureObject.cpp

@@ -15,34 +15,34 @@ namespace MobileGL {
             }
 
             const IntVec3 TextureObjectBase::GetMipmapTexelSize(TextureUploadTarget target, Uint mipmapLevel) const {
-                return m_textureStorage.GetTexelSize(0, mipmapLevel);
+                return m_textureStorage.GetTexelSize(GetIndexOfTextureUploadTarget(target), mipmapLevel);
             }
 
             const SizeT TextureObjectBase::GetMipmapByteSize(TextureUploadTarget target, Uint mipmapLevel) const {
-                return m_textureStorage.GetByteSize(0, mipmapLevel);
+                return m_textureStorage.GetByteSize(GetIndexOfTextureUploadTarget(target), mipmapLevel);
             }
 
             void TextureObjectBase::AllocateStorage(TextureUploadTarget uploadTarget, Uint mipmapLevel,
                                                     MipmapInput input) {
                 // don't care target, index always 0
-                m_textureStorage.AllocateLevel(0, mipmapLevel, input);
+                m_textureStorage.AllocateLevel(GetIndexOfTextureUploadTarget(uploadTarget), mipmapLevel, input);
             }
             void TextureObjectBase::UpdateMipmapSubData(TextureUploadTarget uploadTarget, Uint mipmapLevel,
                                                         DataPtr input) {
                 // ditto
-                m_textureStorage.UpdateSubData(0, mipmapLevel, input);
+                m_textureStorage.UpdateSubData(GetIndexOfTextureUploadTarget(uploadTarget), mipmapLevel, input);
             }
             void* TextureObjectBase::MapMipmapData(TextureUploadTarget uploadTarget, Uint mipmapLevel) {
-                return m_textureStorage.MapData(0, mipmapLevel);
+                return m_textureStorage.MapData(GetIndexOfTextureUploadTarget(uploadTarget), mipmapLevel);
             }
 
             void TextureObjectBase::MarkStorageDirty(TextureUploadTarget uploadTarget, Uint mipmapLevel, bool dirty) {
                 // ditto
-                m_textureStorage.MarkDirty(0, mipmapLevel, dirty);
+                m_textureStorage.MarkDirty(GetIndexOfTextureUploadTarget(uploadTarget), mipmapLevel, dirty);
             }
 
             bool TextureObjectBase::IsStorageDirty(TextureUploadTarget uploadTarget, Uint mipmapLevel) const {
-                return m_textureStorage.IsDirty(0, mipmapLevel);
+                return m_textureStorage.IsDirty(GetIndexOfTextureUploadTarget(uploadTarget), mipmapLevel);
             }
 
             // void TextureObjectBase::SetMipmapLevel(const MipmapLevelInput& level) {

MobileGL/MG_State/GLState/TextureState/TextureObject.h

@@ -71,6 +71,8 @@ namespace MobileGL {
                 virtual const UintVec2& GetLevelRange() const = 0;
                 virtual void SetBaseLevel(Uint baseLevel) = 0;
                 virtual void SetMaxLevel(Uint maxLevel) = 0;
+            protected:
+                virtual Uint GetIndexOfTextureUploadTarget(TextureUploadTarget target) const = 0;
             };
 
             class TextureObjectBase : public ITextureObject {

MobileGL/MG_State/GLState/TextureState/TextureObject1D.cpp

@@ -6,6 +6,11 @@ namespace MobileGL {
             TextureObject1D::TextureObject1D(Uint externalIndex)
                             : TextureObjectBase(TextureTarget::Texture1D, externalIndex) {}
 
+            Uint TextureObject1D::GetIndexOfTextureUploadTarget(TextureUploadTarget target) const {
+                MOBILEGL_ASSERT(target == TextureUploadTarget::Texture1D, "Invalid TextureUploadTarget!");
+                return 0;
+            }
+
             // void TextureObject1D::SetMipmapImpl(const MipmapLevelInput& level) {
             //     if (level.size.x() > 0) {
             //         m_mipmaps.push_back(MipmapLevelInternal(level));

MobileGL/MG_State/GLState/TextureState/TextureObject1D.h

@@ -10,6 +10,7 @@ namespace MobileGL {
 
             protected:
                 // void SetMipmapImpl(const MipmapLevelInput& level) override;
+                Uint GetIndexOfTextureUploadTarget(TextureUploadTarget target) const override;
             };
         }
     }

MobileGL/MG_State/GLState/TextureState/TextureObject2D.cpp

@@ -6,6 +6,10 @@ namespace MobileGL {
             TextureObject2D::TextureObject2D(Uint externalIndex)
                 : TextureObjectBase(TextureTarget::Texture2D, externalIndex) {}
 
+            Uint TextureObject2D::GetIndexOfTextureUploadTarget(TextureUploadTarget target) const {
+                MOBILEGL_ASSERT(target == TextureUploadTarget::Texture1D, "Invalid TextureUploadTarget!");
+                return 0;
+            }
             // 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

@@ -9,6 +9,7 @@ namespace MobileGL {
                 explicit TextureObject2D(Uint externalIndex);
 
             protected:
+                Uint GetIndexOfTextureUploadTarget(TextureUploadTarget target) const override;
                 // void SetMipmapImpl(const MipmapLevelInput& level) override;
             };
         }

MobileGL/MG_State/GLState/TextureState/TextureObject3D.cpp

@@ -6,6 +6,10 @@ namespace MobileGL {
             TextureObject3D::TextureObject3D(Uint externalIndex)
                             : TextureObjectBase(TextureTarget::Texture3D, externalIndex) {}
 
+            Uint TextureObject3D::GetIndexOfTextureUploadTarget(TextureUploadTarget target) const {
+                MOBILEGL_ASSERT(target == TextureUploadTarget::Texture3D, "Invalid TextureUploadTarget!");
+                return 0;
+            }
             // 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

@@ -9,6 +9,7 @@ namespace MobileGL {
                 explicit TextureObject3D(Uint externalIndex);
 
             protected:
+                Uint GetIndexOfTextureUploadTarget(TextureUploadTarget target) const override;
                 // void SetMipmapImpl(const MipmapLevelInput& level) override;
             };
         }

MobileGL/MG_Util/Converters/GLToMG/TextureEnumConverter.cpp

@@ -278,9 +278,13 @@ namespace MobileGL {
 
         TextureUploadTarget ConvertGLEnumToTextureUploadTarget(GLenum target) {
             switch (target) {
+            case GL_TEXTURE_1D:
+                return TextureUploadTarget::Texture1D;
             case GL_TEXTURE_2D:
                 return TextureUploadTarget::Texture2D;
-            case GL_PROXY_TEXTURE_2D:
+            case GL_TEXTURE_3D:
+                return TextureUploadTarget::Texture3D;
+                case GL_PROXY_TEXTURE_2D:
                 return TextureUploadTarget::ProxyTexture2D;
             case GL_TEXTURE_1D_ARRAY:
                 return TextureUploadTarget::Texture1DArray;

MobileGL/MG_Util/Converters/MGToGL/TextureEnumConverter.cpp

@@ -274,6 +274,10 @@ namespace MobileGL {
             switch (target) {
             case TextureUploadTarget::Texture2D:
                 return GL_TEXTURE_2D;
+            case TextureUploadTarget::Texture1D:
+                return GL_TEXTURE_1D;
+            case TextureUploadTarget::Texture3D:
+                return GL_TEXTURE_3D;
             case TextureUploadTarget::ProxyTexture2D:
                 return GL_PROXY_TEXTURE_2D;
             case TextureUploadTarget::Texture1DArray: