private static class GLExt {
    private static class Generic<T> where T : class? {
        internal delegate T? LoadFunctionDelegate(string function, bool throwIfNotFound = false);

        internal static readonly LoadFunctionDelegate LoadFunction =
            typeof(MonoGame.OpenGL.GL).GetStaticMethod("LoadFunction")?.
                MakeGenericMethod(typeof(T)).CreateDelegate<LoadFunctionDelegate>() ??
                ((_, _) => null);
    }

    [System.Security.SuppressUnmanagedCodeSecurity]
    [UnmanagedFunctionPointer(CallingConvention.Winapi)]
    [MonoNativeFunctionWrapper]
    internal delegate void TexStorage2DDelegate(
        TextureTarget target,
        int levels,
        PixelInternalFormat internalFormat,
        int width,
        int height
    );

    internal static readonly TexStorage2DDelegate? TexStorage2D =
        Generic<TexStorage2DDelegate>.LoadFunction("glTexStorage2D");
}

private int ConstructLevel(
    ReadOnlyPinnedSpan<byte> data,
    Vector2I size,
    int level,
    int levelSize,
    bool useSubImage
) {
    if (glFormat == PixelFormat.CompressedTextureFormats) {
        if (useSubImage) {
            MonoGame.OpenGL.GL.CompressedTexSubImage2D(
                TextureTarget.Texture2D,
                level,
                0,
                0,
                size.X,
                size.Y,
                glInternalFormat,
                levelSize,
                data[..levelSize].GetIntPointer()
            );
        }
        else {
            MonoGame.OpenGL.GL.CompressedTexImage2D(
                TextureTarget.Texture2D,
                level,
                glInternalFormat,
                size.X,
                size.Y,
                0,
                levelSize,
                data[..levelSize].GetIntPointer()
            );
        }
    }
    else {
        if (useSubImage) {
            MonoGame.OpenGL.GL.TexSubImage2D(
                TextureTarget.Texture2D,
                level,
                0,
                0,
                size.X,
                size.Y,
                glFormat,
                glType,
                data[..levelSize].GetIntPointer()
            );
        }
        else {
            MonoGame.OpenGL.GL.TexImage2D(
                TextureTarget.Texture2D,
                level,
                glInternalFormat,
                size.X,
                size.Y,
                0,
                glFormat,
                glType,
                data[..levelSize].GetIntPointer()
            );
        }
    }

    GraphicsExtensions.CheckGLError();

    return levelSize;
}

private void Construct(
    ReadOnlyPinnedSpan<byte>.FixedSpan dataIn,
    Vector2I size,
    bool mipmap,
    SurfaceFormat format,
    SurfaceType type,
    bool shared
) {
    glTarget = TextureTarget.Texture2D;
    format.GetGLFormat(GraphicsDevice, out glInternalFormat, out glFormat, out glType);

    // Use glTexStorage2D if it's available.
    // Presently, since we are not yet overriding 'SetData' to use glMeowTexSubImage2D,
    // only use it if we are populating the texture now
    bool useSubImage = !dataIn.IsEmpty && GLExt.TexStorage2D is not null;

    // Calculate the number of texture levels
    int levels = 1;
    if (useSubImage) {
        if (mipmap) {
            var tempDimensions = size;
            while (tempDimensions != (1, 1)) {
                tempDimensions >>= 1;
                tempDimensions = tempDimensions.Min(1);
                ++levels;
            }
        }
    }

    // Mostly taken from MonoGame, but completely refactored.
    // Returns the size given dimensions, adjusted/aligned for block formats.
    Func<Vector2I, int> getLevelSize = format switch {
        // PVRTC has explicit calculations for imageSize
        // https://www.khronos.org/registry/OpenGL/extensions/IMG/IMG_texture_compression_pvrtc.txt
        SurfaceFormat.RgbPvrtc2Bpp or
        SurfaceFormat.RgbaPvrtc2Bpp =>
            static size => {
                var maxDimensions = size.Max((16, 8));
                return ((maxDimensions.X * maxDimensions.Y) << 1 + 7) >> 3;
            },

        SurfaceFormat.RgbPvrtc4Bpp or
        SurfaceFormat.RgbaPvrtc4Bpp =>
            static size => {
                var maxDimensions = size.Max((8, 8));
                return ((maxDimensions.X * maxDimensions.Y) << 2 + 7) >> 3;
            },

        _ when glFormat == PixelFormat.CompressedTextureFormats =>
            size => {
                int blockSize = format.GetSize();
                var blockDimensions = format.BlockEdge();

                var blocks = (size + (blockDimensions - 1)) / blockDimensions;
                return blocks.X * blocks.Y * blockSize;
            },

        _ =>
            size => (int)format.SizeBytes(size.Area)
    };

    Threading.BlockOnUIThread(() => {
        ReadOnlyPinnedSpan<byte> data = default;

        if (!dataIn.IsEmpty) {
            data = dataIn.AsSpan;
        }

        GenerateGLTextureIfRequired();

        if (!data.IsEmpty) {
            MonoGame.OpenGL.GL.PixelStore(PixelStoreParameter.UnpackAlignment, Math.Min(Format.GetSize(), 8));
        }

        if (useSubImage) {
            // https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glTexStorage2D.xhtml
            // Using glTexStorage and glMeowTexSubImage2D to populate textures is more efficient,
            // as the way that MonoGame normally does it requires the texture to be kept largely in flux,
            // and also requires it to be discarded a significant number of times.
            GLExt.TexStorage2D!(
                TextureTarget.Texture2D,
                levels,
                glInternalFormat,
                size.Width,
                size.Height
            );
        }

        var levelDimensions = size;
        int level = 0;
        int currentOffset = 0;

        // Loop over every level and populate it, starting from the largest.
        while (true) {
            currentOffset += ConstructLevel(
                data: data[currentOffset..],
                size: levelDimensions,
                level: level++,
                levelSize: getLevelSize(levelDimensions),
                useSubImage: useSubImage
            );

            if (levelDimensions == (1, 1) || !mipmap)
                break;

            levelDimensions >>= 1;
            levelDimensions = levelDimensions.Min(1);
            ++level;
        }
    });
}