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;
		}
	});
}