[Fix] (DirectGLES, MG_Util): keep 16-bit SNORM precision through the widening

GL_RGB16_SNORM widened to GL_RGBA16F to stay renderable as multisample storage, and
a half float's 11-bit mantissa cannot hold a 16-bit signed-normalized channel:
KHR-GL33.texture_swizzle's blue channel came back several units of 32767 away from
the value the reference computes, well outside its one-unit tolerance.

GL_EXT_render_snorm makes the signed-normalized formats colour-renderable on ES, so
widen to GL_RGBA16_SNORM instead wherever it and EXT_texture_norm16 are both
present, and only fall back to the half float otherwise. Threaded through as its own
normalize option so the capability probe and the runtime pick the same format, the
way every other driver-dependent substitution here is decided.

MobileGL/MG_Backend/DirectGLES/BackendObject_DirectGLES.cpp

@@ -213,6 +213,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
             if (options & PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget) {
                 reasons.push_back("no three-channel multisample storage format on OpenGL ES");
             }
+            if (options & PixelFormatNormalizeOptionBit::NoSnorm16RenderTarget) {
+                reasons.push_back("EXT_render_snorm not supported");
+            }
 
             String reason;
             for (SizeT i = 0; i < reasons.size(); ++i) {
@@ -576,6 +579,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
                     Flags<PixelFormatNormalizeOptionBit> targetOptions;
                     if (IsGLESProbeMultisampleTarget(target)) {
                         targetOptions |= PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget;
+                        if (!capabilities.SupportsRenderSnorm || !capabilities.SupportsNorm16Texture) {
+                            targetOptions |= PixelFormatNormalizeOptionBit::NoSnorm16RenderTarget;
+                        }
                     }
                     GLESProbeFormatInfo fallbackInfo = outerFallbackInfo;
                     Bool hasForcedFallback = outerHasForcedFallback;

MobileGL/MG_Backend/DirectGLES/Utils.cpp

@@ -49,12 +49,9 @@ namespace MobileGL::MG_Backend::DirectGLES {
         }
 
         Flags<PixelFormatNormalizeOptionBit>
-        GetRuntimeFallbackNormalizeOptions(GLenum requestedInternalFormat, Bool mustStayRenderable) {
+        GetRuntimeFallbackNormalizeOptions(GLenum requestedInternalFormat,
+                                           Flags<PixelFormatNormalizeOptionBit> extraOptions) {
             using namespace MG_Util::TextureFormatProcessor;
-            Flags<PixelFormatNormalizeOptionBit> extraOptions;
-            if (mustStayRenderable) {
-                extraOptions |= PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget;
-            }
             const Flags<PixelFormatNormalizeOptionBit> forcedOptions = GetApplicablePixelFormatNormalizeOptions(
                 requestedInternalFormat, GetForcedPixelFormatNormalizeOptions() | extraOptions);
             if (forcedOptions) {
@@ -75,6 +72,18 @@ namespace MobileGL::MG_Backend::DirectGLES {
                    targetIndex == static_cast<SizeT>(TextureTarget::Texture2DMultisampleArray);
         }
 
+        Flags<PixelFormatNormalizeOptionBit> GetRenderTargetNormalizeOptions(SizeT targetIndex) {
+            Flags<PixelFormatNormalizeOptionBit> options;
+            if (!TargetRequiresRenderableFormat(targetIndex)) {
+                return options;
+            }
+            options |= PixelFormatNormalizeOptionBit::NoThreeChannelRenderTarget;
+            if (!g_GLESCapabilities.SupportsRenderSnorm || !g_GLESCapabilities.SupportsNorm16Texture) {
+                options |= PixelFormatNormalizeOptionBit::NoSnorm16RenderTarget;
+            }
+            return options;
+        }
+
         Bool HasCachedFormatCapability(TextureInternalFormat internalFormat,
                                        SizeT targetIndex,
                                        Bool caveat,
@@ -133,7 +142,7 @@ namespace MobileGL::MG_Backend::DirectGLES {
             Flags<PixelFormatNormalizeOptionBit> options;
             if (!pActiveBackendObject || ShouldUseCaveatFormat(internalFormat, targetIndex)) {
                 options = GetRuntimeFallbackNormalizeOptions(requestedInternalFormat,
-                                                             TargetRequiresRenderableFormat(targetIndex));
+                                                             GetRenderTargetNormalizeOptions(targetIndex));
             }
             NormalizePixelFormat(requestedInternalFormat, options, outInternalFormat, outFormat, outType);
         }