Jump to content
  • Advertisement
Sign in to follow this  
jbb

OpenGL Managing opengl contexts for more than one window

This topic is 701 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

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?

Share this post


Link to post
Share on other sites
Advertisement
You can build GLEW in a way that it can deal with different function pointers, but that requires an additional context parameter in each OpenGL function call.

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?

Share this post


Link to post
Share on other sites

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?

Share this post


Link to post
Share on other sites
That's not an area I have much experience in, but if you do not create a texture to render on but a renderbuffer (which you can render to in an FBO but not use as a texture) you can blit extremely fast between renderbuffers (including the implicit renderbuffer of your window). Thta's pretty much what OpenGL already has to do anyway, but hidden from you. A monitor cannot display multiple samples per pixel. They must be collapsed into a single sample before display anyway.

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.

Share this post


Link to post
Share on other sites

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...

Share this post


Link to post
Share on other sites

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.

Share this post


Link to post
Share on other sites

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. :)

Share this post


Link to post
Share on other sites

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 :)

Share this post


Link to post
Share on other sites
Games don’t do this. Switching contexts is extremely slow, plus the overhead of whatever you are doing to check for the current context.
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

Share this post


Link to post
Share on other sites

the drivers usually have very serious issues managing opengl contexts. i suggest not to do it.

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

We are the game development community.

Whether you are an indie, hobbyist, AAA developer, or just trying to learn, GameDev.net is the place for you to learn, share, and connect with the games industry. Learn more About Us or sign up!

Sign me up!