bool
create(WglDrawable *wglDrawable) {
if (!hglrc) {
HDC hDC = wglDrawable->hDC;
hglrc = wglCreateContext(hDC);
if (!hglrc) {
std::cerr << "error: wglCreateContext failed\n";
exit(1);
}
if (shareContext) {
shareContext->create(wglDrawable);
}
if (!createARB(hDC)) {
if (shareContext) {
BOOL bRet;
bRet = wglShareLists(shareContext->hglrc,
hglrc);
if (!bRet) {
std::cerr
<< "warning: wglShareLists failed: "
<< std::hex << GetLastError() << std::dec
<< "\n";
}
}
}
}
return true;
}
COffscreenGLContext::COffscreenGLContext()
{
//! this creates a 2nd OpenGL context on the >onscreen< window/HDC
//! so don't render to the the default framebuffer (always bind FBOs,DLs,...) !!!
//! get the main (onscreen) GL context
HGLRC mainRC = wglGetCurrentContext();
hdc = wglGetCurrentDC();
if (!hdc || !mainRC) {
throw opengl_error("Couldn't create an offscreen GL context: wglGetCurrentDC failed!");
}
//! create a 2nd GL context
offscreenRC = wglCreateContext(hdc);
if (!offscreenRC) {
throw opengl_error("Couldn't create an offscreen GL context: wglCreateContext failed!");
}
//! share the GL resources (textures,DLists,shaders,...)
if(!wglMakeCurrent(NULL, NULL))
throw opengl_error("Could not deactivate rendering context");
int status = wglShareLists(mainRC, offscreenRC);
if(!wglMakeCurrent(hdc, mainRC))
throw opengl_error("Could not activate rendering context");
if (!status) {
DWORD err = GetLastError();
char msg[256];
SNPRINTF(msg, 255, "Couldn't create an offscreen GL context: wglShareLists failed (error: %i)!", (int)err);
throw opengl_error(msg);
}
}
Context::Context(Context *shared)
: ContextSysBase()
{
assert( Context::current() == shared );
mTarget = nullptr;
mGLFormat = shared->mGLFormat;
GPU::RenderTargetWin* previousSharedTarget = shared->mTarget;
init();
if ( shared->mGLFormat.versionMajor >= 3 )
{
initNewContext(shared->mHGLRC);
}
else
{
initOldContext();
wglShareLists(shared->mHGLRC, mHGLRC);
}
shared->doneCurrent();
makeCurrent();
{
GLenum wglewInitResult = wglewInit();
GLenum glewInitResult = glewInit();
assert(GLEW_OK == wglewInitResult && GLEW_OK == glewInitResult);
}
doneCurrent();
shared->makeCurrent(previousSharedTarget);
}
SDL_Thread* SDL_GL_CreateThread(int (*fn)(void *), void *data) {
SDL_SysWMinfo info;
SDL_VERSION(&info.version);
if (SDL_GetWMInfo(&info) == -1) {
// Could not get SDL version info.
return NULL;
}
gl_thread_device = GetDC(info.window);
gl_thread_context = wglCreateContext(gl_thread_device);
if (gl_thread_context == NULL) {
// Could not create new OpenGL context
return NULL;
}
BOOL err = wglShareLists(info.hglrc, gl_thread_context);
if (err == 0) {
int code = GetLastError();
//Could not get OpenGL share lists: %i
return NULL;
}
gl_thread_func = fn;
gl_thread_data = data;
return SDL_CreateThread(gl_thread_create, NULL);
}
bool
makeCurrent(Drawable *drawable, Context *context)
{
if (!drawable || !context) {
return wglMakeCurrent(NULL, NULL);
} else {
WglDrawable *wglDrawable = static_cast<WglDrawable *>(drawable);
WglContext *wglContext = static_cast<WglContext *>(context);
if (!wglContext->hglrc) {
wglContext->hglrc = wglCreateContext(wglDrawable->hDC);
if (!wglContext->hglrc) {
std::cerr << "error: wglCreateContext failed\n";
exit(1);
return false;
}
if (wglContext->shareContext) {
BOOL bRet;
bRet = wglShareLists(wglContext->shareContext->hglrc,
wglContext->hglrc);
if (!bRet) {
std::cerr << "warning: wglShareLists failed\n";
}
}
}
return wglMakeCurrent(wglDrawable->hDC, wglContext->hglrc);
}
}
WindowedGLContext (Component* const component_,
HGLRC contextToShareWith,
const OpenGLPixelFormat& pixelFormat)
: renderContext (0),
component (component_),
dc (0)
{
initialiseGLExtensions();
jassert (component != nullptr);
createNativeWindow();
PIXELFORMATDESCRIPTOR pfd;
initialisePixelFormatDescriptor (pfd, pixelFormat);
const int format = ChoosePixelFormat (dc, &pfd);
if (format != 0)
SetPixelFormat (dc, format, &pfd);
renderContext = wglCreateContext (dc);
if (renderContext != 0)
{
makeActive();
initialiseGLExtensions();
extensions.initialise();
setPixelFormat (pixelFormat);
if (contextToShareWith != 0)
wglShareLists (contextToShareWith, renderContext);
}
}
int SDL_WM_CreateTempContext() {
SDL_SysWMinfo info;
SDL_VERSION(&info.version);
if (SDL_GetWMInfo(&info) == -1) {
// Could not get SDL version info.
return 1;
}
temp_device = GetDC(info.window);
temp_context = wglCreateContext(temp_device);
if (temp_context == NULL) {
// Could not create OpenGL context
return 2;
}
if (!wglShareLists(info.hglrc, temp_context)) {
// Could not share lists with temp context.
return 3;
}
return 0;
}
static void create_opengl_context (struct claw_window *window) {
window->device_context = GetDC (window->hwnd);
PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR),
1,
PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_GENERIC_ACCELERATED|PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA,
32,
0, 0, 0, 0, 0, 0, 0, 0,
0, // accumulation buffer
0, 0, 0, 0,
0, // depth buffer
0, // stencil buffer
0, // aux buffers
0, 0, 0, 0, 0
};
int pixel_format = ChoosePixelFormat (window->device_context, &pfd);
SetPixelFormat (window->device_context, pixel_format, &pfd);
window->opengl_context = wglCreateContext (window->device_context);
if (first_context)
wglShareLists (first_context, window->opengl_context);
else
first_context = window->opengl_context;
wglMakeCurrent (window->device_context, window->opengl_context);
}
static int
assignToVideoContext(HGLRC hRC)
{
// Traverse existing Video Contexts to see if we can share gfx resources with any of them
video_contexts_t::iterator it = video_contexts.begin();
int i = 0;
int iempty = -1;
for ( ; it != video_contexts.end(); it ++, i++)
{
if (!it->empty()) {
// Try to share resource lists with first Context in the group
if (wglShareLists(it->front(), hRC) == TRUE) {
// Succeeded, so add the new Rendering Context to this Video Context
it->push_back(hRC);
// We're done, this is the Video Context we were looking for
return 1 + i;
}
}
else if (iempty < 0) {
iempty = i; // remember this Video Context as available
}
}
// Could not share with any Video Context, so create and add new Video Context (or reuse an empty one)
if (iempty < 0) {
video_context_t vctx;
vctx.push_back(hRC);
video_contexts.push_back(vctx);
return 1 + i; // add 1 to reserve 0 = unassigned
}
else {
video_contexts[iempty].push_back(hRC);
return 1 + iempty;
}
}
void CIrrWindow::createIrrDevice()
{
// create irr device
SIrrlichtCreationParameters param;
param.WindowId = (void*)getHandle();
param.ZBufferBits = 32;
param.DriverType = video::EDT_OPENGL;
m_device = createDeviceEx(param);
m_driver = m_device->getVideoDriver();
m_smgr = m_device->getSceneManager();
// init opengl
HDC HDc = GetDC( getHandle() );
PIXELFORMATDESCRIPTOR pfd={0};
pfd.nSize=sizeof(PIXELFORMATDESCRIPTOR);
int pf = GetPixelFormat(HDc);
DescribePixelFormat(HDc, pf, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
pfd.dwFlags |= PFD_DOUBLEBUFFER | PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW;
pfd.cDepthBits=16;
pf = ChoosePixelFormat(HDc, &pfd);
SetPixelFormat(HDc, pf, &pfd);
// share video data
m_videoData.OpenGLWin32.HWnd = NULL;
m_videoData.OpenGLWin32.HDc = HDc;
m_videoData.OpenGLWin32.HRc = wglCreateContext(HDc);
// share for multithread
wglShareLists((HGLRC)m_driver->getExposedVideoData().OpenGLWin32.HRc, (HGLRC)m_videoData.OpenGLWin32.HRc);
g_irrView = this;
initScene();
}
HGLRC CL_GL1CreationHelper::create_opengl2_context(HGLRC share_context)
{
HGLRC opengl2_context = wglCreateContext(hdc);
if (opengl2_context)
wglShareLists(share_context, opengl2_context);
return opengl2_context;
}
void WGLRenderer::init(Device *device, Renderer *other) {
WGLDevice *wglDevice = static_cast<WGLDevice *>(device);
if (m_session == NULL) {
Log(EDebug, "Using an existing WGL context");
m_context = wglGetCurrentContext();
if (m_context == NULL)
Log(EError, "Unable to retrieve the current WGL context!");
m_borrowed = true;
} else {
/* Create a GL context */
Log(EDebug, "Initializing WGL renderer");
m_context = wglCreateContext(wglDevice->getDeviceContext());
if (other != NULL) {
Assert(other->getClass() == m_theClass);
if (wglShareLists(m_context,
static_cast<WGLRenderer *>(other)->m_context) != TRUE)
Log(EError, "Unable to set up context sharing: %s",
lastErrorText().c_str());
}
device->makeCurrent(this);
m_borrowed = false;
}
GLRenderer::init(device);
m_initialized = true;
}
GLContext* Win32Context::clone() const
{
// Create new context based on own HDC
HGLRC newCtx = wglCreateContext(mHDC);
if (!newCtx)
{
OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
"Error calling wglCreateContext", "Win32Context::clone");
}
HGLRC oldrc = wglGetCurrentContext();
HDC oldhdc = wglGetCurrentDC();
wglMakeCurrent(NULL, NULL);
// Share lists with old context
if (!wglShareLists(mGlrc, newCtx))
{
String errorMsg = translateWGLError();
wglDeleteContext(newCtx);
OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, String("wglShareLists() failed: ") + errorMsg, "Win32Context::clone");
}
// restore old context
wglMakeCurrent(oldhdc, oldrc);
return new Win32Context(mHDC, newCtx);
}
/// Create a GL rendering context
///
/// @return NULL if failed
glContext::renderingContext *
glContext::createRenderingContext()
{
glContext::renderingContext *rc;
rc = new renderingContext();
rc->_hDC = GetDC(window::getInstance().hWnd());
rc->_hGLRC = wglCreateContext(rc->_hDC);
// HGLRC mainhGLRC = _mainRC ? _mainRC->_hGLRC : 0; //todo for ARB_CREATE_CONTEXT
//rc->_hGLRC = wglCreateContextAttribsARB(rc->_hDC, mainhGLRC, contextAttribs); //TODO for ARB_CREAE_CONTEXT, contextAttribs = NULL if no debug required
if (_mainRC) //main context already created, share withi these contexts
wglShareLists(_mainRC->_hGLRC,rc->_hGLRC);
if(rc->_hGLRC == 0)
{
window::getInstance().messageBoxWithLastError("wglCreateContext");
return false;
}
//TODO debug - makecurrent(rc) to set the debug callbak here
// makeCurrent(rc);
//GLExtensionFunctions::getInstance().resolve();
// if(_options._verbose && GLExtensionFunctions::getInstance()._has_GL_ARB_debug_output) {
// glDebugMessageCallbackARB(debugMessageCallback, NULL);
//}
// makeUnCurrent();
return rc;
}
GLXContext
glXCreateContext(Display * display, XVisualInfo * visinfo,
GLXContext share, Bool direct)
{
/* KLUDGE: GLX really expects a display pointer to be passed
in as the first parameter, but Win32 needs an HDC instead,
so BE SURE that the global XHDC is set before calling this
routine. */
HGLRC context;
context = wglCreateContext(XHDC);
#if 0
/* XXX GLUT doesn't support it now, so don't worry about display list
and texture object sharing. */
if (share) {
wglShareLists(share, context);
}
#endif
/* Since direct rendering is implicit, the direct flag is
ignored. */
return context;
}
/*< private >*/
GdkGLContextImpl *
_gdk_win32_gl_context_impl_new (GdkGLContext *glcontext,
GdkGLDrawable *gldrawable,
GdkGLContext *share_list,
gboolean direct,
int render_type)
{
GdkGLConfig *glconfig;
HDC hdc;
HGLRC hglrc;
GdkGLContextImplWin32 *share_impl = NULL;
GDK_GL_NOTE_FUNC_PRIVATE ();
/*
* Create an OpenGL rendering context.
*/
glconfig = gdk_gl_drawable_get_gl_config (gldrawable);
/* Get DC. */
hdc = gdk_win32_gl_window_get_hdc (GDK_GL_WINDOW (gldrawable));
if (hdc == NULL)
return NULL;
GDK_GL_NOTE_FUNC_IMPL ("wglCreateContext");
hglrc = wglCreateContext (hdc);
/* Release DC. */
gdk_win32_gl_window_release_hdc (GDK_GL_WINDOW (gldrawable));
if (hglrc == NULL)
return NULL;
if (share_list != NULL && GDK_IS_GL_CONTEXT (share_list))
{
GDK_GL_NOTE_FUNC_IMPL ("wglShareLists");
share_impl = GDK_GL_CONTEXT_IMPL_WIN32 (share_list);
if (!wglShareLists (share_impl->hglrc, hglrc))
{
wglDeleteContext (hglrc);
return NULL;
}
}
/*
* Instantiate the GdkGLContextImplWin32 object.
*/
return gdk_win32_gl_context_impl_new_common (glcontext,
glconfig,
share_list,
render_type,
hglrc,
FALSE);
}
JNIEXPORT jboolean JNICALL WGL_NATIVE(wglShareLists)
(JNIEnv *env, jclass that, jintLong arg0, jintLong arg1)
{
jboolean rc = 0;
WGL_NATIVE_ENTER(env, that, wglShareLists_FUNC);
rc = (jboolean)wglShareLists((HGLRC)arg0, (HGLRC)arg1);
WGL_NATIVE_EXIT(env, that, wglShareLists_FUNC);
return rc;
}
bool OglContext::createPBuffer(ms_uint32 width, ms_uint32 height)
{
HPBUFFERARB hPBuffer = NULL;
hPBufferDC = NULL;
hPBufferRC = NULL;
int pixelFormat;
int valid = false;
UINT numFormats = 0;
float fAttributes[] = {0,0};
int samples = MAX_MULTISAMPLE_SAMPLES;
while ((!valid || numFormats == 0) && samples >= 0) {
int iAttributes[] = {
WGL_SAMPLES_ARB,samples,
WGL_DRAW_TO_PBUFFER_ARB,GL_TRUE,
WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
WGL_COLOR_BITS_ARB,24,
WGL_ALPHA_BITS_ARB,8,
WGL_DEPTH_BITS_ARB,16,
WGL_STENCIL_BITS_ARB,0,
WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB,
0,0
};
valid = wglChoosePixelFormatARB(window,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
if (!valid || numFormats == 0) samples -= 2;
}
if(numFormats == 0) {
msSetError(MS_OGLERR, "P-buffer Error: Unable to find an acceptable pixel format.", "OglContext::createPBuffer()");
return FALSE;
}
if (!(hPBuffer = wglCreatePbufferARB(window, pixelFormat, width, height, 0))) {
msSetError(MS_OGLERR, "P-buffer Error: Unable to create P-buffer. glError: %d", "OglContext::createPBuffer()", glGetError());
return FALSE;
}
if (!(hPBufferDC = wglGetPbufferDCARB(hPBuffer))) {
msSetError(MS_OGLERR, "P-buffer Error: Unable to get P-buffer DC. glError: %d", "OglContext::createPBuffer()", glGetError());
return FALSE;
}
if (!(hPBufferRC = wglCreateContext(hPBufferDC))) {
msSetError(MS_OGLERR, "P-buffer Error: Unable to get P-buffer DC. glError: %d", "OglContext::createPBuffer()", glGetError());
return FALSE;
}
if (wglShareLists(sharingContext,hPBufferRC) == FALSE) {
msSetError(MS_OGLERR, "P-buffer Error: Unable to share display lists. glError: %d", "OglContext::createPBuffer()", glGetError());
return FALSE;
}
return TRUE;
}
static gboolean
gst_gl_context_wgl_create_context (GstGLContext * context,
GstGLAPI gl_api, GstGLContext * other_context, GError ** error)
{
GstGLWindow *window;
GstGLContextWGL *context_wgl;
GstGLContextWGL *other_wgl = NULL;
HDC device;
context_wgl = GST_GL_CONTEXT_WGL (context);
window = gst_gl_context_get_window (context);
device = (HDC) gst_gl_window_get_display (window);
if (other_context) {
if (!GST_GL_IS_CONTEXT_WGL (other_context)) {
g_set_error (error, GST_GL_CONTEXT_ERROR,
GST_GL_CONTEXT_ERROR_WRONG_CONFIG,
"Cannot share context with a non-WGL context");
goto failure;
}
other_wgl = (GstGLContextWGL *) other_context;
}
context_wgl->wgl_context = wglCreateContext (device);
if (context_wgl->wgl_context)
GST_DEBUG ("gl context created: %" G_GUINTPTR_FORMAT,
(guintptr) context_wgl->wgl_context);
else {
g_set_error (error, GST_GL_CONTEXT_ERROR,
GST_GL_CONTEXT_ERROR_CREATE_CONTEXT, "failed to create glcontext:0x%x",
(unsigned int) GetLastError ());
goto failure;
}
g_assert (context_wgl->wgl_context);
GST_LOG ("gl context id: %" G_GUINTPTR_FORMAT,
(guintptr) context_wgl->wgl_context);
if (other_wgl) {
if (!wglShareLists (other_wgl->wgl_context, context_wgl->wgl_context)) {
g_set_error (error, GST_GL_CONTEXT_ERROR,
GST_GL_CONTEXT_ERROR_CREATE_CONTEXT, "failed to share contexts 0x%x",
(unsigned int) GetLastError ());
goto failure;
}
}
gst_object_unref (window);
return TRUE;
failure:
gst_object_unref (window);
return FALSE;
}
void PBuffer_GL1_Impl::create(OpenGLWindowProvider &window_provider, const Size &size)
{
reset();
OpenGL::set_active(gc_provider);
if (glWglCreatePbufferARB == 0)
{
throw Exception("WGL_ARB_pbuffer OpenGL extension not supported by this card");
}
int attribList[1] = { 0 };
PIXELFORMATDESCRIPTOR pfd =
{
sizeof(PIXELFORMATDESCRIPTOR), // size of this pfd
1, // version number
// PFD_DRAW_TO_WINDOW | // support window
PFD_SUPPORT_OPENGL //| // support OpenGL
//PFD_DOUBLEBUFFER | // double buffered
//PFD_DEPTH_DONTCARE
, // do you care about a zbuffer?
PFD_TYPE_RGBA, // RGBA type
24, // 24-bit color depth
0, 0, 0, 0, 0, 0, // color bits ignored
8, // alpha buffer
0, // shift bit ignored
0, // no accumulation buffer
0, 0, 0, 0, // accum bits ignored
0, // z-buffer
0, // no stencil buffer
0, // no auxiliary buffer
PFD_MAIN_PLANE, // main layer
0, // reserved
0, 0, 0 // layer masks ignored
};
int pixelformat = ChoosePixelFormat(wglGetCurrentDC(), &pfd);
pbuffer = glWglCreatePbufferARB(
wglGetCurrentDC(),
pixelformat,
size.width,
size.height,
attribList);
pbuffer_dc = glWglGetPbufferDCARB(pbuffer);
pbuffer_context = wglCreateContext(pbuffer_dc);
HGLRC share_context = window_provider.get_share_context();
if (share_context == 0)
throw Exception("Shared OpenGL Context is not valid");
wglShareLists(share_context, pbuffer_context);
pbuffer_size = size;
}
void *
MSWinSurface::createExtraContext()
{
assert(hGLRC != 0);
HDC hDC = GetDC(hWnd);
HGLRC hRC = wglCreateContext(hDC);
if (hRC == 0) throw EMSWinError(GetLastError(), "wglCreateContext() (extra context)");
if (! wglShareLists(hGLRC, hRC)) throw EMSWinError(GetLastError(), "wglShareLists() (extra context)");
return hRC;
}
// Spout OpenGL initialization function
bool SpoutSenderPlugin::InitOpenGL()
{
char windowtitle[512];
// We only need an OpenGL context with no window
m_hwnd = GetForegroundWindow(); // Any window will do - we don't render to it
if(!m_hwnd) { printf("InitOpenGL error 1\n"); MessageBoxA(NULL, "Error 1\n", "InitOpenGL", MB_OK); return false; }
m_hdc = GetDC(m_hwnd);
if(!m_hdc) { printf("InitOpenGL error 2\n"); MessageBoxA(NULL, "Error 2\n", "InitOpenGL", MB_OK); return false; }
GetWindowTextA(m_hwnd, windowtitle, 256); // debug
PIXELFORMATDESCRIPTOR pfd;
ZeroMemory( &pfd, sizeof( pfd ) );
pfd.nSize = sizeof( pfd );
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 32;
pfd.cDepthBits = 24; // LJ DEBUG - was 16;
pfd.cStencilBits = 8; // LJ DEBUG -added
pfd.iLayerType = PFD_MAIN_PLANE;
int iFormat = ChoosePixelFormat(m_hdc, &pfd);
if(!iFormat) { printf("InitOpenGL error 3\n"); MessageBoxA(NULL, "Error 3\n", "InitOpenGL", MB_OK); return false; }
if(!SetPixelFormat(m_hdc, iFormat, &pfd)) { printf("InitOpenGL error 4\n"); MessageBoxA(NULL, "Error 4\n", "InitOpenGL", MB_OK); return false; }
m_hRC = wglCreateContext(m_hdc);
if(!m_hRC) { printf("InitOpenGL error 5\n"); MessageBoxA(NULL, "Error 5\n", "InitOpenGL", MB_OK); return false; }
wglMakeCurrent(m_hdc, m_hRC);
if(wglGetCurrentContext() == NULL) { printf("InitOpenGL error 6\n"); MessageBoxA(NULL, "Error 6\n", "InitOpenGL", MB_OK); return false; }
// Set up a shared context
if(!m_hSharedRC) m_hSharedRC = wglCreateContext(m_hdc);
if(!m_hSharedRC) { printf("InitOpenGL shared context not created\n"); }
if(!wglShareLists(m_hSharedRC, m_hRC)) { printf("wglShareLists failed\n"); }
// Drop through to return true
/*
SendMessageTimeoutA(m_hwnd, WM_GETTEXT, 256, (LPARAM)windowtitle, SMTO_ABORTIFHUNG, 128, NULL);
printf("InitOpenGL : hwnd = %x (%s), hdc = %x, context = %x\n", m_hwnd, windowtitle, m_hdc, m_hRC);
int nTotalAvailMemoryInKB = 0;
int nCurAvailMemoryInKB = 0;
// GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX 0x9048
// GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX 0x9049
glGetIntegerv(0x9048, &nTotalAvailMemoryInKB);
glGetIntegerv(0x9049, &nCurAvailMemoryInKB);
printf("Memory : Total [%i], Available [%i]\n", nTotalAvailMemoryInKB, nCurAvailMemoryInKB);
*/
return true;
}
wxGLContext::wxGLContext(wxGLCanvas *win, const wxGLContext* other)
{
m_glContext = wglCreateContext(win->GetHDC());
wxCHECK_RET( m_glContext, wxT("Couldn't create OpenGL context") );
if ( other )
{
if ( !wglShareLists(other->m_glContext, m_glContext) )
wxLogLastError(_T("wglShareLists"));
}
}
int Server::initGLContexts()
{
diplayWindow = wglGetCurrentDC();
primaryContext = wglGetCurrentContext();
loadingThreadContext = wglCreateContext(diplayWindow);
wglMakeCurrent(NULL, NULL);
BOOL error = wglShareLists(primaryContext, loadingThreadContext);
wglMakeCurrent(diplayWindow, primaryContext);
return 0;
}
static inline HGLRC createContext(HDC hdc, HGLRC shared)
{
HGLRC result = wglCreateContext(hdc);
if (!result) {
qErrnoWarning("%s: wglCreateContext failed.", __FUNCTION__);
return 0;
}
if (shared && !wglShareLists(shared, result))
qErrnoWarning("%s: wglShareLists() failed.", __FUNCTION__);
return result;
}
BBGLContext *bbGLGraphicsAttachGraphics( HWND hwnd,int flags ){
BBGLContext *context;
HDC hdc;
HGLRC hglrc;
long pf;
PIXELFORMATDESCRIPTOR pfd;
RECT rect;
_initWndClass();
hdc=GetDC( hwnd );
if( !hdc ) return 0;
_initPfd( &pfd,flags );
int multisample = 0;
if (_MULTISAMPLE2X & flags) multisample = 2;
else if (_MULTISAMPLE4X & flags) multisample = 4;
else if (_MULTISAMPLE8X & flags) multisample = 8;
else if (_MULTISAMPLE16X & flags) multisample = 16;
if (multisample>0){
pf=MyChoosePixelFormat( hdc,flags );
}else{
pf=ChoosePixelFormat( hdc,&pfd );
}
if( !pf ) return 0;
SetPixelFormat( hdc,pf,&pfd );
hglrc=wglCreateContext( hdc );
if( _sharedContext ) wglShareLists( _sharedContext->hglrc,hglrc );
GetClientRect( hwnd,&rect );
context=(BBGLContext*)malloc( sizeof(BBGLContext) );
memset( context,0,sizeof(*context) );
context->mode=MODE_WIDGET;
context->width=rect.right;
context->height=rect.bottom;
context->flags=flags;
context->hdc=hdc;
context->hwnd=hwnd;
context->hglrc=hglrc;
context->succ=_contexts;
_contexts=context;
return context;
}
void ParticleShaderVoronoi::setupBuffers(int width, int height)
{
hdc = wglGetCurrentDC();
hglrc = wglGetCurrentContext();
pbufferOne = new nv_pbuffer(width, height, 1);
pbufferOne->wglGetLastError();
// If we're sharing contexts, don't need to share lists
if (pbufferOne->onecontext == false)
wglShareLists(pbufferOne->hglrc, hglrc);
}
KT_API WinOGL3Context::WinOGL3Context( Window* window,
WinOGL3Context* sharedWith,
unsigned redBits,
unsigned greenBits,
unsigned blueBits,
unsigned alphaBits,
unsigned depth,
unsigned stencil )
{
myWindow = window ? window : new Window();
myDC = GetDC( myWindow->GetWindowHandle() );
if( !myDC )
kTLaunchException( Exception, "Can't retrieve the DC to create a OGL context" );
PIXELFORMATDESCRIPTOR pfd = {0};
pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.nVersion = 1;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.iLayerType = PFD_MAIN_PLANE;
pfd.cColorBits = redBits + greenBits + blueBits + alphaBits;
pfd.cRedBits = redBits;
pfd.cGreenBits = greenBits;
pfd.cBlueBits = blueBits;
pfd.cAlphaBits = alphaBits;
pfd.cDepthBits = depth;
pfd.cStencilBits = stencil;
int pixelFormat = ChoosePixelFormat( myDC, &pfd );
if( !pixelFormat )
kTLaunchException( Exception, "Can't find a matching pixel format" );
if( SetPixelFormat( myDC, pixelFormat, &pfd ) == FALSE )
kTLaunchException( Exception, "Can't set the pixel format" );
myOGLContext = wglCreateContext( myDC );
if( !myOGLContext )
kTLaunchException( Exception, "Can't create the context" );
if( sharedWith )
{
if( wglShareLists( sharedWith->GetHandle(), myOGLContext ) == FALSE )
kTLaunchException( Exception, "Can't share the context" );
}
}
//----------------------------------------------------------------------------//
void OpenGLWGLPBTextureTarget::initialisePBuffer()
{
int creation_attrs[] =
{
WGL_PBUFFER_LARGEST_ARB, true,
0
};
releasePBuffer();
HDC hdc = wglGetCurrentDC();
d_pbuffer = wglCreatePbufferARB(hdc, d_pixfmt,
static_cast<int>(d_area.getWidth()),
static_cast<int>(d_area.getHeight()),
creation_attrs);
if (!d_pbuffer)
CEGUI_THROW(RendererException(
"OpenGLWGLPBTextureTarget::initialisePBuffer - "
"pbuffer creation failure, wglCreatePbufferARB() call failed."));
d_hdc = wglGetPbufferDCARB(d_pbuffer);
if (!d_hdc)
CEGUI_THROW(RendererException(
"OpenGLWGLPBTextureTarget::initialisePBuffer - "
"pbuffer creation failure, wglGetPbufferDCARB() call failed."));
d_context= wglCreateContext(d_hdc);
if (!d_hdc)
CEGUI_THROW(RendererException(
"OpenGLWGLPBTextureTarget::initialisePBuffer - "
"pbuffer creation failure, wglCreateContext() call failed."));
if(!wglShareLists(wglGetCurrentContext(), d_context))
CEGUI_THROW(RendererException(
"OpenGLWGLPBTextureTarget::initialisePBuffer - "
"pbuffer creation failure, wglShareLists() call failed."));
// extract the actual size of the created bufer
int actual_width, actual_height;
wglQueryPbufferARB(d_pbuffer, WGL_PBUFFER_WIDTH_ARB, &actual_width);
wglQueryPbufferARB(d_pbuffer, WGL_PBUFFER_HEIGHT_ARB, &actual_height);
d_area.setSize(Size(static_cast<float>(actual_width),
static_cast<float>(actual_height)));
// ensure CEGUI::Texture is wrapping real GL texture and has correct size
d_CEGUITexture->setOpenGLTexture(d_texture, d_area.getSize());
}
GHOST_TSuccess GHOST_WindowWin32::installDrawingContext(GHOST_TDrawingContextType type)
{
GHOST_TSuccess success;
switch (type) {
case GHOST_kDrawingContextTypeOpenGL:
{
if(m_stereoVisual)
sPreferredFormat.dwFlags |= PFD_STEREO;
// Attempt to match device context pixel format to the preferred format
int iPixelFormat = EnumPixelFormats(m_hDC);
if (iPixelFormat == 0) {
success = GHOST_kFailure;
break;
}
if (::SetPixelFormat(m_hDC, iPixelFormat, &sPreferredFormat) == FALSE) {
success = GHOST_kFailure;
break;
}
// For debugging only: retrieve the pixel format chosen
PIXELFORMATDESCRIPTOR preferredFormat;
::DescribePixelFormat(m_hDC, iPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &preferredFormat);
// Create the context
m_hGlRc = ::wglCreateContext(m_hDC);
if (m_hGlRc) {
if (s_firsthGLRc) {
wglShareLists(s_firsthGLRc, m_hGlRc);
} else {
s_firsthGLRc = m_hGlRc;
}
success = ::wglMakeCurrent(m_hDC, m_hGlRc) == TRUE ? GHOST_kSuccess : GHOST_kFailure;
}
else {
success = GHOST_kFailure;
}
}
break;
case GHOST_kDrawingContextTypeNone:
success = GHOST_kSuccess;
break;
default:
success = GHOST_kFailure;
}
return success;
}