Should each texture have its own dedicated renderer in SDL?

1
votes

I'm attempting to learn SDL2 and am having difficulties from a practical perspective. I feel like I have a good understanding of SDL windows, renderers, and textures from an abstract perspective. However, I feel like I need to know more about what's going on under the hood to use them appropriately.

For example, when creating a texture I am required to provide a reference to a renderer. I find this odd. A texture seems like it is a resource that is loaded into VRAM. Why should I need to give a resource a reference to a renderer? I understand why it would be necessary to give a renderer a reference to a texture, however, vice versa it doesn't make any sense.

So that leads to another question. Since each texture requires a renderer, should each texture have its own dedicated renderer, or should multiple textures share a renderer?

I feel like there are consequences going down one route versus the other.

1
sdlsdl-2

1 Answers

4
votes

Short Answers

I believe the reason a SDL_Texture requires a renderer is because some backend implementations (OpenGL?) have contexts (this is essentially what SDL_Renderer is) and the image data must be associated with that particular context. You cannot use a texture created in one context inside of another.

for your other question, no, you don't need or want a renderer for each texture. That probably would only produce correct results with the software backend for the same reason (context).

As @keltar correctly points out none of the renderer's will work with a texture that was created with a different renderer due to a check in SDL_RenderCopy. However, this is strictly an API requirement to keep things consistent, my point above is to highlight that even if that check were absent it would not work for backends such as OpenGL, but there is no technical reason it would not work for the software renderer.

Some Details about SDL_Renderer

Remember that SDL_Renderer is an abstract interface to multiple possible backends (OpenGL, OpenGLES, D3D, Metal, Software, more?). Each of these are going to possibly have restrictions on sharing data between contexts and therefore SDL has to limit itself in the same way to maintain sanity.

Example of OpenGL restrictions

Here is a good resource for general restrictions and platform dependent functionality on OpenGL contexts.

As you can see from that page that sharing between contexts has restrictions.

  1. Sharing can only occur in the same OpenGL implementation

This means that you certainly cant share between an SDL_Renderer using OpenGL an a different SDL_Renderer using another backend.

  1. You can share data between different OpenGL Contexts ... This is done using OS Specific extensions

Since SDL is cross platform this means they would have to write special code for each platform to support this, and all OpenGL implementations may not support it at all so its better for SDL to simply not support this either.

  1. each extra render context has a major impact of the applications performance

while not a restriction, it is a reason why adding support for sharing textures is not worthwhile for SDL.

Final Note: the 'S' in SDL stands for "simple". If you need to share data between contexts SDL is simply the wrong tool for the job.