I'm new to using matrices, so I'd like some input on whether I've understood the use of them in the context described in the title.
Right now I have a small Direct3D 11-based game engine which renders a stack of scenes, or screens if you will, from bottom to top. I have a static 2D orthographic view-projection matrix that simply maps to screen coordinates from ( 0, 0 ) to ( screen width, screen height ). The position and resulting world matrix of the different entities are set with coordinates relative to this.
However, I'd like to expand on this by enabling different scenes to use different perspectives, so that I would be able to render a 3D scene with perspective, and then a flat 2D GUI on top of it. But since I'm very new to using matrices, I'd like confirmation on whether I have the correct idea of what will happen before I change things, because it takes a fair amount of work to refactor the engine with the way it is set up now.
Let's say I have
Scene A as the 3D scene, and
Scene B as my 2D overlay.
When entities in
Scene A is rendered, the following matrices are passed to the shader:
View= camera position/orientation in the 3D world
Projection= perspective matrix with FoV, aspect ratio and near/far depth
World= the individual entity's position in the 3D world
Then, when I want to render
Scene B, I pass these matrices instead:
View= identity matrix since the view is static
Projection= orthographic matrix with screen coordinates
World= the individual entity's position in the screen coordinate system
In both cases the vertex shader multiplies the matrices like so:
world * view * projection
Is this correct? Will this draw my 3D scene as expected first, and then correctly draw the 2D elements relative to the screen coordinate system instead? Or have I misunderstood how the matrices work?
EDIT: scratch the question below; I found the answer under related questions...: Should the modelview and projection matrices be calculated in the shader or on the CPU?
Original question: And one more thing, would it be more efficient to compute the View-Projection-World matrix on the CPU end before passing it to the shader's constant buffer, or is the GPU better suited at receiving the three matrices and multiplying them on the shader side? I've seen both approaches used, but I haven't found any conclusions on which way is more practical/efficient. I have two constant buffers by the way, one with the View and Projection matrices which is updated once per scene, and one with the World matrix updated for each individual entity, so the memory bandwidth savings would be insignificant if I moved the multiplications to the CPU instead. But would that be faster in theory, and are there any eventual drawbacks to this?