C++ – OpenGL – Share existing textures with future contexts

copenglwindows

I have an application where I draw frames to a texture using the FBO extensions.

These frames are then be displayed to different windows that are opened while the application is running. This means that textures can be created and pooled before the OpenGL context for any new window is created and wglShareLists is called.

Currently I have to do glReadPixels, glMapBufferRange and glTexSubImage to move the texture into the different window contexts, which is rather inefficient.

Any ideas on how to improve on this? Should I create multiple (as much as the maximum number of windows at any time ~4) OpenGL contexts and hidden windows during program startup? What would be the overhead of that?

Or even better, is there a way to make textures shared between existing and future OpenGL contexts?

Best Answer

Sharing Lists between OpenGL contexts will share all data encapsulating buffer objects as well (textures, vertex buffer objects, pixel buffer objects) but not abstract collection objects (framebuffer objects, vertex array objects). It is mandatory to create the sharing, before creating any new named objects in the new context, as creating names before the sharing may result in namespace collisions. Already created objects are shared. But this of course requires precautions, because what would happen if both context A and B had textures with ID=1? If however A had a lot of textures and B none, then the texture names of A can be transferred to B just fine. That's the caveat.

However if you just want to render to multiple windows: It is perfectly possible to use a single OpenGL context on an arbitrary number of windows, as long as their PIXELFORMATDESCRIPTOR is compatible. That's what the HDC parameter of wglMakeCurrent is meant for. If a context was strictly bound to a single window, wglMakeCurrent had only a HRC parameter.

Related Solutions

R – How do OpenGL contexts and device contexts work

In general, it's usually safe to think of a single OpenGL context as a window, especially on windows.

A device context will (typically) map to an Window Handle (HWND). It's actually a DC (HDC is the handle), but normally you associate one HDC with a single HWND. In Windows, you'll create a window to use based off the window on screen where you want to render.

Typically, you'll reuse this device context for the entire runtime of your application. If you want to render into a different window, you'll need to generate a device context (HDC) for the new window handle. Also, offscreen rendering is a bit different, since you'd create a compatible device context for that, as well.

As for your questions:

1) When you create the window where you want to do the rendering, you'll grab a device context, and use it for the lifetime of that window.

2) You'll want to always use the device context created for the window where you are rendering.

Repeating Textures in OpenGL

If I'm understanding you correctly you're not treating the texture coordinates correctly. When using glTexCoord2f() the texture extends from 0.0, 0.0 to 1.0, 1.0. So if you want to have a texture that fills a quad you use the following:

glTexCoord2f(0.0f, 0.0f);    glVertex3f(0.35f, 0.35f, 0.0f);
glTexCoord2f(0.0f, 1.0f);    glVertex3f(0.35f, 0.65f, 0.0f);
glTexCoord2f(1.0f, 1.0f);    glVertex3f(0.65f, 0.65f, 0.0f);
glTexCoord2f(1.0f, 0.0f);    glVertex3f(0.65f, 0.35f, 0.0f);

And if you want to repeat the texture 8 times across the surface of the quad use 8.0f in place of the 1.0fs in the texCoords call. You'll also need to make sure that the texture is set to repeat when it is set once you've bound the texture.

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

That's probably your problem, but if you're still having aliasing issues, try looking into glTexParameteri with GL_TEXTURE_MAG_FILTER and GL_TEXTURE_MAG_FILTER and mip-mapping.

It may be over a decade old, but this old Flipcode tutorial is still relevant and worth a look.

EDIT: Had vertex calls before texcoord calls

Best Answer

Related Solutions

R – How do OpenGL contexts and device contexts work

Repeating Textures in OpenGL

Related Topic