/* static */
bool
wxGLCanvasX11::InitXVisualInfo(const int *attribList,
GLXFBConfig **pFBC,
XVisualInfo **pXVisual)
{
int data[512];
if ( !ConvertWXAttrsToGL(attribList, data, WXSIZEOF(data)) )
return false;
Display * const dpy = wxGetX11Display();
if ( GetGLXVersion() >= 13 )
{
int returned;
*pFBC = glXChooseFBConfig(dpy, DefaultScreen(dpy), data, &returned);
if ( *pFBC )
{
*pXVisual = glXGetVisualFromFBConfig(wxGetX11Display(), **pFBC);
if ( !*pXVisual )
{
XFree(*pFBC);
*pFBC = NULL;
}
}
}
else // GLX <= 1.2
{
*pFBC = NULL;
*pXVisual = glXChooseVisual(dpy, DefaultScreen(dpy), data);
}
return *pXVisual != NULL;
}
bool GLWindow::DisplayWindow(int _width, int _height)
{
GetWindowSize();
if (!CreateVisual()) return false;
// connect the glx-context to the window
CreateContextGL();
glXMakeCurrent(glDisplay, glWindow, context);
GetGLXVersion();
return true;
}
bool GLWindow::DisplayWindow(int _width, int _height)
{
backbuffer.w = _width;
backbuffer.h = _height;
if (!CreateVisual()) return false;
/* create a color map */
attr.colormap = XCreateColormap(glDisplay, RootWindow(glDisplay, vi->screen),
vi->visual, AllocNone);
attr.border_pixel = 0;
attr.event_mask = ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask |
StructureNotifyMask | SubstructureRedirectMask | SubstructureNotifyMask |
EnterWindowMask | LeaveWindowMask | FocusChangeMask ;
// Create a window at the last position/size
glWindow = XCreateWindow(glDisplay, RootWindow(glDisplay, vi->screen),
conf.x , conf.y , _width, _height, 0, vi->depth, InputOutput, vi->visual,
CWBorderPixel | CWColormap | CWEventMask,
&attr);
/* Allow to kill properly the window */
Atom wmDelete = XInternAtom(glDisplay, "WM_DELETE_WINDOW", True);
XSetWMProtocols(glDisplay, glWindow, &wmDelete, 1);
// Set icon name
XSetIconName(glDisplay, glWindow, "ZZogl-pg");
// Draw the window
XMapRaised(glDisplay, glWindow);
XSync(glDisplay, false);
// connect the glx-context to the window
CreateContextGL();
glXMakeCurrent(glDisplay, glWindow, context);
GetGLXVersion();
// Always start in window mode
fullScreen = 0;
GetWindowSize();
return true;
}
bool
wxGLCanvasX11::ConvertWXAttrsToGL(const int *wxattrs, int *glattrs, size_t n)
{
wxCHECK_MSG( n >= 16, false, wxT("GL attributes buffer too small") );
/*
Different versions of GLX API use rather different attributes lists, see
the following URLs:
- <= 1.2: http://www.opengl.org/sdk/docs/man/xhtml/glXChooseVisual.xml
- >= 1.3: http://www.opengl.org/sdk/docs/man/xhtml/glXChooseFBConfig.xml
Notice in particular that
- GLX_RGBA is boolean attribute in the old version of the API but a
value of GLX_RENDER_TYPE in the new one
- Boolean attributes such as GLX_DOUBLEBUFFER don't take values in the
old version but must be followed by True or False in the new one.
*/
if ( !wxattrs )
{
size_t i = 0;
// use double-buffered true colour by default
glattrs[i++] = GLX_DOUBLEBUFFER;
if ( GetGLXVersion() < 13 )
{
// default settings if attriblist = 0
glattrs[i++] = GLX_RGBA;
glattrs[i++] = GLX_DEPTH_SIZE; glattrs[i++] = 1;
glattrs[i++] = GLX_RED_SIZE; glattrs[i++] = 1;
glattrs[i++] = GLX_GREEN_SIZE; glattrs[i++] = 1;
glattrs[i++] = GLX_BLUE_SIZE; glattrs[i++] = 1;
glattrs[i++] = GLX_ALPHA_SIZE; glattrs[i++] = 0;
}
else // recent GLX can choose the defaults on its own just fine
{
// we just need to have a value after GLX_DOUBLEBUFFER
glattrs[i++] = True;
}
glattrs[i] = None;
wxASSERT_MSG( i < n, wxT("GL attributes buffer too small") );
}
else // have non-default attributes
{
size_t p = 0;
for ( int arg = 0; wxattrs[arg] != 0; )
{
// check if we have any space left, knowing that we may insert 2
// more elements during this loop iteration and we always need to
// terminate the list with None (hence -3)
if ( p > n - 3 )
return false;
// indicates whether we have a boolean attribute
bool isBoolAttr = false;
switch ( wxattrs[arg++] )
{
case WX_GL_BUFFER_SIZE:
glattrs[p++] = GLX_BUFFER_SIZE;
break;
case WX_GL_LEVEL:
glattrs[p++] = GLX_LEVEL;
break;
case WX_GL_RGBA:
if ( GetGLXVersion() >= 13 )
{
// this is the default GLX_RENDER_TYPE anyhow
continue;
}
glattrs[p++] = GLX_RGBA;
isBoolAttr = true;
break;
case WX_GL_DOUBLEBUFFER:
glattrs[p++] = GLX_DOUBLEBUFFER;
isBoolAttr = true;
break;
case WX_GL_STEREO:
glattrs[p++] = GLX_STEREO;
isBoolAttr = true;
break;
case WX_GL_AUX_BUFFERS:
glattrs[p++] = GLX_AUX_BUFFERS;
break;
case WX_GL_MIN_RED:
glattrs[p++] = GLX_RED_SIZE;
break;
case WX_GL_MIN_GREEN:
glattrs[p++] = GLX_GREEN_SIZE;
break;
case WX_GL_MIN_BLUE:
glattrs[p++] = GLX_BLUE_SIZE;
break;
case WX_GL_MIN_ALPHA:
glattrs[p++] = GLX_ALPHA_SIZE;
break;
case WX_GL_DEPTH_SIZE:
glattrs[p++] = GLX_DEPTH_SIZE;
break;
case WX_GL_STENCIL_SIZE:
glattrs[p++] = GLX_STENCIL_SIZE;
break;
case WX_GL_MIN_ACCUM_RED:
glattrs[p++] = GLX_ACCUM_RED_SIZE;
break;
case WX_GL_MIN_ACCUM_GREEN:
glattrs[p++] = GLX_ACCUM_GREEN_SIZE;
break;
case WX_GL_MIN_ACCUM_BLUE:
glattrs[p++] = GLX_ACCUM_BLUE_SIZE;
break;
case WX_GL_MIN_ACCUM_ALPHA:
glattrs[p++] = GLX_ACCUM_ALPHA_SIZE;
break;
case WX_GL_SAMPLE_BUFFERS:
#ifdef GLX_SAMPLE_BUFFERS_ARB
if ( IsGLXMultiSampleAvailable() )
{
glattrs[p++] = GLX_SAMPLE_BUFFERS_ARB;
break;
}
#endif // GLX_SAMPLE_BUFFERS_ARB
// if it was specified just to disable it, no problem
if ( !wxattrs[arg++] )
continue;
// otherwise indicate that it's not supported
return false;
case WX_GL_SAMPLES:
#ifdef GLX_SAMPLES_ARB
if ( IsGLXMultiSampleAvailable() )
{
glattrs[p++] = GLX_SAMPLES_ARB;
break;
}
#endif // GLX_SAMPLES_ARB
if ( !wxattrs[arg++] )
continue;
return false;
default:
wxLogDebug(wxT("Unsupported OpenGL attribute %d"),
wxattrs[arg - 1]);
continue;
}
if ( isBoolAttr )
{
// as explained above, for pre 1.3 API the attribute just needs
// to be present so we only add its value when using the new API
if ( GetGLXVersion() >= 13 )
glattrs[p++] = True;
}
else // attribute with real (non-boolean) value
{
// copy attribute value as is
glattrs[p++] = wxattrs[arg++];
}
}
glattrs[p] = None;
}
return true;
}
void tui::LayoutCanvas::showInfo()
{
std::ostringstream ost1, ost2, ost3;
const GLubyte *vendor = glGetString(GL_VENDOR);
const GLubyte *renderer = glGetString(GL_RENDERER);
const GLubyte *version = glGetString(GL_VERSION);
ost1<<"Vendor:" << vendor;
ost2<<"Renderer:" << renderer;
ost3<<"Version:" << version;
tell_log(console::MT_INFO,ost1.str());
tell_log(console::MT_INFO,ost2.str());
tell_log(console::MT_INFO,ost3.str());
#ifdef WIN32
HDC hdc = ::GetDC((HWND) GetHWND());
std::ostringstream ost;
PIXELFORMATDESCRIPTOR pfd;
//HDC hdc;
int iPixelFormat;
iPixelFormat = 1;
// obtain detailed information about
// the device context's first pixel format
DescribePixelFormat(hdc, iPixelFormat,
sizeof(PIXELFORMATDESCRIPTOR), &pfd);
if((pfd.dwFlags & PFD_GENERIC_FORMAT) && !(pfd.dwFlags & PFD_GENERIC_ACCELERATED))
{
ost<<"Program emulation of OpenGL";
tell_log(console::MT_INFO,ost.str());
ost<<"Operation can be extremely slow";
tell_log(console::MT_INFO,ost.str());
}
// Hardware supports only part of all set of functions ( MCD-driver ).
if((pfd.dwFlags & PFD_GENERIC_FORMAT) && (pfd.dwFlags & PFD_GENERIC_ACCELERATED))
{
ost<<"Program/hardware emulation of OpenGL";
tell_log(console::MT_INFO,ost.str());
ost<<"Some operations can not be accelerated";
tell_log(console::MT_INFO,ost.str());
}
// Full hardware support ( ICD-driver ).
if( !(pfd.dwFlags & PFD_GENERIC_FORMAT) && !(pfd.dwFlags & PFD_GENERIC_ACCELERATED))
{
ost<<"Hardware accelerated OpenGL";
tell_log(console::MT_INFO,ost.str());
}
#endif
#ifdef __WXGTK__
std::ostringstream msg;
msg << "GLX version "<< GetGLXVersion();
tell_log(console::MT_INFO, msg.str());
#endif
}
