OpenGL loading resource in separated thread

0
votes

I am new to multithread OpenGL. I don't want to use shared context in separated thread. I found a way that we can map memory to do asynchronous resource loading.

However I need to tell glBufferData or glTexImage2D to reserve the exact memory size for me. For BMP, we have information in the header. But to know the number of vertices in an obj file, we need to iterate through the whole file... How do commercial game engine do it? Design its own format?

1
multithreadingopengl
You will have to iterate through the file once anyway and pass it's data to some CPU memory. Does it matter whether you allocate GPU memory before parsing the file or afterwards? And yes, most commercial engines have their own internal format. – BDL
What makes you think that "commercial game engines" bother with trash formats like .obj at runtime? – Nicol Bolas
Yeah, even a bad programmer like me can come up with a better format. But is it worth designing a new format? – Tim Hsu

1 Answers

2
votes

A way to load resources asynchronously that worked for me is to push the inevitable read-from-file operations into designated threads. It can be easily combined with lazy resource management like so:

  1. Set up your scene but don't immediately load your resources from file. Instead, flag it as unitialized and store the file paths for later use.
  2. Start rendering your scene
  3. As soon as you encounter a resource flagged as uninitialized, start a thread that asynchronously loads the data from file into a CPU buffer and store meta info (e.g. width and height of textures, number of vertices for meshes etc.) as well. For now, replace the requested resource by some default or simply "do nothing" (assuming your renderer can handle "empty" resources).
  4. In subsequent rendering steps and requests for the resource, check if the associated loading thread has finished and, if so, create the necessary GPU buffers, upload the data and flag the resource as initialized. The stored metadata helps you to figure out the necessary size of the resulting buffers. You can now use the resource as intended.

Handling resources this way avoids sharing OpenGL contexts between multiple threads since you only handle the (presumably very heavy) CPU-bound load-from-file operations asynchronously. Of course, you will have to cope with mutual exclusion to safely check whether or not a loading thread has finished. Furthermore, you might consider defining and maintaining an upload budget for limiting the amount of data transferred from CPU to GPU per frame in order to avoid framerate drops.