Hi everyone,

I need some feedback from 3D graphics developers. It relates to this bug
report:
http://www.amiga.org/developer/bugreports/view.php?id=848

Warp3D Nova currently leaves the responsibility to make sure you don't
overwrite data that the GPU is using in the hands of application/game
developers (or the OpenGL library). The advantage is flexibility: you
can write to one part of a VBO/DBO while the GPU is accessing a
different part. Apps/games/OpenGL-libs can call waitDone() with a
submitID to make sure that the GPU is done with a buffer.

This current API design was inspired by the Vulkan API, which does the
same thing. The burden of tracking GPU usage belongs to the app/game,
with the idea that they're best placed to know exactly what they're
trying to achieve. Vulkan is designed to give very low-level hardware
access. It's a result of people like John Carmack begging for
lower-level access so that they can squeeze as much performance out as
possible.

The down side of this arrangement, is that it's possible to accidentally
overwrite data while the GPU is accessing it, causing glitching. The
chance of that happening depends on the CPU & GPU speeds, so it may vary
from machine to machine. This appears to be happening in the bug report
linked to above.

I can eliminate the glitching by having the drivers enforce
single-access to VBOs/DBOs. However, this means that the CPU & GPU can
never access (any part of) a buffer simultaneously, which means that you
won't be able to write to one part of a buffer while the GPU is reading
a different part (i.e., efficient multi-buffering).

So, the big question is: is the efficient multi-buffering using a single
VBO/DBO a feature worth keeping? Or does the burden placed on external
software outweigh the benefit?

It's a trade-off between flexibility or ease-of use. I welcome some
feedback before I make a decision.

regards,
Hans