OpenGL Shaders - Should the camera translation happen on the GPU or the CPU?

Question

So currently what I am doing is before loading my elements onto a VBO I create a new matrix and I add them to it. I do that so I can play with the matrix as much as I want. So what I did is I just added the camera position onto the coordinates in the matrix.

Note: the actual position of the objects is saved elsewhere the matrix is a translation stage.

Now, this works but I am not sure if its correct or if I should translate to the camera location in the shaders instead of in the CPU.

So this is my question:

Should the camera translation happen on the GPU or the CPU?

Answer 1

I am not entirely sure what you are currently doing. But the sane way of doing this is to not touch the VBO. Instead, pass one or more transformation matrices as uniforms to your vertex shader and perform the matrix multiplication on the GPU.

Changing your VBO data on the CPU is insane, it means either keeping a copy of your vertex data on the CPU, iterating over it and uploading or mapping the buffer and iterating over it. Either way, it would be insanely slow. The whole point of having a VBO is so you can upload your vertex data once and work concurrently on the CPU while the GPU buggers off and does its thing with said vertex data.

Instead, you just store your vertices once in the vertex buffer, preferably in object space (just for sanity's sake). Then you keep track of a transformation matrix for each object which transforms the vertices from the object's space to clip space. You pass that matrix to your vertex shader and do the multiplications for each vertex on the GPU.

Obviously the GPU is multiplying every vertex by at least one matrix each frame. But the GPU has parallel hardware which does matrix multiplication insanely fast. So especially when your matrices constantly change (e.g. your objects move) this is much faster than doing it on the CPU and updating a massive buffer. Besides, you free your CPU to do other things like physics or audio or whatever.

Now I can imagine you would want to NOT do this if your object never moves, however, GPU matrix multiplication is probably about the same speed as a CPU float multiplication (I don't know specifics). So it is questionable if having more shaders for static objects is worth it.

Summary:

• Updating buffers on the CPU is SLOW.
• Matrix multiplication on the GPU is FAST.
• No buffer update? = free up the CPU.
• Multiplications on the GPU? = easy and fast to move objects (just change the matrix you upload).

Hope this somewhat helped.