[Fix] (MG_Backend/DirectGLES, MG_Impl/GLImpl, MG_Util): GL CTS packed_pixels + texture_swizzle readback overhaul - canonical shadow layouts for legacy sized/unsized/packed internal formats (RGB5->RGB565, RGB10/12->RGB16, RGBA2->RGBA4, RGB10_A2(UI)/RGB9_E5/R11F_G11F_B10F packed-word shadows with per-texel encode/decode incl. 5_9_9_9_REV and 10F_11F_11F_REV client types), GL_UNSIGNED_INT_10_10_10_2 pixel type mapping, conversion-first GetTexImage with CPU-shadow fallback for non-attachable formats and stale-temp-FBO detach, narrow implementation read pairs + SNORM read candidates + 2_10_10_10_REV wide-read decode with RGBA expansion, PACK image/skip and SWAP_BYTES honored on the CPU repack (never in ES), state-reset conformance (default-texture TexParameter/TexImage/TexBuffer no-ops, renderbuffer 0 unbind, vertex attrib 0 current value, ActiveTexture up to combined units, UBO binding count clamp), FramebufferTexture3D/TextureLayer slice attachments via glFramebufferTextureLayer, capability-driven FBO UNSUPPORTED for non-renderable colors, ReadPixels integer-ness mismatch error, single-value texture swizzle validation, and DirectGLES 1D/1D-array/2D-array texture emulation (2D/2D-array backend targets matching SPIRV-Cross ES 1D-as-2D shaders)

2026-09-08 04:08:32 +09:00 · 2026-07-16 22:41:54 -04:00
parent 3ca57068a8
commit 870d882fef
21 changed files with 1683 additions and 419 deletions
@@ -60,6 +60,87 @@ namespace MobileGL::MG_Impl::GLImpl {
            return false;
        }

+        // Whether the backend can actually attach this color format to a framebuffer. Preferred
+        // source of truth is the backend's probed format-capability cache (real glCheckFramebufferStatus
+        // probes, so extensions like EXT_render_snorm are respected). Formats a probe-less backend
+        // cannot answer for fall back to a conservative static list of formats no ES driver renders to:
+        // shared-exponent, SNORM, three-channel norm16/float32/sRGB and three-channel integer formats.
+        // Desktop GL treats those as texture-only too (not in the GL 3.3 required-renderable list), so
+        // reporting GL_FRAMEBUFFER_UNSUPPORTED for them is legal.
+        Bool IsColorInternalFormatRenderable(TextureInternalFormat format) {
+            const SizeT formatIndex = static_cast<SizeT>(format);
+            if (MG_Backend::pActiveBackendObject && formatIndex < MG_Backend::kFormatCapabilityFormatCount) {
+                const auto& cache = MG_Backend::pActiveBackendObject->GetFormatCapabilities();
+                const SizeT sentinelFormat = static_cast<SizeT>(TextureInternalFormat::RGBA8);
+                Bool cachePopulated = false;
+                for (SizeT targetIndex = 0; targetIndex < MG_Backend::kFormatCapabilityTargetCount && !cachePopulated;
+                     ++targetIndex) {
+                    cachePopulated = MG_Backend::HasFormatCapability(cache.FullCaps[targetIndex][sentinelFormat],
+                                                                     MG_Backend::FormatCapability::Creatable);
+                }
+                if (cachePopulated) {
+                    for (SizeT targetIndex = 0; targetIndex < MG_Backend::kFormatCapabilityTargetCount;
+                         ++targetIndex) {
+                        if (MG_Backend::HasFormatCapability(cache.FullCaps[targetIndex][formatIndex],
+                                                            MG_Backend::FormatCapability::FramebufferRenderable) ||
+                            MG_Backend::HasFormatCapability(cache.CaveatCaps[targetIndex][formatIndex],
+                                                            MG_Backend::FormatCapability::FramebufferRenderable)) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+            }
+            switch (format) {
+            case TextureInternalFormat::RGB9E5:
+            case TextureInternalFormat::R8Snorm:
+            case TextureInternalFormat::RG8Snorm:
+            case TextureInternalFormat::RGB8Snorm:
+            case TextureInternalFormat::RGBA8Snorm:
+            case TextureInternalFormat::R16Snorm:
+            case TextureInternalFormat::RG16Snorm:
+            case TextureInternalFormat::RGB16Snorm:
+            case TextureInternalFormat::RGBA16Snorm:
+            case TextureInternalFormat::RGB16:
+            case TextureInternalFormat::RGB10: // stored as RGB16
+            case TextureInternalFormat::RGB12: // stored as RGB16
+            case TextureInternalFormat::RGB16F:
+            case TextureInternalFormat::RGB32F:
+            case TextureInternalFormat::RGB8I:
+            case TextureInternalFormat::RGB8UI:
+            case TextureInternalFormat::RGB16I:
+            case TextureInternalFormat::RGB16UI:
+            case TextureInternalFormat::RGB32I:
+            case TextureInternalFormat::RGB32UI:
+            case TextureInternalFormat::SRGB8:
+                return false;
+            default:
+                return true;
+            }
+        }
+
+        Bool HasNonRenderableColorAttachment(const MG_State::GLState::FramebufferObject& framebufferObject) {
+            const auto& attachments = framebufferObject.GetAllAttachmentObjects();
+            for (SizeT i = 0; i < attachments.size(); ++i) {
+                const auto type = static_cast<FramebufferAttachmentType>(i);
+                if (type < FramebufferAttachmentType::Color0 || type > FramebufferAttachmentType::Color31) {
+                    continue;
+                }
+                const auto& attachment = attachments[i];
+                if (!attachment.IsValid()) continue;
+                TextureInternalFormat format = TextureInternalFormat::Unknown;
+                if (attachment.IsTexture() && attachment.GetTexture()) {
+                    format = attachment.GetTexture()->GetFormat();
+                } else if (attachment.IsRenderbuffer() && attachment.GetRenderbuffer()) {
+                    format = attachment.GetRenderbuffer()->GetInternalFormat();
+                }
+                if (format != TextureInternalFormat::Unknown && !IsColorInternalFormatRenderable(format)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
        void RecordUnsupportedFramebufferTextureAttachmentError(const char* functionName, const char* detail) {
            MG_State::pGLContext->RecordError(
                ErrorCode::InvalidOperation,
@@ -556,6 +637,62 @@ namespace MobileGL::MG_Impl::GLImpl {
        return framebufferObject;
    }

+    // Attaches a single layer/slice of a 3D or array texture. The attachment model stores the layer
+    // index; the DirectGLES backend attaches it with glFramebufferTextureLayer.
+    static void AttachFramebufferTextureLayer(const char* functionName, GLenum target, GLenum attachment,
+                                              GLuint texture, GLint level, GLint layer,
+                                              TextureUploadTarget textureUploadTarget) {
+        if (target == GL_FRAMEBUFFER) {
+            target = GL_DRAW_FRAMEBUFFER;
+        }
+        if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
+            AttachFramebufferTextureLayer(functionName, target, GL_DEPTH_ATTACHMENT, texture, level, layer,
+                                          textureUploadTarget);
+            AttachFramebufferTextureLayer(functionName, target, GL_STENCIL_ATTACHMENT, texture, level, layer,
+                                          textureUploadTarget);
+            return;
+        }
+
+        const FramebufferAttachmentType attachmentType = MG_Util::ConvertGLEnumToFramebufferAttachmentType(attachment);
+        const FramebufferTarget framebufferTarget = MG_Util::ConvertGLEnumToFramebufferTarget(target);
+        if (!FramebufferImpl::ValidateFramebufferAttachmentType(attachmentType)) return;
+        if (!FramebufferImpl::ValidateFramebufferTarget(framebufferTarget)) return;
+        if (!TextureImpl::ValidateTextureName(texture, true)) return;
+
+        auto& bindingSlot = MG_State::pGLContext->GetFramebufferBindingSlot(framebufferTarget);
+        auto& framebufferObject = bindingSlot.GetBoundObject();
+        if (!framebufferObject) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
+                                             "Framebuffer target is bound to no framebuffer object."));
+            return;
+        }
+
+        if (texture == 0) {
+            framebufferObject->Detach(attachmentType);
+            return;
+        }
+
+        auto& textureObject = MG_State::pGLContext->GetTextureObject(texture);
+        if (!textureObject) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName,
+                                             std::format("Texture object {} is not valid.", texture)));
+            return;
+        }
+        if (layer < 0) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidValue,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", functionName, "Layer must be non-negative."));
+            return;
+        }
+
+        framebufferObject->AttachTexture(attachmentType, textureObject, textureUploadTarget, level, layer,
+                                         /*layered=*/false);
+    }
+
    void FramebufferTextureLayer_State(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) {
        if (texture == 0) {
            const TextureUploadTarget detachTarget = TextureUploadTarget::Texture2D;
@@ -563,10 +700,31 @@ namespace MobileGL::MG_Impl::GLImpl {
            return;
        }

-        static_cast<void>(layer);
-        RecordUnsupportedFramebufferTextureAttachmentError(
-            __func__,
-            "Layered framebuffer texture attachments are not represented by the current framebuffer attachment model.");
+        auto& textureObject = MG_State::pGLContext->GetTextureObject(texture);
+        if (!textureObject) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidOperation,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
+                                             std::format("Texture object {} is not valid.", texture)));
+            return;
+        }
+        TextureUploadTarget textureUploadTarget = TextureUploadTarget::Unknown;
+        switch (textureObject->GetTarget()) {
+        case TextureTarget::Texture3D:
+            textureUploadTarget = TextureUploadTarget::Texture3D;
+            break;
+        case TextureTarget::Texture2DArray:
+            textureUploadTarget = TextureUploadTarget::Texture2DArray;
+            break;
+        case TextureTarget::Texture2DMultisampleArray:
+            textureUploadTarget = TextureUploadTarget::Texture2DMultisampleArray;
+            break;
+        default:
+            RecordUnsupportedFramebufferTextureAttachmentError(
+                __func__, "FramebufferTextureLayer requires a 3D, 2D array or 2D multisample array texture.");
+            return;
+        }
+        AttachFramebufferTextureLayer(__func__, target, attachment, texture, level, layer, textureUploadTarget);
    }

    void FramebufferTexture3D_State(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level,
@@ -578,10 +736,15 @@ namespace MobileGL::MG_Impl::GLImpl {
            return;
        }

-        static_cast<void>(zoffset);
-        RecordUnsupportedFramebufferTextureAttachmentError(
-            __func__,
-            "3D framebuffer texture slice attachments are not represented by the current framebuffer attachment model.");
+        if (textarget != GL_TEXTURE_3D) {
+            MG_State::pGLContext->RecordError(
+                ErrorCode::InvalidEnum,
+                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
+                                             "FramebufferTexture3D requires GL_TEXTURE_3D."));
+            return;
+        }
+        AttachFramebufferTextureLayer(__func__, target, attachment, texture, level, zoffset,
+                                      TextureUploadTarget::Texture3D);
    }

    void FramebufferTexture2D_State(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {
@@ -1252,6 +1415,9 @@ namespace MobileGL::MG_Impl::GLImpl {
                GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT :
                GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT;
        }
+        if (HasNonRenderableColorAttachment(*framebufferObject)) {
+            return GL_FRAMEBUFFER_UNSUPPORTED;
+        }
        if (IsActiveBackendDirectVulkan() &&
            IsUnsupportedFramebufferForDirectVulkan(*framebufferObject)) {
            return GL_FRAMEBUFFER_UNSUPPORTED;
@@ -1277,6 +1443,9 @@ namespace MobileGL::MG_Impl::GLImpl {
                GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT :
                GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT;
        }
+        if (HasNonRenderableColorAttachment(*framebufferObject)) {
+            return GL_FRAMEBUFFER_UNSUPPORTED;
+        }
        if (IsActiveBackendDirectVulkan() &&
            IsUnsupportedFramebufferForDirectVulkan(*framebufferObject)) {
            return GL_FRAMEBUFFER_UNSUPPORTED;
@@ -1626,8 +1795,8 @@ namespace MobileGL::MG_Impl::GLImpl {
            return false;
        }

-        // Check framebuffer completeness
-        if (!framebufferObject->CheckCompleteness()) {
+        // Check framebuffer completeness (including formats the ES pipeline cannot attach)
+        if (!framebufferObject->CheckCompleteness() || HasNonRenderableColorAttachment(*framebufferObject)) {
            MG_State::pGLContext->RecordError(
                ErrorCode::InvalidFramebufferOperation,
                MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State", "Framebuffer is incomplete"));
@@ -1679,6 +1848,26 @@ namespace MobileGL::MG_Impl::GLImpl {
                                                 "No color buffer for color format"));
                return false;
            }
+
+            // GL 3.3 section 4.3.1: GL_INVALID_OPERATION if format is an integer format and the read
+            // buffer is not an integer format, or vice versa (GL CTS packed_pixels expects the error
+            // for every *_INTEGER readback from a normalized attachment).
+            const auto& readAttachment = framebufferObject->GetAttachment(readBuffer);
+            TextureInternalFormat attachmentFormat = TextureInternalFormat::Unknown;
+            if (readAttachment.IsTexture() && readAttachment.GetTexture()) {
+                attachmentFormat = readAttachment.GetTexture()->GetFormat();
+            } else if (readAttachment.IsRenderbuffer() && readAttachment.GetRenderbuffer()) {
+                attachmentFormat = readAttachment.GetRenderbuffer()->GetInternalFormat();
+            }
+            if (attachmentFormat != TextureInternalFormat::Unknown &&
+                TextureImpl::IsIntegerColorInputFormat(textureInputFormat) !=
+                    TextureImpl::IsIntegerColorInternalFormat(attachmentFormat)) {
+                MG_State::pGLContext->RecordError(
+                    ErrorCode::InvalidOperation,
+                    MakeUnique<GenericErrorInfo>("MG_Impl/GLImpl", "ReadPixels_State",
+                                                 "Integer-ness of format does not match the read buffer"));
+                return false;
+            }
        }

        // Packed-type/format pairing (GL CTS packed_pixels: e.g. GL_RED with GL_UNSIGNED_SHORT_5_6_5 must