Game Development Stack Exchange is a question and answer site for professional and independent game developers. It only takes a minute to sign up.
Sign up to join this community
Platform is OpenGL ES 1.x. I am using glGetFloatv() to get MODELVIEW matrix. This allows me to compute points, where I need to draw a shadow effect. This is very handy, as I can forget about complexity of scene (its translations, rotations, etc.) – and by simple 3x1 matrix multiplication get the points.
But here it is stated that the call should be avoided. Is it correct recommendation? Can be glGetFloatv() omitted?
From a pure performance standpoint, the glGet*() functions should generally be avoided where possible, as they can introduce unnecessary synchronization points inside the graphics driver. Basically, when you call glGet*(), the driver may have to stall the CPU and wait for the GPU to finish any outstanding rendering operations, so that a correct and up-to-date value can be returned from glGet*(). Even better, the performance penalty may vary from driver to driver, so what runs fine on one platform may be unacceptably slow on another.
The faster (but much less convenient) solution is to manually cache any necessary render state in the application code. For example, when you pass a MODELVIEW matrix to OpenGL, keep an extra copy around for yourself, so you don't need to call glGetFloatv() later to retrieve it.
That said, a single call to glGetFloatv() per frame probably isn't going to kill your performance. Just use these functions sparingly, be aware of their potential side effects, and profile often!
The fastest way to solve this would be to use modern, programmable pipeline OpenGL (2.0 ES), since you would typically be creating the model, view and projection matrices on the client side, and would thus never need to request them from the server.
I don't know if this is an option for you -- you may be supporting older devices.
This is going to be driver-dependent behaviour, so an absolute one-size-fits-all answer won't be possible. However, while the general rule is that any glGet call should be avoided, in certain cases they can be used without undue problems.
The reason for this is that not every glGet call will be dependent on the result of previous GPU-side operations, and that it's only those that are so dependent that will involve synchronization and pipeline stall/flush problems.
In the case of the current modelview matrix, this will - generally - always be calculated CPU-side by the driver, then sent to the GPU for actual use when a draw call occurs. So a glGetFloatv on the current modelview matrix won't actually need to round-trip to the GPU - it can just grab the copy of it that the driver is storing CPU-side and give that back to your program.
