How do people manage multiple opengl contexts, if in fact they do?
My code has a 'Window' class, so, in theory at least, you can create two or more windows. Each window can have it's own pixel format and opengl context due to the way it works. Now the problem is that before making *every* call to opengl I have to check that the current gl context is the correct one, and if not do wglMakeCurrent to switch to it. Or else I have to make a function on 'Window' called something like 'makeActive' before I do any opengl operations on it. And be sure to always remember to do this.
My question is how do people cope with this? Is doing this very slow? Or do people generally not support more than one context in a program?
Secondly, it seems that on windows at least, you have to call opengl functions via function pointers obtained from wglGetProcAddress and those pointers can be *different* for each context if they have different pixel formats. I am using multisampled output window in my main window and intend in a debug mode to have a separate window that doesn't need to have that so I *will* be having different pixel formats. So I can't just slap them into a lot of global variables.
How do people cope with this?
Or do people in general decide that supporting multiple windows is more effort than it's worth and find alternative solutions?
Managing opengl contexts for more than one window
For games though I would try to do whatever I can to avoid having to deal with this issue. Why exactly do you need to do that anyway? Wouldn't it be far easier to have no multisampling in the pixel format and just use FBOs with/without multisampling?
If I want to use multsampling on the output, don't I have to create a multisampled pixel format?
Or are you saying I can create a multisampled render-to-texture and render to that, and then somehow copy that to the display?
Won't that be slow?
I would have a look at the OpenGL wiki regarding multisampling, I remember reading it a while back and it cleared up a lot of misconceptions.
As far as I know, no one really does multisampling outside of FBOs anymore.
Thanks, i looked into it now :)
That makes a lot of sense and makes things very much easier as I can basically pick a single pixel format and use that for all my windows and hard code it and forget about all this.
Hmm, does that mean I need a depth buffer on my render buffer and don't need to create my window with one...
Hmm, does that mean I need a depth buffer on my render buffer and don't need to create my window with one...
You would need an additional renderbuffer (or a qualified texture) acting as depth buffer, yes, unless there is some kind of mixed color/depth format around (to my knowledge, there is no such thing). If you will only render to your FBOs, you do not need a depth buffer with your window's framebuffer.
My question is how do people cope with this? Is doing this very slow? Or do people generally not support more than one context in a program?
People generally avoid it, and yes it is slow (depending on platform).
The magic global context which is both a device and a swap-chain is one of the over-arching worst design mistakes of OpenGL (which is really saying something) and one of the reasons that Vulkan is an entirely new API rather than a set of GL extensions. GL's design also complicates multi-threading renderers.
If you have a particular need for fancier application, I have to suggest that you use DirectX (9 or 11, your pick)instead. The API is just far better designed and handles such intricate tasks as multiple windows without surprise or problem. :)
Thanks everyone.
I don't actually need this at all. As they say, I'm trying to make a game, not a general purpose engine, but it's always nice to separate components where possible and effective, so it seemed right to make a Window class which naturally lead to thinking what if the user makes more than one.
Well my game isn't going to, and it looks tricky, so I'll probably come up with an alternative interface that assumes only one "window", precluding the question even arising.
Still a useful discussion for me anyway, as it's lead to me looking into and understanding renderbuffers and fbo's and why I might use one :)
Not only this, but resources are not shared across contexts, so you would also need to keep track of which textures, vertex buffers, shaders, etc., are available given the current context.
Tools/editors may use multiple contexts, in which case you would use shared contexts. This is extremely easy to set up with Qt and allows you to have 1 window showing the model and other windows displaying the model textures, with different contexts each but able to share the resources (textures in this example) without having to load them once-per-context.
L. Spiro
