Question

I’m building an OpenGL app with many small textures. I estimate that I will have a few hundred
textures on the screen at any given moment.

Can anyone recommend best practices for storing all these textures in memory so as to avoid potential performance issues?

I’m also interested in understanding how OpenGL manages textures. Will OpenGL try to store them into GPU memory? If so, how much GPU memory can I count on? If not, how often does OpenGL pass the textures from application memory to the GPU, and should I be worried about latency when this happens?

I’m working with OpenGL 3.3. I intend to use only modern features, i.e. no immediate mode stuff.

Answer 1

1. If you have a large number of small textures, you would be best off combining them into a single large texture with each of the small textures occupying known sub-regions (a technique sometimes called a “texture atlas”). Switching which texture is bound can be expensive, in that it will limit how much of your drawing you can batch together. By combining into one you can minimize the number of times you have to rebind. Alternatively, if your textures are very similarly sized, you might look into using an array texture (introduction here).
2. OpenGL does try to store your textures in GPU memory insofar as possible, but I do not believe that it is guaranteed to actually reside on the graphics card.
3. The amount of GPU memory you have available will be dependent on the hardware you run on and the other demands on the system at the time you run. What exactly “GPU memory” means will vary across machines, it can be discrete and used only be the GPU, shared with main memory, or some combination of the two.
4. Assuming your application is not constantly modifying the textures you should not need to be particularly concerned about latency issues. You will provide OpenGL with the textures once and from that point forward it will manage their location in memory. Assuming you don’t need more texture data than can easily fit in GPU memory every frame, it shouldn’t be cause for concern. If you do need to use a large amount of texture data, try to ensure that you batch all use of a certain texture together to minimize the number of round trips the data has to make. You can also look into the built-in texture compression facilities, supplying something like GL_COMPRESSED_RGBA to your call to glTexImage2D, see the man page for more details.

Of course, as always, your best bet will be to test these things yourself in a situation close to your expected use case. OpenGL provides a good number of guarantees, but much will vary depending on the particular implementation.