What is the best method to share the projection matrix and view matrix with all graphic entity shaders in a custom game engine?

Question

What is the best method to share the projection matrix and view matrix with all graphic entity shaders in a custom game engine? The refer graphic entities have glUseProgram({shader_program_id}); glDrawArrays(GL_XXXX, x);

One of my ideas is to have a camera object that manages the current view and projection matrix. Then, I pass a reference of that camera object to all the entities. However, my issue with that approach is syncing the current camera across all the entities/objects when switching views.

I could make the Camera global, however, that could have many issues.

Answer 1

In this answer I am assuming that you have a standard 3-matrix setup: projection, view and model. For your static objects the model matrix will be identity; for moving objects it will not. In your shaders you have something like:

out = projection * view * model * in;

Therefore projection and view don't change, model does, and hence your question.

This is actually an inefficient way of doing it. Instead you should premultiply the 3 matrices on the CPU and upload a single combined MVP matrix to the GPU.

So, in your C or C++ code:

MVP = projection * view * model;
glUniformMatrix4fv (..., MVP, ...);

And in your GLSL:

out = MVP * in;

This solves your initial problem in that you now no longer need to upload global projection or view matrices; since you're uploading a new model matrix per-object anyway you have no change there aside from the fact that it's now a combined MVP rather than an isolated model matrix.

This also solves your performance problem because you're now calculating the combined MVP once per-object only, rather than once per-vertex.

Answer 2

Did i get that right that you have the actual render method specified in the code for each different graphic entity? That is super inefficient, code-wise. Make a renderer-class and put all your shaders and draw-methods into there. Have a main render method that calls all the other render-methods specific to shaders or types of entities. Then you just have to pass your view matrix and projection matrix to that renderer object once and you can use it for each drawable.

In my engine, i store the projection matrix in that renderer class (it never changes though) and pass my camera to the renderer in each call of the render-method.

Answer 3

I'm working in DX11 so idk how this will work for you.

I have one constant buffer that is common over all of my standard shaders, it has view, projection, far clip and camera position.

I update this one constant buffer at the start of the frame and have it set to slot 0 for all my drawing and then just set it once, so its update CB->set CB-> draw everything that uses the same buffer.

I hope I'm close to what u wanted to know?

Answer 4

In my "engine" I have a Scene class which contains all entities and cameras available. I also have a material component which is attached to the entity. At the rendering phase I call the entities material component from the Scene and passing the camera(s) to it.