Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1583 insertions, 0 deletions

diff --git a/gfx/angle/checkout/src/libANGLE/renderer/renderer_utils.cpp b/gfx/angle/checkout/src/libANGLE/renderer/renderer_utils.cpp
new file mode 100644
index 0000000000..152de2f25d
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/renderer/renderer_utils.cpp
@@ -0,0 +1,1583 @@
+//
+// Copyright 2016 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// renderer_utils:
+//   Helper methods pertaining to most or all back-ends.
+//
+
+#include "libANGLE/renderer/renderer_utils.h"
+
+#include "common/string_utils.h"
+#include "common/system_utils.h"
+#include "common/utilities.h"
+#include "image_util/copyimage.h"
+#include "image_util/imageformats.h"
+#include "libANGLE/AttributeMap.h"
+#include "libANGLE/Context.h"
+#include "libANGLE/Context.inl.h"
+#include "libANGLE/Display.h"
+#include "libANGLE/formatutils.h"
+#include "libANGLE/renderer/ContextImpl.h"
+#include "libANGLE/renderer/Format.h"
+#include "platform/Feature.h"
+
+#include <string.h>
+#include <cctype>
+
+namespace angle
+{
+namespace
+{
+// For the sake of feature name matching, underscore is ignored, and the names are matched
+// case-insensitive.  This allows feature names to be overriden both in snake_case (previously used
+// by ANGLE) and camelCase.  The second string (user-provided name) can end in `*` for wildcard
+// matching.
+bool FeatureNameMatch(const std::string &a, const std::string &b)
+{
+    size_t ai = 0;
+    size_t bi = 0;
+
+    while (ai < a.size() && bi < b.size())
+    {
+        if (a[ai] == '_')
+        {
+            ++ai;
+        }
+        if (b[bi] == '_')
+        {
+            ++bi;
+        }
+        if (b[bi] == '*' && bi + 1 == b.size())
+        {
+            // If selected feature name ends in wildcard, match it.
+            return true;
+        }
+        if (std::tolower(a[ai++]) != std::tolower(b[bi++]))
+        {
+            return false;
+        }
+    }
+
+    return ai == a.size() && bi == b.size();
+}
+}  // anonymous namespace
+
+// FeatureSetBase implementation
+void FeatureSetBase::overrideFeatures(const std::vector<std::string> &featureNames, bool enabled)
+{
+    for (const std::string &name : featureNames)
+    {
+        const bool hasWildcard = name.back() == '*';
+        for (auto iter : members)
+        {
+            const std::string &featureName = iter.first;
+            FeatureInfo *feature           = iter.second;
+
+            if (!FeatureNameMatch(featureName, name))
+            {
+                continue;
+            }
+
+            feature->enabled = enabled;
+
+            // If name has a wildcard, try to match it with all features.  Otherwise, bail on first
+            // match, as names are unique.
+            if (!hasWildcard)
+            {
+                break;
+            }
+        }
+    }
+}
+
+void FeatureSetBase::populateFeatureList(FeatureList *features) const
+{
+    for (FeatureMap::const_iterator it = members.begin(); it != members.end(); it++)
+    {
+        features->push_back(it->second);
+    }
+}
+}  // namespace angle
+
+namespace rx
+{
+
+namespace
+{
+// Both D3D and Vulkan support the same set of standard sample positions for 1, 2, 4, 8, and 16
+// samples.  See:
+//
+// - https://msdn.microsoft.com/en-us/library/windows/desktop/ff476218.aspx
+//
+// -
+// https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#primsrast-multisampling
+using SamplePositionsArray                                     = std::array<float, 32>;
+constexpr std::array<SamplePositionsArray, 5> kSamplePositions = {
+    {{{0.5f, 0.5f}},
+     {{0.75f, 0.75f, 0.25f, 0.25f}},
+     {{0.375f, 0.125f, 0.875f, 0.375f, 0.125f, 0.625f, 0.625f, 0.875f}},
+     {{0.5625f, 0.3125f, 0.4375f, 0.6875f, 0.8125f, 0.5625f, 0.3125f, 0.1875f, 0.1875f, 0.8125f,
+       0.0625f, 0.4375f, 0.6875f, 0.9375f, 0.9375f, 0.0625f}},
+     {{0.5625f, 0.5625f, 0.4375f, 0.3125f, 0.3125f, 0.625f,  0.75f,   0.4375f,
+       0.1875f, 0.375f,  0.625f,  0.8125f, 0.8125f, 0.6875f, 0.6875f, 0.1875f,
+       0.375f,  0.875f,  0.5f,    0.0625f, 0.25f,   0.125f,  0.125f,  0.75f,
+       0.0f,    0.5f,    0.9375f, 0.25f,   0.875f,  0.9375f, 0.0625f, 0.0f}}}};
+
+struct IncompleteTextureParameters
+{
+    GLenum sizedInternalFormat;
+    GLenum format;
+    GLenum type;
+    GLubyte clearColor[4];
+};
+
+// Note that for gl::SamplerFormat::Shadow, the clearColor datatype needs to be GLushort and as such
+// we will reinterpret GLubyte[4] as GLushort[2].
+constexpr angle::PackedEnumMap<gl::SamplerFormat, IncompleteTextureParameters>
+    kIncompleteTextureParameters = {
+        {gl::SamplerFormat::Float, {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, {0, 0, 0, 255}}},
+        {gl::SamplerFormat::Unsigned,
+         {GL_RGBA8UI, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE, {0, 0, 0, 255}}},
+        {gl::SamplerFormat::Signed, {GL_RGBA8I, GL_RGBA_INTEGER, GL_BYTE, {0, 0, 0, 127}}},
+        {gl::SamplerFormat::Shadow,
+         {GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, {0, 0, 0, 0}}}};
+
+void CopyColor(gl::ColorF *color)
+{
+    // No-op
+}
+
+void PremultiplyAlpha(gl::ColorF *color)
+{
+    color->red *= color->alpha;
+    color->green *= color->alpha;
+    color->blue *= color->alpha;
+}
+
+void UnmultiplyAlpha(gl::ColorF *color)
+{
+    if (color->alpha != 0.0f)
+    {
+        float invAlpha = 1.0f / color->alpha;
+        color->red *= invAlpha;
+        color->green *= invAlpha;
+        color->blue *= invAlpha;
+    }
+}
+
+void ClipChannelsR(gl::ColorF *color)
+{
+    color->green = 0.0f;
+    color->blue  = 0.0f;
+    color->alpha = 1.0f;
+}
+
+void ClipChannelsRG(gl::ColorF *color)
+{
+    color->blue  = 0.0f;
+    color->alpha = 1.0f;
+}
+
+void ClipChannelsRGB(gl::ColorF *color)
+{
+    color->alpha = 1.0f;
+}
+
+void ClipChannelsLuminance(gl::ColorF *color)
+{
+    color->alpha = 1.0f;
+}
+
+void ClipChannelsAlpha(gl::ColorF *color)
+{
+    color->red   = 0.0f;
+    color->green = 0.0f;
+    color->blue  = 0.0f;
+}
+
+void ClipChannelsNoOp(gl::ColorF *color) {}
+
+void WriteUintColor(const gl::ColorF &color,
+                    PixelWriteFunction colorWriteFunction,
+                    uint8_t *destPixelData)
+{
+    gl::ColorUI destColor(
+        static_cast<unsigned int>(color.red * 255), static_cast<unsigned int>(color.green * 255),
+        static_cast<unsigned int>(color.blue * 255), static_cast<unsigned int>(color.alpha * 255));
+    colorWriteFunction(reinterpret_cast<const uint8_t *>(&destColor), destPixelData);
+}
+
+void WriteFloatColor(const gl::ColorF &color,
+                     PixelWriteFunction colorWriteFunction,
+                     uint8_t *destPixelData)
+{
+    colorWriteFunction(reinterpret_cast<const uint8_t *>(&color), destPixelData);
+}
+
+template <int cols, int rows, bool IsColumnMajor>
+inline int GetFlattenedIndex(int col, int row)
+{
+    if (IsColumnMajor)
+    {
+        return col * rows + row;
+    }
+    else
+    {
+        return row * cols + col;
+    }
+}
+
+template <typename T,
+          bool IsSrcColumnMajor,
+          int colsSrc,
+          int rowsSrc,
+          bool IsDstColumnMajor,
+          int colsDst,
+          int rowsDst>
+void ExpandMatrix(T *target, const GLfloat *value)
+{
+    static_assert(colsSrc <= colsDst && rowsSrc <= rowsDst, "Can only expand!");
+
+    constexpr int kDstFlatSize = colsDst * rowsDst;
+    T staging[kDstFlatSize]    = {0};
+
+    for (int r = 0; r < rowsSrc; r++)
+    {
+        for (int c = 0; c < colsSrc; c++)
+        {
+            int srcIndex = GetFlattenedIndex<colsSrc, rowsSrc, IsSrcColumnMajor>(c, r);
+            int dstIndex = GetFlattenedIndex<colsDst, rowsDst, IsDstColumnMajor>(c, r);
+
+            staging[dstIndex] = static_cast<T>(value[srcIndex]);
+        }
+    }
+
+    memcpy(target, staging, kDstFlatSize * sizeof(T));
+}
+
+template <bool IsSrcColumMajor,
+          int colsSrc,
+          int rowsSrc,
+          bool IsDstColumnMajor,
+          int colsDst,
+          int rowsDst>
+void SetFloatUniformMatrix(unsigned int arrayElementOffset,
+                           unsigned int elementCount,
+                           GLsizei countIn,
+                           const GLfloat *value,
+                           uint8_t *targetData)
+{
+    unsigned int count =
+        std::min(elementCount - arrayElementOffset, static_cast<unsigned int>(countIn));
+
+    const unsigned int targetMatrixStride = colsDst * rowsDst;
+    GLfloat *target                       = reinterpret_cast<GLfloat *>(
+        targetData + arrayElementOffset * sizeof(GLfloat) * targetMatrixStride);
+
+    for (unsigned int i = 0; i < count; i++)
+    {
+        ExpandMatrix<GLfloat, IsSrcColumMajor, colsSrc, rowsSrc, IsDstColumnMajor, colsDst,
+                     rowsDst>(target, value);
+
+        target += targetMatrixStride;
+        value += colsSrc * rowsSrc;
+    }
+}
+
+void SetFloatUniformMatrixFast(unsigned int arrayElementOffset,
+                               unsigned int elementCount,
+                               GLsizei countIn,
+                               size_t matrixSize,
+                               const GLfloat *value,
+                               uint8_t *targetData)
+{
+    const unsigned int count =
+        std::min(elementCount - arrayElementOffset, static_cast<unsigned int>(countIn));
+
+    const uint8_t *valueData = reinterpret_cast<const uint8_t *>(value);
+    targetData               = targetData + arrayElementOffset * matrixSize;
+
+    memcpy(targetData, valueData, matrixSize * count);
+}
+}  // anonymous namespace
+
+bool IsRotatedAspectRatio(SurfaceRotation rotation)
+{
+    switch (rotation)
+    {
+        case SurfaceRotation::Rotated90Degrees:
+        case SurfaceRotation::Rotated270Degrees:
+        case SurfaceRotation::FlippedRotated90Degrees:
+        case SurfaceRotation::FlippedRotated270Degrees:
+            return true;
+        default:
+            return false;
+    }
+}
+
+void RotateRectangle(const SurfaceRotation rotation,
+                     const bool flipY,
+                     const int framebufferWidth,
+                     const int framebufferHeight,
+                     const gl::Rectangle &incoming,
+                     gl::Rectangle *outgoing)
+{
+    // GLES's y-axis points up; Vulkan's points down.
+    switch (rotation)
+    {
+        case SurfaceRotation::Identity:
+            // Do not rotate gl_Position (surface matches the device's orientation):
+            outgoing->x     = incoming.x;
+            outgoing->y     = flipY ? framebufferHeight - incoming.y - incoming.height : incoming.y;
+            outgoing->width = incoming.width;
+            outgoing->height = incoming.height;
+            break;
+        case SurfaceRotation::Rotated90Degrees:
+            // Rotate gl_Position 90 degrees:
+            outgoing->x      = incoming.y;
+            outgoing->y      = flipY ? incoming.x : framebufferWidth - incoming.x - incoming.width;
+            outgoing->width  = incoming.height;
+            outgoing->height = incoming.width;
+            break;
+        case SurfaceRotation::Rotated180Degrees:
+            // Rotate gl_Position 180 degrees:
+            outgoing->x     = framebufferWidth - incoming.x - incoming.width;
+            outgoing->y     = flipY ? incoming.y : framebufferHeight - incoming.y - incoming.height;
+            outgoing->width = incoming.width;
+            outgoing->height = incoming.height;
+            break;
+        case SurfaceRotation::Rotated270Degrees:
+            // Rotate gl_Position 270 degrees:
+            outgoing->x      = framebufferHeight - incoming.y - incoming.height;
+            outgoing->y      = flipY ? framebufferWidth - incoming.x - incoming.width : incoming.x;
+            outgoing->width  = incoming.height;
+            outgoing->height = incoming.width;
+            break;
+        default:
+            UNREACHABLE();
+            break;
+    }
+}
+
+PackPixelsParams::PackPixelsParams()
+    : destFormat(nullptr),
+      outputPitch(0),
+      packBuffer(nullptr),
+      offset(0),
+      rotation(SurfaceRotation::Identity)
+{}
+
+PackPixelsParams::PackPixelsParams(const gl::Rectangle &areaIn,
+                                   const angle::Format &destFormat,
+                                   GLuint outputPitchIn,
+                                   bool reverseRowOrderIn,
+                                   gl::Buffer *packBufferIn,
+                                   ptrdiff_t offsetIn)
+    : area(areaIn),
+      destFormat(&destFormat),
+      outputPitch(outputPitchIn),
+      packBuffer(packBufferIn),
+      reverseRowOrder(reverseRowOrderIn),
+      offset(offsetIn),
+      rotation(SurfaceRotation::Identity)
+{}
+
+void PackPixels(const PackPixelsParams &params,
+                const angle::Format &sourceFormat,
+                int inputPitchIn,
+                const uint8_t *sourceIn,
+                uint8_t *destWithoutOffset)
+{
+    uint8_t *destWithOffset = destWithoutOffset + params.offset;
+
+    const uint8_t *source = sourceIn;
+    int inputPitch        = inputPitchIn;
+    int destWidth         = params.area.width;
+    int destHeight        = params.area.height;
+    int xAxisPitch        = 0;
+    int yAxisPitch        = 0;
+    switch (params.rotation)
+    {
+        case SurfaceRotation::Identity:
+            // The source image is not rotated (i.e. matches the device's orientation), and may or
+            // may not be y-flipped.  The image is row-major.  Each source row (one step along the
+            // y-axis for each step in the dest y-axis) is inputPitch past the previous row.  Along
+            // a row, each source pixel (one step along the x-axis for each step in the dest
+            // x-axis) is sourceFormat.pixelBytes past the previous pixel.
+            xAxisPitch = sourceFormat.pixelBytes;
+            if (params.reverseRowOrder)
+            {
+                // The source image is y-flipped, which means we start at the last row, and each
+                // source row is BEFORE the previous row.
+                source += inputPitchIn * (params.area.height - 1);
+                inputPitch = -inputPitch;
+                yAxisPitch = -inputPitchIn;
+            }
+            else
+            {
+                yAxisPitch = inputPitchIn;
+            }
+            break;
+        case SurfaceRotation::Rotated90Degrees:
+            // The source image is rotated 90 degrees counter-clockwise.  Y-flip is always applied
+            // to rotated images.  The image is column-major.  Each source column (one step along
+            // the source x-axis for each step in the dest y-axis) is inputPitch past the previous
+            // column.  Along a column, each source pixel (one step along the y-axis for each step
+            // in the dest x-axis) is sourceFormat.pixelBytes past the previous pixel.
+            xAxisPitch = inputPitchIn;
+            yAxisPitch = sourceFormat.pixelBytes;
+            destWidth  = params.area.height;
+            destHeight = params.area.width;
+            break;
+        case SurfaceRotation::Rotated180Degrees:
+            // The source image is rotated 180 degrees.  Y-flip is always applied to rotated
+            // images.  The image is row-major, but upside down.  Each source row (one step along
+            // the y-axis for each step in the dest y-axis) is inputPitch after the previous row.
+            // Along a row, each source pixel (one step along the x-axis for each step in the dest
+            // x-axis) is sourceFormat.pixelBytes BEFORE the previous pixel.
+            xAxisPitch = -static_cast<int>(sourceFormat.pixelBytes);
+            yAxisPitch = inputPitchIn;
+            source += sourceFormat.pixelBytes * (params.area.width - 1);
+            break;
+        case SurfaceRotation::Rotated270Degrees:
+            // The source image is rotated 270 degrees counter-clockwise (or 90 degrees clockwise).
+            // Y-flip is always applied to rotated images.  The image is column-major, where each
+            // column (one step in the source x-axis for one step in the dest y-axis) is inputPitch
+            // BEFORE the previous column.  Along a column, each source pixel (one step along the
+            // y-axis for each step in the dest x-axis) is sourceFormat.pixelBytes BEFORE the
+            // previous pixel.  The first pixel is at the end of the source.
+            xAxisPitch = -inputPitchIn;
+            yAxisPitch = -static_cast<int>(sourceFormat.pixelBytes);
+            destWidth  = params.area.height;
+            destHeight = params.area.width;
+            source += inputPitch * (params.area.height - 1) +
+                      sourceFormat.pixelBytes * (params.area.width - 1);
+            break;
+        default:
+            UNREACHABLE();
+            break;
+    }
+
+    if (params.rotation == SurfaceRotation::Identity && sourceFormat == *params.destFormat)
+    {
+        // Direct copy possible
+        for (int y = 0; y < params.area.height; ++y)
+        {
+            memcpy(destWithOffset + y * params.outputPitch, source + y * inputPitch,
+                   params.area.width * sourceFormat.pixelBytes);
+        }
+        return;
+    }
+
+    FastCopyFunction fastCopyFunc = sourceFormat.fastCopyFunctions.get(params.destFormat->id);
+
+    if (fastCopyFunc)
+    {
+        // Fast copy is possible through some special function
+        fastCopyFunc(source, xAxisPitch, yAxisPitch, destWithOffset, params.destFormat->pixelBytes,
+                     params.outputPitch, destWidth, destHeight);
+        return;
+    }
+
+    PixelWriteFunction pixelWriteFunction = params.destFormat->pixelWriteFunction;
+    ASSERT(pixelWriteFunction != nullptr);
+
+    // Maximum size of any Color<T> type used.
+    uint8_t temp[16];
+    static_assert(sizeof(temp) >= sizeof(gl::ColorF) && sizeof(temp) >= sizeof(gl::ColorUI) &&
+                      sizeof(temp) >= sizeof(gl::ColorI) &&
+                      sizeof(temp) >= sizeof(angle::DepthStencil),
+                  "Unexpected size of pixel struct.");
+
+    PixelReadFunction pixelReadFunction = sourceFormat.pixelReadFunction;
+    ASSERT(pixelReadFunction != nullptr);
+
+    for (int y = 0; y < destHeight; ++y)
+    {
+        for (int x = 0; x < destWidth; ++x)
+        {
+            uint8_t *dest =
+                destWithOffset + y * params.outputPitch + x * params.destFormat->pixelBytes;
+            const uint8_t *src = source + y * yAxisPitch + x * xAxisPitch;
+
+            // readFunc and writeFunc will be using the same type of color, CopyTexImage
+            // will not allow the copy otherwise.
+            pixelReadFunction(src, temp);
+            pixelWriteFunction(temp, dest);
+        }
+    }
+}
+
+bool FastCopyFunctionMap::has(angle::FormatID formatID) const
+{
+    return (get(formatID) != nullptr);
+}
+
+namespace
+{
+
+const FastCopyFunctionMap::Entry *getEntry(const FastCopyFunctionMap::Entry *entry,
+                                           size_t numEntries,
+                                           angle::FormatID formatID)
+{
+    const FastCopyFunctionMap::Entry *end = entry + numEntries;
+    while (entry != end)
+    {
+        if (entry->formatID == formatID)
+        {
+            return entry;
+        }
+        ++entry;
+    }
+
+    return nullptr;
+}
+
+}  // namespace
+
+FastCopyFunction FastCopyFunctionMap::get(angle::FormatID formatID) const
+{
+    const FastCopyFunctionMap::Entry *entry = getEntry(mData, mSize, formatID);
+    return entry ? entry->func : nullptr;
+}
+
+bool ShouldUseDebugLayers(const egl::AttributeMap &attribs)
+{
+    EGLAttrib debugSetting =
+        attribs.get(EGL_PLATFORM_ANGLE_DEBUG_LAYERS_ENABLED_ANGLE, EGL_DONT_CARE);
+
+    // Prefer to enable debug layers when available.
+#if defined(ANGLE_ENABLE_ASSERTS)
+    return (debugSetting != EGL_FALSE);
+#else
+    return (debugSetting == EGL_TRUE);
+#endif  // defined(ANGLE_ENABLE_ASSERTS)
+}
+
+void CopyImageCHROMIUM(const uint8_t *sourceData,
+                       size_t sourceRowPitch,
+                       size_t sourcePixelBytes,
+                       size_t sourceDepthPitch,
+                       PixelReadFunction pixelReadFunction,
+                       uint8_t *destData,
+                       size_t destRowPitch,
+                       size_t destPixelBytes,
+                       size_t destDepthPitch,
+                       PixelWriteFunction pixelWriteFunction,
+                       GLenum destUnsizedFormat,
+                       GLenum destComponentType,
+                       size_t width,
+                       size_t height,
+                       size_t depth,
+                       bool unpackFlipY,
+                       bool unpackPremultiplyAlpha,
+                       bool unpackUnmultiplyAlpha)
+{
+    using ConversionFunction              = void (*)(gl::ColorF *);
+    ConversionFunction conversionFunction = CopyColor;
+    if (unpackPremultiplyAlpha != unpackUnmultiplyAlpha)
+    {
+        if (unpackPremultiplyAlpha)
+        {
+            conversionFunction = PremultiplyAlpha;
+        }
+        else
+        {
+            conversionFunction = UnmultiplyAlpha;
+        }
+    }
+
+    auto clipChannelsFunction = ClipChannelsNoOp;
+    switch (destUnsizedFormat)
+    {
+        case GL_RED:
+            clipChannelsFunction = ClipChannelsR;
+            break;
+        case GL_RG:
+            clipChannelsFunction = ClipChannelsRG;
+            break;
+        case GL_RGB:
+            clipChannelsFunction = ClipChannelsRGB;
+            break;
+        case GL_LUMINANCE:
+            clipChannelsFunction = ClipChannelsLuminance;
+            break;
+        case GL_ALPHA:
+            clipChannelsFunction = ClipChannelsAlpha;
+            break;
+    }
+
+    auto writeFunction = (destComponentType == GL_UNSIGNED_INT) ? WriteUintColor : WriteFloatColor;
+
+    for (size_t z = 0; z < depth; z++)
+    {
+        for (size_t y = 0; y < height; y++)
+        {
+            for (size_t x = 0; x < width; x++)
+            {
+                const uint8_t *sourcePixelData =
+                    sourceData + y * sourceRowPitch + x * sourcePixelBytes + z * sourceDepthPitch;
+
+                gl::ColorF sourceColor;
+                pixelReadFunction(sourcePixelData, reinterpret_cast<uint8_t *>(&sourceColor));
+
+                conversionFunction(&sourceColor);
+                clipChannelsFunction(&sourceColor);
+
+                size_t destY = 0;
+                if (unpackFlipY)
+                {
+                    destY += (height - 1);
+                    destY -= y;
+                }
+                else
+                {
+                    destY += y;
+                }
+
+                uint8_t *destPixelData =
+                    destData + destY * destRowPitch + x * destPixelBytes + z * destDepthPitch;
+                writeFunction(sourceColor, pixelWriteFunction, destPixelData);
+            }
+        }
+    }
+}
+
+// IncompleteTextureSet implementation.
+IncompleteTextureSet::IncompleteTextureSet() : mIncompleteTextureBufferAttachment(nullptr) {}
+
+IncompleteTextureSet::~IncompleteTextureSet() {}
+
+void IncompleteTextureSet::onDestroy(const gl::Context *context)
+{
+    // Clear incomplete textures.
+    for (auto &incompleteTextures : mIncompleteTextures)
+    {
+        for (auto &incompleteTexture : incompleteTextures)
+        {
+            if (incompleteTexture.get() != nullptr)
+            {
+                incompleteTexture->onDestroy(context);
+                incompleteTexture.set(context, nullptr);
+            }
+        }
+    }
+    if (mIncompleteTextureBufferAttachment != nullptr)
+    {
+        mIncompleteTextureBufferAttachment->onDestroy(context);
+        mIncompleteTextureBufferAttachment = nullptr;
+    }
+}
+
+angle::Result IncompleteTextureSet::getIncompleteTexture(
+    const gl::Context *context,
+    gl::TextureType type,
+    gl::SamplerFormat format,
+    MultisampleTextureInitializer *multisampleInitializer,
+    gl::Texture **textureOut)
+{
+    *textureOut = mIncompleteTextures[format][type].get();
+    if (*textureOut != nullptr)
+    {
+        return angle::Result::Continue;
+    }
+
+    ContextImpl *implFactory = context->getImplementation();
+
+    gl::Extents colorSize(1, 1, 1);
+    gl::PixelUnpackState unpack;
+    unpack.alignment = 1;
+    gl::Box area(0, 0, 0, 1, 1, 1);
+    const IncompleteTextureParameters &incompleteTextureParam =
+        kIncompleteTextureParameters[format];
+
+    // Cube map arrays are expected to have layer counts that are multiples of 6
+    constexpr int kCubeMapArraySize = 6;
+    if (type == gl::TextureType::CubeMapArray)
+    {
+        // From the GLES 3.2 spec:
+        //   8.18. IMMUTABLE-FORMAT TEXTURE IMAGES
+        //   TexStorage3D Errors
+        //   An INVALID_OPERATION error is generated if any of the following conditions hold:
+        //     * target is TEXTURE_CUBE_MAP_ARRAY and depth is not a multiple of 6
+        // Since ANGLE treats incomplete textures as immutable, respect that here.
+        colorSize.depth = kCubeMapArraySize;
+        area.depth      = kCubeMapArraySize;
+    }
+
+    // If a texture is external use a 2D texture for the incomplete texture
+    gl::TextureType createType = (type == gl::TextureType::External) ? gl::TextureType::_2D : type;
+
+    gl::Texture *tex =
+        new gl::Texture(implFactory, {std::numeric_limits<GLuint>::max()}, createType);
+    angle::UniqueObjectPointer<gl::Texture, gl::Context> t(tex, context);
+
+    // This is a bit of a kludge but is necessary to consume the error.
+    gl::Context *mutableContext = const_cast<gl::Context *>(context);
+
+    if (createType == gl::TextureType::Buffer)
+    {
+        constexpr uint32_t kBufferInitData = 0;
+        mIncompleteTextureBufferAttachment =
+            new gl::Buffer(implFactory, {std::numeric_limits<GLuint>::max()});
+        ANGLE_TRY(mIncompleteTextureBufferAttachment->bufferData(
+            mutableContext, gl::BufferBinding::Texture, &kBufferInitData, sizeof(kBufferInitData),
+            gl::BufferUsage::StaticDraw));
+    }
+    else if (createType == gl::TextureType::_2DMultisample)
+    {
+        ANGLE_TRY(t->setStorageMultisample(mutableContext, createType, 1,
+                                           incompleteTextureParam.sizedInternalFormat, colorSize,
+                                           true));
+    }
+    else
+    {
+        ANGLE_TRY(t->setStorage(mutableContext, createType, 1,
+                                incompleteTextureParam.sizedInternalFormat, colorSize));
+    }
+
+    if (type == gl::TextureType::CubeMap)
+    {
+        for (gl::TextureTarget face : gl::AllCubeFaceTextureTargets())
+        {
+            ANGLE_TRY(t->setSubImage(mutableContext, unpack, nullptr, face, 0, area,
+                                     incompleteTextureParam.format, incompleteTextureParam.type,
+                                     incompleteTextureParam.clearColor));
+        }
+    }
+    else if (type == gl::TextureType::CubeMapArray)
+    {
+        // We need to provide enough pixel data to fill the array of six faces
+        GLubyte incompleteCubeArrayPixels[kCubeMapArraySize][4];
+        for (int i = 0; i < kCubeMapArraySize; ++i)
+        {
+            incompleteCubeArrayPixels[i][0] = incompleteTextureParam.clearColor[0];
+            incompleteCubeArrayPixels[i][1] = incompleteTextureParam.clearColor[1];
+            incompleteCubeArrayPixels[i][2] = incompleteTextureParam.clearColor[2];
+            incompleteCubeArrayPixels[i][3] = incompleteTextureParam.clearColor[3];
+        }
+
+        ANGLE_TRY(t->setSubImage(mutableContext, unpack, nullptr,
+                                 gl::NonCubeTextureTypeToTarget(createType), 0, area,
+                                 incompleteTextureParam.format, incompleteTextureParam.type,
+                                 *incompleteCubeArrayPixels));
+    }
+    else if (type == gl::TextureType::_2DMultisample)
+    {
+        // Call a specialized clear function to init a multisample texture.
+        ANGLE_TRY(multisampleInitializer->initializeMultisampleTextureToBlack(context, t.get()));
+    }
+    else if (type == gl::TextureType::Buffer)
+    {
+        ANGLE_TRY(t->setBuffer(context, mIncompleteTextureBufferAttachment,
+                               incompleteTextureParam.sizedInternalFormat));
+    }
+    else
+    {
+        ANGLE_TRY(t->setSubImage(mutableContext, unpack, nullptr,
+                                 gl::NonCubeTextureTypeToTarget(createType), 0, area,
+                                 incompleteTextureParam.format, incompleteTextureParam.type,
+                                 incompleteTextureParam.clearColor));
+    }
+
+    if (format == gl::SamplerFormat::Shadow)
+    {
+        // To avoid the undefined spec behavior for shadow samplers with a depth texture, we set the
+        // compare mode to GL_COMPARE_REF_TO_TEXTURE
+        ASSERT(!t->hasObservers());
+        t->setCompareMode(context, GL_COMPARE_REF_TO_TEXTURE);
+    }
+
+    ANGLE_TRY(t->syncState(context, gl::Command::Other));
+
+    mIncompleteTextures[format][type].set(context, t.release());
+    *textureOut = mIncompleteTextures[format][type].get();
+    return angle::Result::Continue;
+}
+
+#define ANGLE_INSTANTIATE_SET_UNIFORM_MATRIX_FUNC(api, cols, rows) \
+    template void SetFloatUniformMatrix##api<cols, rows>::Run(     \
+        unsigned int, unsigned int, GLsizei, GLboolean, const GLfloat *, uint8_t *)
+
+ANGLE_INSTANTIATE_SET_UNIFORM_MATRIX_FUNC(GLSL, 2, 2);
+ANGLE_INSTANTIATE_SET_UNIFORM_MATRIX_FUNC(GLSL, 3, 3);
+ANGLE_INSTANTIATE_SET_UNIFORM_MATRIX_FUNC(GLSL, 2, 3);
+ANGLE_INSTANTIATE_SET_UNIFORM_MATRIX_FUNC(GLSL, 3, 2);
+ANGLE_INSTANTIATE_SET_UNIFORM_MATRIX_FUNC(GLSL, 4, 2);
+ANGLE_INSTANTIATE_SET_UNIFORM_MATRIX_FUNC(GLSL, 4, 3);
+
+ANGLE_INSTANTIATE_SET_UNIFORM_MATRIX_FUNC(HLSL, 2, 2);
+ANGLE_INSTANTIATE_SET_UNIFORM_MATRIX_FUNC(HLSL, 3, 3);
+ANGLE_INSTANTIATE_SET_UNIFORM_MATRIX_FUNC(HLSL, 2, 3);
+ANGLE_INSTANTIATE_SET_UNIFORM_MATRIX_FUNC(HLSL, 3, 2);
+ANGLE_INSTANTIATE_SET_UNIFORM_MATRIX_FUNC(HLSL, 2, 4);
+ANGLE_INSTANTIATE_SET_UNIFORM_MATRIX_FUNC(HLSL, 3, 4);
+
+#undef ANGLE_INSTANTIATE_SET_UNIFORM_MATRIX_FUNC
+
+#define ANGLE_SPECIALIZATION_ROWS_SET_UNIFORM_MATRIX_FUNC(api, cols, rows)                      \
+    template void SetFloatUniformMatrix##api<cols, 4>::Run(unsigned int, unsigned int, GLsizei, \
+                                                           GLboolean, const GLfloat *, uint8_t *)
+
+template <int cols>
+struct SetFloatUniformMatrixGLSL<cols, 4>
+{
+    static void Run(unsigned int arrayElementOffset,
+                    unsigned int elementCount,
+                    GLsizei countIn,
+                    GLboolean transpose,
+                    const GLfloat *value,
+                    uint8_t *targetData);
+};
+
+ANGLE_SPECIALIZATION_ROWS_SET_UNIFORM_MATRIX_FUNC(GLSL, 2, 4);
+ANGLE_SPECIALIZATION_ROWS_SET_UNIFORM_MATRIX_FUNC(GLSL, 3, 4);
+ANGLE_SPECIALIZATION_ROWS_SET_UNIFORM_MATRIX_FUNC(GLSL, 4, 4);
+
+#undef ANGLE_SPECIALIZATION_ROWS_SET_UNIFORM_MATRIX_FUNC
+
+#define ANGLE_SPECIALIZATION_COLS_SET_UNIFORM_MATRIX_FUNC(api, cols, rows)                      \
+    template void SetFloatUniformMatrix##api<4, rows>::Run(unsigned int, unsigned int, GLsizei, \
+                                                           GLboolean, const GLfloat *, uint8_t *)
+
+template <int rows>
+struct SetFloatUniformMatrixHLSL<4, rows>
+{
+    static void Run(unsigned int arrayElementOffset,
+                    unsigned int elementCount,
+                    GLsizei countIn,
+                    GLboolean transpose,
+                    const GLfloat *value,
+                    uint8_t *targetData);
+};
+
+ANGLE_SPECIALIZATION_COLS_SET_UNIFORM_MATRIX_FUNC(HLSL, 4, 2);
+ANGLE_SPECIALIZATION_COLS_SET_UNIFORM_MATRIX_FUNC(HLSL, 4, 3);
+ANGLE_SPECIALIZATION_COLS_SET_UNIFORM_MATRIX_FUNC(HLSL, 4, 4);
+
+#undef ANGLE_SPECIALIZATION_COLS_SET_UNIFORM_MATRIX_FUNC
+
+template <int cols>
+void SetFloatUniformMatrixGLSL<cols, 4>::Run(unsigned int arrayElementOffset,
+                                             unsigned int elementCount,
+                                             GLsizei countIn,
+                                             GLboolean transpose,
+                                             const GLfloat *value,
+                                             uint8_t *targetData)
+{
+    const bool isSrcColumnMajor = !transpose;
+    if (isSrcColumnMajor)
+    {
+        // Both src and dst matrixs are has same layout,
+        // a single memcpy updates all the matrices
+        constexpr size_t srcMatrixSize = sizeof(GLfloat) * cols * 4;
+        SetFloatUniformMatrixFast(arrayElementOffset, elementCount, countIn, srcMatrixSize, value,
+                                  targetData);
+    }
+    else
+    {
+        // fallback to general cases
+        SetFloatUniformMatrix<false, cols, 4, true, cols, 4>(arrayElementOffset, elementCount,
+                                                             countIn, value, targetData);
+    }
+}
+
+template <int cols, int rows>
+void SetFloatUniformMatrixGLSL<cols, rows>::Run(unsigned int arrayElementOffset,
+                                                unsigned int elementCount,
+                                                GLsizei countIn,
+                                                GLboolean transpose,
+                                                const GLfloat *value,
+                                                uint8_t *targetData)
+{
+    const bool isSrcColumnMajor = !transpose;
+    // GLSL expects matrix uniforms to be column-major, and each column is padded to 4 rows.
+    if (isSrcColumnMajor)
+    {
+        SetFloatUniformMatrix<true, cols, rows, true, cols, 4>(arrayElementOffset, elementCount,
+                                                               countIn, value, targetData);
+    }
+    else
+    {
+        SetFloatUniformMatrix<false, cols, rows, true, cols, 4>(arrayElementOffset, elementCount,
+                                                                countIn, value, targetData);
+    }
+}
+
+template <int rows>
+void SetFloatUniformMatrixHLSL<4, rows>::Run(unsigned int arrayElementOffset,
+                                             unsigned int elementCount,
+                                             GLsizei countIn,
+                                             GLboolean transpose,
+                                             const GLfloat *value,
+                                             uint8_t *targetData)
+{
+    const bool isSrcColumnMajor = !transpose;
+    if (!isSrcColumnMajor)
+    {
+        // Both src and dst matrixs are has same layout,
+        // a single memcpy updates all the matrices
+        constexpr size_t srcMatrixSize = sizeof(GLfloat) * 4 * rows;
+        SetFloatUniformMatrixFast(arrayElementOffset, elementCount, countIn, srcMatrixSize, value,
+                                  targetData);
+    }
+    else
+    {
+        // fallback to general cases
+        SetFloatUniformMatrix<true, 4, rows, false, 4, rows>(arrayElementOffset, elementCount,
+                                                             countIn, value, targetData);
+    }
+}
+
+template <int cols, int rows>
+void SetFloatUniformMatrixHLSL<cols, rows>::Run(unsigned int arrayElementOffset,
+                                                unsigned int elementCount,
+                                                GLsizei countIn,
+                                                GLboolean transpose,
+                                                const GLfloat *value,
+                                                uint8_t *targetData)
+{
+    const bool isSrcColumnMajor = !transpose;
+    // Internally store matrices as row-major to accomodate HLSL matrix indexing.  Each row is
+    // padded to 4 columns.
+    if (!isSrcColumnMajor)
+    {
+        SetFloatUniformMatrix<false, cols, rows, false, 4, rows>(arrayElementOffset, elementCount,
+                                                                 countIn, value, targetData);
+    }
+    else
+    {
+        SetFloatUniformMatrix<true, cols, rows, false, 4, rows>(arrayElementOffset, elementCount,
+                                                                countIn, value, targetData);
+    }
+}
+
+template void GetMatrixUniform<GLint>(GLenum, GLint *, const GLint *, bool);
+template void GetMatrixUniform<GLuint>(GLenum, GLuint *, const GLuint *, bool);
+
+void GetMatrixUniform(GLenum type, GLfloat *dataOut, const GLfloat *source, bool transpose)
+{
+    int columns = gl::VariableColumnCount(type);
+    int rows    = gl::VariableRowCount(type);
+    for (GLint col = 0; col < columns; ++col)
+    {
+        for (GLint row = 0; row < rows; ++row)
+        {
+            GLfloat *outptr = dataOut + ((col * rows) + row);
+            const GLfloat *inptr =
+                transpose ? source + ((row * 4) + col) : source + ((col * 4) + row);
+            *outptr = *inptr;
+        }
+    }
+}
+
+template <typename NonFloatT>
+void GetMatrixUniform(GLenum type, NonFloatT *dataOut, const NonFloatT *source, bool transpose)
+{
+    UNREACHABLE();
+}
+
+const angle::Format &GetFormatFromFormatType(GLenum format, GLenum type)
+{
+    GLenum sizedInternalFormat    = gl::GetInternalFormatInfo(format, type).sizedInternalFormat;
+    angle::FormatID angleFormatID = angle::Format::InternalFormatToID(sizedInternalFormat);
+    return angle::Format::Get(angleFormatID);
+}
+
+angle::Result ComputeStartVertex(ContextImpl *contextImpl,
+                                 const gl::IndexRange &indexRange,
+                                 GLint baseVertex,
+                                 GLint *firstVertexOut)
+{
+    // The entire index range should be within the limits of a 32-bit uint because the largest
+    // GL index type is GL_UNSIGNED_INT.
+    ASSERT(indexRange.start <= std::numeric_limits<uint32_t>::max() &&
+           indexRange.end <= std::numeric_limits<uint32_t>::max());
+
+    // The base vertex is only used in DrawElementsIndirect. Given the assertion above and the
+    // type of mBaseVertex (GLint), adding them both as 64-bit ints is safe.
+    int64_t startVertexInt64 =
+        static_cast<int64_t>(baseVertex) + static_cast<int64_t>(indexRange.start);
+
+    // OpenGL ES 3.2 spec section 10.5: "Behavior of DrawElementsOneInstance is undefined if the
+    // vertex ID is negative for any element"
+    ANGLE_CHECK_GL_MATH(contextImpl, startVertexInt64 >= 0);
+
+    // OpenGL ES 3.2 spec section 10.5: "If the vertex ID is larger than the maximum value
+    // representable by type, it should behave as if the calculation were upconverted to 32-bit
+    // unsigned integers(with wrapping on overflow conditions)." ANGLE does not fully handle
+    // these rules, an overflow error is returned if the start vertex cannot be stored in a
+    // 32-bit signed integer.
+    ANGLE_CHECK_GL_MATH(contextImpl, startVertexInt64 <= std::numeric_limits<GLint>::max());
+
+    *firstVertexOut = static_cast<GLint>(startVertexInt64);
+    return angle::Result::Continue;
+}
+
+angle::Result GetVertexRangeInfo(const gl::Context *context,
+                                 GLint firstVertex,
+                                 GLsizei vertexOrIndexCount,
+                                 gl::DrawElementsType indexTypeOrInvalid,
+                                 const void *indices,
+                                 GLint baseVertex,
+                                 GLint *startVertexOut,
+                                 size_t *vertexCountOut)
+{
+    if (indexTypeOrInvalid != gl::DrawElementsType::InvalidEnum)
+    {
+        gl::IndexRange indexRange;
+        ANGLE_TRY(context->getState().getVertexArray()->getIndexRange(
+            context, indexTypeOrInvalid, vertexOrIndexCount, indices, &indexRange));
+        ANGLE_TRY(ComputeStartVertex(context->getImplementation(), indexRange, baseVertex,
+                                     startVertexOut));
+        *vertexCountOut = indexRange.vertexCount();
+    }
+    else
+    {
+        *startVertexOut = firstVertex;
+        *vertexCountOut = vertexOrIndexCount;
+    }
+    return angle::Result::Continue;
+}
+
+gl::Rectangle ClipRectToScissor(const gl::State &glState, const gl::Rectangle &rect, bool invertY)
+{
+    // If the scissor test isn't enabled, assume it has infinite size.  Its intersection with the
+    // rect would be the rect itself.
+    //
+    // Note that on Vulkan, returning this (as opposed to a fixed max-int-sized rect) could lead to
+    // unnecessary pipeline creations if two otherwise identical pipelines are used on framebuffers
+    // with different sizes.  If such usage is observed in an application, we should investigate
+    // possible optimizations.
+    if (!glState.isScissorTestEnabled())
+    {
+        return rect;
+    }
+
+    gl::Rectangle clippedRect;
+    if (!gl::ClipRectangle(glState.getScissor(), rect, &clippedRect))
+    {
+        return gl::Rectangle();
+    }
+
+    if (invertY)
+    {
+        clippedRect.y = rect.height - clippedRect.y - clippedRect.height;
+    }
+
+    return clippedRect;
+}
+
+void LogFeatureStatus(const angle::FeatureSetBase &features,
+                      const std::vector<std::string> &featureNames,
+                      bool enabled)
+{
+    for (const std::string &name : featureNames)
+    {
+        const bool hasWildcard = name.back() == '*';
+        for (auto iter : features.getFeatures())
+        {
+            const std::string &featureName = iter.first;
+
+            if (!angle::FeatureNameMatch(featureName, name))
+            {
+                continue;
+            }
+
+            INFO() << "Feature: " << featureName << (enabled ? " enabled" : " disabled");
+
+            if (!hasWildcard)
+            {
+                break;
+            }
+        }
+    }
+}
+
+void ApplyFeatureOverrides(angle::FeatureSetBase *features, const egl::DisplayState &state)
+{
+    features->overrideFeatures(state.featureOverridesEnabled, true);
+    features->overrideFeatures(state.featureOverridesDisabled, false);
+
+    // Override with environment as well.
+    constexpr char kAngleFeatureOverridesEnabledEnvName[]  = "ANGLE_FEATURE_OVERRIDES_ENABLED";
+    constexpr char kAngleFeatureOverridesDisabledEnvName[] = "ANGLE_FEATURE_OVERRIDES_DISABLED";
+    constexpr char kAngleFeatureOverridesEnabledPropertyName[] =
+        "debug.angle.feature_overrides_enabled";
+    constexpr char kAngleFeatureOverridesDisabledPropertyName[] =
+        "debug.angle.feature_overrides_disabled";
+    std::vector<std::string> overridesEnabled =
+        angle::GetCachedStringsFromEnvironmentVarOrAndroidProperty(
+            kAngleFeatureOverridesEnabledEnvName, kAngleFeatureOverridesEnabledPropertyName, ":");
+    std::vector<std::string> overridesDisabled =
+        angle::GetCachedStringsFromEnvironmentVarOrAndroidProperty(
+            kAngleFeatureOverridesDisabledEnvName, kAngleFeatureOverridesDisabledPropertyName, ":");
+
+    features->overrideFeatures(overridesEnabled, true);
+    LogFeatureStatus(*features, overridesEnabled, true);
+
+    features->overrideFeatures(overridesDisabled, false);
+    LogFeatureStatus(*features, overridesDisabled, false);
+}
+
+void GetSamplePosition(GLsizei sampleCount, size_t index, GLfloat *xy)
+{
+    ASSERT(gl::isPow2(sampleCount));
+    if (sampleCount > 16)
+    {
+        // Vulkan (and D3D11) doesn't have standard sample positions for 32 and 64 samples (and no
+        // drivers are known to support that many samples)
+        xy[0] = 0.5f;
+        xy[1] = 0.5f;
+    }
+    else
+    {
+        size_t indexKey = static_cast<size_t>(gl::log2(sampleCount));
+        ASSERT(indexKey < kSamplePositions.size() &&
+               (2 * index + 1) < kSamplePositions[indexKey].size());
+
+        xy[0] = kSamplePositions[indexKey][2 * index];
+        xy[1] = kSamplePositions[indexKey][2 * index + 1];
+    }
+}
+
+// These macros are to avoid code too much duplication for variations of multi draw types
+#define DRAW_ARRAYS__ contextImpl->drawArrays(context, mode, firsts[drawID], counts[drawID])
+#define DRAW_ARRAYS_INSTANCED_                                                      \
+    contextImpl->drawArraysInstanced(context, mode, firsts[drawID], counts[drawID], \
+                                     instanceCounts[drawID])
+#define DRAW_ELEMENTS__ \
+    contextImpl->drawElements(context, mode, counts[drawID], type, indices[drawID])
+#define DRAW_ELEMENTS_INSTANCED_                                                             \
+    contextImpl->drawElementsInstanced(context, mode, counts[drawID], type, indices[drawID], \
+                                       instanceCounts[drawID])
+#define DRAW_ARRAYS_INSTANCED_BASE_INSTANCE                                                     \
+    contextImpl->drawArraysInstancedBaseInstance(context, mode, firsts[drawID], counts[drawID], \
+                                                 instanceCounts[drawID], baseInstances[drawID])
+#define DRAW_ELEMENTS_INSTANCED_BASE_VERTEX_BASE_INSTANCE                             \
+    contextImpl->drawElementsInstancedBaseVertexBaseInstance(                         \
+        context, mode, counts[drawID], type, indices[drawID], instanceCounts[drawID], \
+        baseVertices[drawID], baseInstances[drawID])
+#define DRAW_CALL(drawType, instanced, bvbi) DRAW_##drawType##instanced##bvbi
+
+#define MULTI_DRAW_BLOCK(drawType, instanced, bvbi, hasDrawID, hasBaseVertex, hasBaseInstance) \
+    for (GLsizei drawID = 0; drawID < drawcount; ++drawID)                                     \
+    {                                                                                          \
+        if (ANGLE_NOOP_DRAW(instanced))                                                        \
+        {                                                                                      \
+            ANGLE_TRY(contextImpl->handleNoopDrawEvent());                                     \
+            continue;                                                                          \
+        }                                                                                      \
+        ANGLE_SET_DRAW_ID_UNIFORM(hasDrawID)(drawID);                                          \
+        ANGLE_SET_BASE_VERTEX_UNIFORM(hasBaseVertex)(baseVertices[drawID]);                    \
+        ANGLE_SET_BASE_INSTANCE_UNIFORM(hasBaseInstance)(baseInstances[drawID]);               \
+        ANGLE_TRY(DRAW_CALL(drawType, instanced, bvbi));                                       \
+        ANGLE_MARK_TRANSFORM_FEEDBACK_USAGE(instanced);                                        \
+        gl::MarkShaderStorageUsage(context);                                                   \
+    }
+
+angle::Result MultiDrawArraysGeneral(ContextImpl *contextImpl,
+                                     const gl::Context *context,
+                                     gl::PrimitiveMode mode,
+                                     const GLint *firsts,
+                                     const GLsizei *counts,
+                                     GLsizei drawcount)
+{
+    gl::Program *programObject = context->getState().getLinkedProgram(context);
+    const bool hasDrawID       = programObject && programObject->hasDrawIDUniform();
+    if (hasDrawID)
+    {
+        MULTI_DRAW_BLOCK(ARRAYS, _, _, 1, 0, 0)
+    }
+    else
+    {
+        MULTI_DRAW_BLOCK(ARRAYS, _, _, 0, 0, 0)
+    }
+
+    return angle::Result::Continue;
+}
+
+angle::Result MultiDrawArraysIndirectGeneral(ContextImpl *contextImpl,
+                                             const gl::Context *context,
+                                             gl::PrimitiveMode mode,
+                                             const void *indirect,
+                                             GLsizei drawcount,
+                                             GLsizei stride)
+{
+    const GLubyte *indirectPtr = static_cast<const GLubyte *>(indirect);
+
+    for (auto count = 0; count < drawcount; count++)
+    {
+        ANGLE_TRY(contextImpl->drawArraysIndirect(
+            context, mode, reinterpret_cast<const gl::DrawArraysIndirectCommand *>(indirectPtr)));
+        if (stride == 0)
+        {
+            indirectPtr += sizeof(gl::DrawArraysIndirectCommand);
+        }
+        else
+        {
+            indirectPtr += stride;
+        }
+    }
+
+    return angle::Result::Continue;
+}
+
+angle::Result MultiDrawArraysInstancedGeneral(ContextImpl *contextImpl,
+                                              const gl::Context *context,
+                                              gl::PrimitiveMode mode,
+                                              const GLint *firsts,
+                                              const GLsizei *counts,
+                                              const GLsizei *instanceCounts,
+                                              GLsizei drawcount)
+{
+    gl::Program *programObject = context->getState().getLinkedProgram(context);
+    const bool hasDrawID       = programObject && programObject->hasDrawIDUniform();
+    if (hasDrawID)
+    {
+        MULTI_DRAW_BLOCK(ARRAYS, _INSTANCED, _, 1, 0, 0)
+    }
+    else
+    {
+        MULTI_DRAW_BLOCK(ARRAYS, _INSTANCED, _, 0, 0, 0)
+    }
+
+    return angle::Result::Continue;
+}
+
+angle::Result MultiDrawElementsGeneral(ContextImpl *contextImpl,
+                                       const gl::Context *context,
+                                       gl::PrimitiveMode mode,
+                                       const GLsizei *counts,
+                                       gl::DrawElementsType type,
+                                       const GLvoid *const *indices,
+                                       GLsizei drawcount)
+{
+    gl::Program *programObject = context->getState().getLinkedProgram(context);
+    const bool hasDrawID       = programObject && programObject->hasDrawIDUniform();
+    if (hasDrawID)
+    {
+        MULTI_DRAW_BLOCK(ELEMENTS, _, _, 1, 0, 0)
+    }
+    else
+    {
+        MULTI_DRAW_BLOCK(ELEMENTS, _, _, 0, 0, 0)
+    }
+
+    return angle::Result::Continue;
+}
+
+angle::Result MultiDrawElementsIndirectGeneral(ContextImpl *contextImpl,
+                                               const gl::Context *context,
+                                               gl::PrimitiveMode mode,
+                                               gl::DrawElementsType type,
+                                               const void *indirect,
+                                               GLsizei drawcount,
+                                               GLsizei stride)
+{
+    const GLubyte *indirectPtr = static_cast<const GLubyte *>(indirect);
+
+    for (auto count = 0; count < drawcount; count++)
+    {
+        ANGLE_TRY(contextImpl->drawElementsIndirect(
+            context, mode, type,
+            reinterpret_cast<const gl::DrawElementsIndirectCommand *>(indirectPtr)));
+        if (stride == 0)
+        {
+            indirectPtr += sizeof(gl::DrawElementsIndirectCommand);
+        }
+        else
+        {
+            indirectPtr += stride;
+        }
+    }
+
+    return angle::Result::Continue;
+}
+
+angle::Result MultiDrawElementsInstancedGeneral(ContextImpl *contextImpl,
+                                                const gl::Context *context,
+                                                gl::PrimitiveMode mode,
+                                                const GLsizei *counts,
+                                                gl::DrawElementsType type,
+                                                const GLvoid *const *indices,
+                                                const GLsizei *instanceCounts,
+                                                GLsizei drawcount)
+{
+    gl::Program *programObject = context->getState().getLinkedProgram(context);
+    const bool hasDrawID       = programObject && programObject->hasDrawIDUniform();
+    if (hasDrawID)
+    {
+        MULTI_DRAW_BLOCK(ELEMENTS, _INSTANCED, _, 1, 0, 0)
+    }
+    else
+    {
+        MULTI_DRAW_BLOCK(ELEMENTS, _INSTANCED, _, 0, 0, 0)
+    }
+
+    return angle::Result::Continue;
+}
+
+angle::Result MultiDrawArraysInstancedBaseInstanceGeneral(ContextImpl *contextImpl,
+                                                          const gl::Context *context,
+                                                          gl::PrimitiveMode mode,
+                                                          const GLint *firsts,
+                                                          const GLsizei *counts,
+                                                          const GLsizei *instanceCounts,
+                                                          const GLuint *baseInstances,
+                                                          GLsizei drawcount)
+{
+    gl::Program *programObject = context->getState().getLinkedProgram(context);
+    const bool hasDrawID       = programObject && programObject->hasDrawIDUniform();
+    const bool hasBaseInstance = programObject && programObject->hasBaseInstanceUniform();
+    ResetBaseVertexBaseInstance resetUniforms(programObject, false, hasBaseInstance);
+
+    if (hasDrawID && hasBaseInstance)
+    {
+        MULTI_DRAW_BLOCK(ARRAYS, _INSTANCED, _BASE_INSTANCE, 1, 0, 1)
+    }
+    else if (hasDrawID)
+    {
+        MULTI_DRAW_BLOCK(ARRAYS, _INSTANCED, _BASE_INSTANCE, 1, 0, 0)
+    }
+    else if (hasBaseInstance)
+    {
+        MULTI_DRAW_BLOCK(ARRAYS, _INSTANCED, _BASE_INSTANCE, 0, 0, 1)
+    }
+    else
+    {
+        MULTI_DRAW_BLOCK(ARRAYS, _INSTANCED, _BASE_INSTANCE, 0, 0, 0)
+    }
+
+    return angle::Result::Continue;
+}
+
+angle::Result MultiDrawElementsInstancedBaseVertexBaseInstanceGeneral(ContextImpl *contextImpl,
+                                                                      const gl::Context *context,
+                                                                      gl::PrimitiveMode mode,
+                                                                      const GLsizei *counts,
+                                                                      gl::DrawElementsType type,
+                                                                      const GLvoid *const *indices,
+                                                                      const GLsizei *instanceCounts,
+                                                                      const GLint *baseVertices,
+                                                                      const GLuint *baseInstances,
+                                                                      GLsizei drawcount)
+{
+    gl::Program *programObject = context->getState().getLinkedProgram(context);
+    const bool hasDrawID       = programObject && programObject->hasDrawIDUniform();
+    const bool hasBaseVertex   = programObject && programObject->hasBaseVertexUniform();
+    const bool hasBaseInstance = programObject && programObject->hasBaseInstanceUniform();
+    ResetBaseVertexBaseInstance resetUniforms(programObject, hasBaseVertex, hasBaseInstance);
+
+    if (hasDrawID)
+    {
+        if (hasBaseVertex)
+        {
+            if (hasBaseInstance)
+            {
+                MULTI_DRAW_BLOCK(ELEMENTS, _INSTANCED, _BASE_VERTEX_BASE_INSTANCE, 1, 1, 1)
+            }
+            else
+            {
+                MULTI_DRAW_BLOCK(ELEMENTS, _INSTANCED, _BASE_VERTEX_BASE_INSTANCE, 1, 1, 0)
+            }
+        }
+        else
+        {
+            if (hasBaseInstance)
+            {
+                MULTI_DRAW_BLOCK(ELEMENTS, _INSTANCED, _BASE_VERTEX_BASE_INSTANCE, 1, 0, 1)
+            }
+            else
+            {
+                MULTI_DRAW_BLOCK(ELEMENTS, _INSTANCED, _BASE_VERTEX_BASE_INSTANCE, 1, 0, 0)
+            }
+        }
+    }
+    else
+    {
+        if (hasBaseVertex)
+        {
+            if (hasBaseInstance)
+            {
+                MULTI_DRAW_BLOCK(ELEMENTS, _INSTANCED, _BASE_VERTEX_BASE_INSTANCE, 0, 1, 1)
+            }
+            else
+            {
+                MULTI_DRAW_BLOCK(ELEMENTS, _INSTANCED, _BASE_VERTEX_BASE_INSTANCE, 0, 1, 0)
+            }
+        }
+        else
+        {
+            if (hasBaseInstance)
+            {
+                MULTI_DRAW_BLOCK(ELEMENTS, _INSTANCED, _BASE_VERTEX_BASE_INSTANCE, 0, 0, 1)
+            }
+            else
+            {
+                MULTI_DRAW_BLOCK(ELEMENTS, _INSTANCED, _BASE_VERTEX_BASE_INSTANCE, 0, 0, 0)
+            }
+        }
+    }
+
+    return angle::Result::Continue;
+}
+
+ResetBaseVertexBaseInstance::ResetBaseVertexBaseInstance(gl::Program *programObject,
+                                                         bool resetBaseVertex,
+                                                         bool resetBaseInstance)
+    : mProgramObject(programObject),
+      mResetBaseVertex(resetBaseVertex),
+      mResetBaseInstance(resetBaseInstance)
+{}
+
+ResetBaseVertexBaseInstance::~ResetBaseVertexBaseInstance()
+{
+    if (mProgramObject)
+    {
+        // Reset emulated uniforms to zero to avoid affecting other draw calls
+        if (mResetBaseVertex)
+        {
+            mProgramObject->setBaseVertexUniform(0);
+        }
+
+        if (mResetBaseInstance)
+        {
+            mProgramObject->setBaseInstanceUniform(0);
+        }
+    }
+}
+
+angle::FormatID ConvertToSRGB(angle::FormatID formatID)
+{
+    switch (formatID)
+    {
+        case angle::FormatID::R8_UNORM:
+            return angle::FormatID::R8_UNORM_SRGB;
+        case angle::FormatID::R8G8_UNORM:
+            return angle::FormatID::R8G8_UNORM_SRGB;
+        case angle::FormatID::R8G8B8_UNORM:
+            return angle::FormatID::R8G8B8_UNORM_SRGB;
+        case angle::FormatID::R8G8B8A8_UNORM:
+            return angle::FormatID::R8G8B8A8_UNORM_SRGB;
+        case angle::FormatID::B8G8R8A8_UNORM:
+            return angle::FormatID::B8G8R8A8_UNORM_SRGB;
+        case angle::FormatID::BC1_RGB_UNORM_BLOCK:
+            return angle::FormatID::BC1_RGB_UNORM_SRGB_BLOCK;
+        case angle::FormatID::BC1_RGBA_UNORM_BLOCK:
+            return angle::FormatID::BC1_RGBA_UNORM_SRGB_BLOCK;
+        case angle::FormatID::BC2_RGBA_UNORM_BLOCK:
+            return angle::FormatID::BC2_RGBA_UNORM_SRGB_BLOCK;
+        case angle::FormatID::BC3_RGBA_UNORM_BLOCK:
+            return angle::FormatID::BC3_RGBA_UNORM_SRGB_BLOCK;
+        case angle::FormatID::BC7_RGBA_UNORM_BLOCK:
+            return angle::FormatID::BC7_RGBA_UNORM_SRGB_BLOCK;
+        case angle::FormatID::ETC2_R8G8B8_UNORM_BLOCK:
+            return angle::FormatID::ETC2_R8G8B8_SRGB_BLOCK;
+        case angle::FormatID::ETC2_R8G8B8A1_UNORM_BLOCK:
+            return angle::FormatID::ETC2_R8G8B8A1_SRGB_BLOCK;
+        case angle::FormatID::ETC2_R8G8B8A8_UNORM_BLOCK:
+            return angle::FormatID::ETC2_R8G8B8A8_SRGB_BLOCK;
+        case angle::FormatID::ASTC_4x4_UNORM_BLOCK:
+            return angle::FormatID::ASTC_4x4_SRGB_BLOCK;
+        case angle::FormatID::ASTC_5x4_UNORM_BLOCK:
+            return angle::FormatID::ASTC_5x4_SRGB_BLOCK;
+        case angle::FormatID::ASTC_5x5_UNORM_BLOCK:
+            return angle::FormatID::ASTC_5x5_SRGB_BLOCK;
+        case angle::FormatID::ASTC_6x5_UNORM_BLOCK:
+            return angle::FormatID::ASTC_6x5_SRGB_BLOCK;
+        case angle::FormatID::ASTC_6x6_UNORM_BLOCK:
+            return angle::FormatID::ASTC_6x6_SRGB_BLOCK;
+        case angle::FormatID::ASTC_8x5_UNORM_BLOCK:
+            return angle::FormatID::ASTC_8x5_SRGB_BLOCK;
+        case angle::FormatID::ASTC_8x6_UNORM_BLOCK:
+            return angle::FormatID::ASTC_8x6_SRGB_BLOCK;
+        case angle::FormatID::ASTC_8x8_UNORM_BLOCK:
+            return angle::FormatID::ASTC_8x8_SRGB_BLOCK;
+        case angle::FormatID::ASTC_10x5_UNORM_BLOCK:
+            return angle::FormatID::ASTC_10x5_SRGB_BLOCK;
+        case angle::FormatID::ASTC_10x6_UNORM_BLOCK:
+            return angle::FormatID::ASTC_10x6_SRGB_BLOCK;
+        case angle::FormatID::ASTC_10x8_UNORM_BLOCK:
+            return angle::FormatID::ASTC_10x8_SRGB_BLOCK;
+        case angle::FormatID::ASTC_10x10_UNORM_BLOCK:
+            return angle::FormatID::ASTC_10x10_SRGB_BLOCK;
+        case angle::FormatID::ASTC_12x10_UNORM_BLOCK:
+            return angle::FormatID::ASTC_12x10_SRGB_BLOCK;
+        case angle::FormatID::ASTC_12x12_UNORM_BLOCK:
+            return angle::FormatID::ASTC_12x12_SRGB_BLOCK;
+        default:
+            return angle::FormatID::NONE;
+    }
+}
+
+angle::FormatID ConvertToLinear(angle::FormatID formatID)
+{
+    switch (formatID)
+    {
+        case angle::FormatID::R8_UNORM_SRGB:
+            return angle::FormatID::R8_UNORM;
+        case angle::FormatID::R8G8_UNORM_SRGB:
+            return angle::FormatID::R8G8_UNORM;
+        case angle::FormatID::R8G8B8_UNORM_SRGB:
+            return angle::FormatID::R8G8B8_UNORM;
+        case angle::FormatID::R8G8B8A8_UNORM_SRGB:
+            return angle::FormatID::R8G8B8A8_UNORM;
+        case angle::FormatID::B8G8R8A8_UNORM_SRGB:
+            return angle::FormatID::B8G8R8A8_UNORM;
+        case angle::FormatID::BC1_RGB_UNORM_SRGB_BLOCK:
+            return angle::FormatID::BC1_RGB_UNORM_BLOCK;
+        case angle::FormatID::BC1_RGBA_UNORM_SRGB_BLOCK:
+            return angle::FormatID::BC1_RGBA_UNORM_BLOCK;
+        case angle::FormatID::BC2_RGBA_UNORM_SRGB_BLOCK:
+            return angle::FormatID::BC2_RGBA_UNORM_BLOCK;
+        case angle::FormatID::BC3_RGBA_UNORM_SRGB_BLOCK:
+            return angle::FormatID::BC3_RGBA_UNORM_BLOCK;
+        case angle::FormatID::BC7_RGBA_UNORM_SRGB_BLOCK:
+            return angle::FormatID::BC7_RGBA_UNORM_BLOCK;
+        case angle::FormatID::ETC2_R8G8B8_SRGB_BLOCK:
+            return angle::FormatID::ETC2_R8G8B8_UNORM_BLOCK;
+        case angle::FormatID::ETC2_R8G8B8A1_SRGB_BLOCK:
+            return angle::FormatID::ETC2_R8G8B8A1_UNORM_BLOCK;
+        case angle::FormatID::ETC2_R8G8B8A8_SRGB_BLOCK:
+            return angle::FormatID::ETC2_R8G8B8A8_UNORM_BLOCK;
+        case angle::FormatID::ASTC_4x4_SRGB_BLOCK:
+            return angle::FormatID::ASTC_4x4_UNORM_BLOCK;
+        case angle::FormatID::ASTC_5x4_SRGB_BLOCK:
+            return angle::FormatID::ASTC_5x4_UNORM_BLOCK;
+        case angle::FormatID::ASTC_5x5_SRGB_BLOCK:
+            return angle::FormatID::ASTC_5x5_UNORM_BLOCK;
+        case angle::FormatID::ASTC_6x5_SRGB_BLOCK:
+            return angle::FormatID::ASTC_6x5_UNORM_BLOCK;
+        case angle::FormatID::ASTC_6x6_SRGB_BLOCK:
+            return angle::FormatID::ASTC_6x6_UNORM_BLOCK;
+        case angle::FormatID::ASTC_8x5_SRGB_BLOCK:
+            return angle::FormatID::ASTC_8x5_UNORM_BLOCK;
+        case angle::FormatID::ASTC_8x6_SRGB_BLOCK:
+            return angle::FormatID::ASTC_8x6_UNORM_BLOCK;
+        case angle::FormatID::ASTC_8x8_SRGB_BLOCK:
+            return angle::FormatID::ASTC_8x8_UNORM_BLOCK;
+        case angle::FormatID::ASTC_10x5_SRGB_BLOCK:
+            return angle::FormatID::ASTC_10x5_UNORM_BLOCK;
+        case angle::FormatID::ASTC_10x6_SRGB_BLOCK:
+            return angle::FormatID::ASTC_10x6_UNORM_BLOCK;
+        case angle::FormatID::ASTC_10x8_SRGB_BLOCK:
+            return angle::FormatID::ASTC_10x8_UNORM_BLOCK;
+        case angle::FormatID::ASTC_10x10_SRGB_BLOCK:
+            return angle::FormatID::ASTC_10x10_UNORM_BLOCK;
+        case angle::FormatID::ASTC_12x10_SRGB_BLOCK:
+            return angle::FormatID::ASTC_12x10_UNORM_BLOCK;
+        case angle::FormatID::ASTC_12x12_SRGB_BLOCK:
+            return angle::FormatID::ASTC_12x12_UNORM_BLOCK;
+        default:
+            return angle::FormatID::NONE;
+    }
+}
+
+bool IsOverridableLinearFormat(angle::FormatID formatID)
+{
+    return ConvertToSRGB(formatID) != angle::FormatID::NONE;
+}
+}  // namespace rx