Am I barking up the right tree?
Or totally lost the plot?
So in the case of a deferred render where there is no post process step and the final image is just a blend of the pixels affected by lights I can just present that to the screen directly and not need to render it to a full screen quad?
There are some missunderstandings. A deferred renderer utilize 80% of the time post-processing and you don't render to a fullscreen quad.
First try to abstract from textures/buffers etc, you have just memory.
A deferred render pipeline works like this:
1. render all the position information (which pixel represents a world position) to a buffer , called g-buffer.
2. now apply lot of post-processing steps, which take as input the g-buffer, calculate some effects (lighting, ssao, shadow) and write it back to some other memory block/buffer
3. finish it with a final pass, where you take all necessary input buffers (light, shadow, ssao, etc.) and compose a final image, write it to some memory block/buffer.
4. display this block/buffer
The trick is, that you use the memory blocks sometimes as output and sometimes as input (to make it simple first, you can't use a memory block for reading and writing at the same time!). Now, to translate this to OpenGL and a graphics API, you need to know, that accessing the memory blocks works like this:
1. if you want to read from it, you need handle it as texture.
2. if you want to write to it, you need to handle it as buffer.
3. if you want to sometimes read and sometimes to write to it, you need to handle it as texture and buffer.
4. To read from, you render a screensized quad and take as texture the input buffers. This way you get access to the memory blocks you want to read from. Then you do some crazy calculation in your shader and write the result to the attached memory in form of an attached buffer.
5. The texture and buffers are just an other way to access one and the same memory block.
Hope this helps.