This PR implements the 2D MSAA in the OpenGL3 backend. It is based on the discussions in #83976 and the already existing code from #84688

Current base commit: 6d6e822 (4.7 Beta 1)

New version (v2)

I overhauled the previous implementation to address the amount of blitting used in my first approach. You can find the implementation details of the older version below. Images are provided after.
I will squash the commits if this approach is approved. For now I'd keep both to have the comparison to the first version available.

Technical details

We create a multisampled framebuffer when turning 2D MSAA on and delete it again when turned off again.

I introduced two new functions in the TextureStorage class:

• render_target_prepare_canvas_msaa in which we copy the scene that is rendered up to this point onto the MSAA framebuffer using the CopyEffects class.
• render_target_finalize_canvas_msaa in which we simply call render_target_do_msaa_resolve which in itself blits the final 2D render onto the normal framebuffer.

These functions are only implemented in the OpenGL backend since these operations are already implied in the other backends.

render_target_prepare_canvas_msaa is called after a potential 3D scene is rendered, before we render the 2D scene. render_target_finalize_canvas_msaa is called after the 2D scene is done rendering. Since Godot supports the rendering of the 3D scene in between the 2D scene which in turn relies on the non-multisampled framebuffer, we need to resolve our MSAA framebuffer before rendering the 3D scene. This means that in this case we need two full resolves in one render cycle.

Furthermore, if the backbuffer is used we might need to copy parts of the frontbuffer onto the backbuffer. For this I introduced a partial resolve in TextureStorage::render_target_copy_to_back_buffer.

For Mobile devices we can still use the GL_EXT_multisampled_render_to_texture extension so we don't need the resolve steps.

Discussion

For this approach I decided to not support MSAA on the backbuffer, apart from the mentioned partial resolve when copying from the frontbuffer to the backbuffer.

1. Because the other backends don't support it as well
2. Because otherwise we would have way too many blitting and copying operations which is counterproductive, especially for the compatibility backend.

I also decided that the partial resolve is a tradeoff worth making, since otherwise we would need to turn off MSAA completely when encountering a copy from the frontbuffer to the backbuffer.

Old version (v1)

Technical details

We create a multisampled framebuffer when turning 2D MSAA on, as well as a multisampled backbuffer if it is needed.

When rendering without the backbuffer we simply have to blit the already rendered 3D scene (if available) to the multisampled framebuffer, render the complete scene and finally resolve the MSAA buffer into the normal framebuffer. I put the final resolve now into the end of RasterizerCanvasGLES3::canvas_render_items, since everything should be already rendererd at this point (but please correct if I am wrong).

When using the backbuffer we have to consider the following things:

• We need to resolve the backbuffer everytime we render onto it, since we sample from it later on
• When copying parts of or the complete render_target we first need to resolve the frontbuffer, so we can sample from it, and after copying we need to blit the backbuffer back to the multisampled backbuffer
• When clearing the backbuffer we need to clear the normal backbuffer as well as the multisampled backbuffer

For Mobile devices we want to use the GL_EXT_multisampled_render_to_texture extension so we don't need the resolve step.

Discussion

While this approach works, we introduce quite a lot of blitting operations when using the backbuffer. If this is not wanted, another approach could be to copy or adjust the relevant shaders (like the copy shader or the default_clip_children_shader) to support multisampled textures.
While making the images below, I noticed that the vulkan backend does not include MSAA on the backbuffer. That would of course also be an option for the OpenGL backend.

Images

No Antialiasing; Scene with lines, meshes, Sprites, screenreading shader, canvasgroup and groups with a clipped child MSAA 8x in OpenGL MSAA 8x in Vulkan MSAA 8x 3D scene with not antialised 2D scene on top in OpenGL MSAA 8x 3D scene with MSAA 8x 2D scene on top in OpenGL MSAA 8x 3D scene in between MSAA 8x 2D scene in OpenGL

closes #69462 and #84688