[Fix] (MG_Impl/GLImpl, MG_State/GLState): fix texture integer border color queries [skip ci]

MobileGL/MG_Impl/GLImpl/Texture/GL_Texture.cpp

@@ -31,7 +31,7 @@ namespace MobileGL::MG_Impl::GLImpl {
     static SharedPtr<MG_State::GLState::ITextureObject> nullTextureObject;
     static UnorderedMap<Uint, Bool> g_autoGenerateMipmapByTextureId;
 
-    void GetTexParameteriv_State(GLenum target, GLenum pname, GLint* params);
+    Bool GetTexParameteriv_State(GLenum target, GLenum pname, GLint* params);
 
     namespace {
         void SetTextureBorderColorFromFloats(const SharedPtr<MG_State::GLState::ITextureObject>& textureObject,
@@ -45,6 +45,16 @@ namespace MobileGL::MG_Impl::GLImpl {
                                                     static_cast<Float>(params[2]), static_cast<Float>(params[3])));
         }
 
+        void SetTextureBorderColorFromIntegerInts(const SharedPtr<MG_State::GLState::ITextureObject>& textureObject,
+                                                  const GLint* params) {
+            textureObject->SetBorderColorI(IntVec4(params[0], params[1], params[2], params[3]));
+        }
+
+        void SetTextureBorderColorFromUnsignedInts(const SharedPtr<MG_State::GLState::ITextureObject>& textureObject,
+                                                   const GLuint* params) {
+            textureObject->SetBorderColorUI(UintVec4(params[0], params[1], params[2], params[3]));
+        }
+
         Bool SetTextureSwizzleParamsFromInts(const SharedPtr<MG_State::GLState::ITextureObject>& textureObject,
                                              const GLint* params, const char* caller) {
             Vec4<TextureSwizzleParam> swizzleParams;
@@ -993,7 +1003,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             TextureTarget textureTarget = MG_Util::ConvertGLEnumToTextureTarget(target);
             auto& textureObject = GetTextureObjectByTarget(textureUploadTarget, textureTarget);
             if (!textureObject) return;
-            SetTextureBorderColorFromInts(textureObject, params);
+            SetTextureBorderColorFromIntegerInts(textureObject, params);
             break;
         }
         case GL_TEXTURE_SWIZZLE_RGBA: {
@@ -1021,8 +1031,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             TextureTarget textureTarget = MG_Util::ConvertGLEnumToTextureTarget(target);
             auto& textureObject = GetTextureObjectByTarget(textureUploadTarget, textureTarget);
             if (!textureObject) return;
-            textureObject->SetBorderColor(FloatVec4(static_cast<Float>(params[0]), static_cast<Float>(params[1]),
+            SetTextureBorderColorFromUnsignedInts(textureObject, params);
-                                                    static_cast<Float>(params[2]), static_cast<Float>(params[3])));
             break;
         }
         case GL_TEXTURE_SWIZZLE_RGBA: {
@@ -1499,8 +1508,28 @@ namespace MobileGL::MG_Impl::GLImpl {
     void GetTexParameterIuiv_State(GLenum target, GLenum pname, GLuint* params) {
         if (params == nullptr) return;
 
+        if (pname == GL_TEXTURE_BORDER_COLOR) {
+            TextureUploadTarget textureUploadTarget = MG_Util::ConvertGLEnumToTextureUploadTarget(target);
+            TextureTarget textureTarget = MG_Util::ConvertGLEnumToTextureTarget(target);
+            auto& activeUnit = MG_State::pGLContext->GetTextureUnitObject(MG_State::pGLContext->GetActiveTextureUnit());
+            auto& bindingSlot = activeUnit.GetBindingSlot(textureTarget);
+            Bool isProxy = TextureImpl::IsProxyTextureTarget(textureUploadTarget);
+            auto& textureObject =
+                isProxy ? TextureImpl::pProxyTextureManager->GetProxyTextureObject(textureUploadTarget)
+                        : bindingSlot.GetBoundObject();
+
+            if (!TextureImpl::ValidateTextureObject(textureObject)) return;
+
+            const auto& borderColor = textureObject->GetBorderColorUI();
+            params[0] = borderColor.x();
+            params[1] = borderColor.y();
+            params[2] = borderColor.z();
+            params[3] = borderColor.w();
+            return;
+        }
+
         GLint signedParams[4] = {0, 0, 0, 0};
-        GetTexParameteriv_State(target, pname, signedParams);
+        if (!GetTexParameteriv_State(target, pname, signedParams)) return;
         const int componentCount = pname == GL_TEXTURE_BORDER_COLOR || pname == GL_TEXTURE_SWIZZLE_RGBA ? 4 : 1;
         for (int i = 0; i < componentCount; ++i) {
             params[i] = static_cast<GLuint>(signedParams[i]);
@@ -1508,10 +1537,32 @@ namespace MobileGL::MG_Impl::GLImpl {
     }
 
     void GetTexParameterIiv_State(GLenum target, GLenum pname, GLint* params) {
+        if (params == nullptr) return;
+
+        if (pname == GL_TEXTURE_BORDER_COLOR) {
+            TextureUploadTarget textureUploadTarget = MG_Util::ConvertGLEnumToTextureUploadTarget(target);
+            TextureTarget textureTarget = MG_Util::ConvertGLEnumToTextureTarget(target);
+            auto& activeUnit = MG_State::pGLContext->GetTextureUnitObject(MG_State::pGLContext->GetActiveTextureUnit());
+            auto& bindingSlot = activeUnit.GetBindingSlot(textureTarget);
+            Bool isProxy = TextureImpl::IsProxyTextureTarget(textureUploadTarget);
+            auto& textureObject =
+                isProxy ? TextureImpl::pProxyTextureManager->GetProxyTextureObject(textureUploadTarget)
+                        : bindingSlot.GetBoundObject();
+
+            if (!TextureImpl::ValidateTextureObject(textureObject)) return;
+
+            const auto& borderColor = textureObject->GetBorderColorI();
+            params[0] = borderColor.x();
+            params[1] = borderColor.y();
+            params[2] = borderColor.z();
+            params[3] = borderColor.w();
+            return;
+        }
+
         GetTexParameteriv_State(target, pname, params);
     }
 
-    void GetTexParameteriv_State(GLenum target, GLenum pname, GLint* params) {
+    Bool GetTexParameteriv_State(GLenum target, GLenum pname, GLint* params) {
         // ======================= Converting ================================
         TextureUploadTarget textureUploadTarget = MG_Util::ConvertGLEnumToTextureUploadTarget(target);
         TextureTarget textureTarget = MG_Util::ConvertGLEnumToTextureTarget(target);
@@ -1524,7 +1575,7 @@ namespace MobileGL::MG_Impl::GLImpl {
             isProxy ? TextureImpl::pProxyTextureManager->GetProxyTextureObject(textureUploadTarget)
                     : bindingSlot.GetBoundObject();
 
-        if (!TextureImpl::ValidateTextureObject(textureObject)) return;
+        if (!TextureImpl::ValidateTextureObject(textureObject)) return false;
 
         switch (pname) {
         case GL_TEXTURE_MAG_FILTER:
@@ -1633,8 +1684,10 @@ namespace MobileGL::MG_Impl::GLImpl {
             MG_State::pGLContext->RecordError(ErrorCode::InvalidEnum,
                                               MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "GetTexParameteriv_State",
                                                                            "pname is not a valid texture parameter."));
-            return;
+            return false;
         }
+
+        return true;
     }
 
     void GetTexParameterfv_State(GLenum target, GLenum pname, GLfloat* params) {

MobileGL/MG_State/GLState/TextureState/TextureObject.cpp

@@ -68,6 +68,40 @@ namespace MobileGL {
                 if (color == m_borderColor) return;
 
                 m_borderColor = color;
+                m_borderColorI = IntVec4(static_cast<Int32>(color.x()), static_cast<Int32>(color.y()),
+                                         static_cast<Int32>(color.z()), static_cast<Int32>(color.w()));
+                m_borderColorUI = UintVec4(static_cast<Uint32>(color.x()), static_cast<Uint32>(color.y()),
+                                           static_cast<Uint32>(color.z()), static_cast<Uint32>(color.w()));
+                ++m_textureParamsVersion;
+            }
+
+            const IntVec4& TextureObjectBase::GetBorderColorI() const {
+                return m_borderColorI;
+            }
+
+            void TextureObjectBase::SetBorderColorI(const IntVec4& color) {
+                if (color == m_borderColorI) return;
+
+                m_borderColorI = color;
+                m_borderColorUI = UintVec4(static_cast<Uint32>(color.x()), static_cast<Uint32>(color.y()),
+                                           static_cast<Uint32>(color.z()), static_cast<Uint32>(color.w()));
+                m_borderColor = FloatVec4(static_cast<Float>(color.x()), static_cast<Float>(color.y()),
+                                          static_cast<Float>(color.z()), static_cast<Float>(color.w()));
+                ++m_textureParamsVersion;
+            }
+
+            const UintVec4& TextureObjectBase::GetBorderColorUI() const {
+                return m_borderColorUI;
+            }
+
+            void TextureObjectBase::SetBorderColorUI(const UintVec4& color) {
+                if (color == m_borderColorUI) return;
+
+                m_borderColorUI = color;
+                m_borderColorI = IntVec4(static_cast<Int32>(color.x()), static_cast<Int32>(color.y()),
+                                         static_cast<Int32>(color.z()), static_cast<Int32>(color.w()));
+                m_borderColor = FloatVec4(static_cast<Float>(color.x()), static_cast<Float>(color.y()),
+                                          static_cast<Float>(color.z()), static_cast<Float>(color.w()));
                 ++m_textureParamsVersion;
             }
 

MobileGL/MG_State/GLState/TextureState/TextureObject.h

@@ -32,6 +32,10 @@ namespace MobileGL::MG_State::GLState {
         virtual Uint GetExternalIndex() const = 0;
         virtual const FloatVec4& GetBorderColor() const = 0;
         virtual void SetBorderColor(const FloatVec4& color) = 0;
+        virtual const IntVec4& GetBorderColorI() const = 0;
+        virtual void SetBorderColorI(const IntVec4& color) = 0;
+        virtual const UintVec4& GetBorderColorUI() const = 0;
+        virtual void SetBorderColorUI(const UintVec4& color) = 0;
         virtual TextureSwizzleParam GetSwizzleParam(TextureSwizzleParam param) const = 0;
         virtual void SetSwizzleParam(TextureSwizzleParam param, TextureSwizzleParam value) = 0;
         virtual void SetSwizzleParamRGBA(const Vec4<TextureSwizzleParam>& values) = 0;
@@ -64,6 +68,10 @@ namespace MobileGL::MG_State::GLState {
         Uint GetExternalIndex() const override;
         const FloatVec4& GetBorderColor() const override;
         void SetBorderColor(const FloatVec4& color) override;
+        const IntVec4& GetBorderColorI() const override;
+        void SetBorderColorI(const IntVec4& color) override;
+        const UintVec4& GetBorderColorUI() const override;
+        void SetBorderColorUI(const UintVec4& color) override;
         TextureSwizzleParam GetSwizzleParam(TextureSwizzleParam param) const override;
         const Vec4<TextureSwizzleParam>& GetAllSwizzleParams() const override;
         void SetSwizzleParam(TextureSwizzleParam param, TextureSwizzleParam value) override;
@@ -87,6 +95,8 @@ namespace MobileGL::MG_State::GLState {
         TextureInternalFormat m_internalFormat = TextureInternalFormat::Unknown;
         SharedPtr<SamplerObject> m_sampler = nullptr;
         FloatVec4 m_borderColor = {0.0f, 0.0f, 0.0f, 0.0f};
+        IntVec4 m_borderColorI = {0, 0, 0, 0};
+        UintVec4 m_borderColorUI = {0, 0, 0, 0};
         Vec4<TextureSwizzleParam> m_swizzleParams = {TextureSwizzleParam::Red, TextureSwizzleParam::Green,
                                                      TextureSwizzleParam::Blue, TextureSwizzleParam::Alpha};
         UintVec2 m_levelRange = {0, 1000};