bool OglContext::createPBuffer(ms_uint32 width, ms_uint32 height)
{
int maxHeight, maxWidth;
glXGetFBConfigAttrib(window, *configs, GLX_MAX_PBUFFER_WIDTH, &maxWidth);
glXGetFBConfigAttrib(window, *configs, GLX_MAX_PBUFFER_HEIGHT, &maxHeight);
ms_uint32 uMaxHeight = maxHeight, uMaxWidth = maxWidth;
this->width = MS_MIN(width, uMaxWidth);
this->height = MS_MIN(height, uMaxHeight);
int iPbufferAttributes[] = {
GLX_PBUFFER_WIDTH, this->width,
GLX_PBUFFER_HEIGHT, this->height,
GLX_LARGEST_PBUFFER, false,
0, 0
};
pbuffer = glXCreatePbuffer(window, *configs, iPbufferAttributes);
if (pbuffer == 0) {
msSetError(MS_OGLERR, "glXCreatePbuffer failed. glError: %d", "OglContext::init()", glGetError());
return false;
}
return true;
}
GLXFBConfig chooseFBConfig(Display* display) {
printf("Getting matching framebuffer configs\n");
int fbcount;
GLXFBConfig* fbc = glXChooseFBConfig(display, DefaultScreen(display),
visual_attribs, &fbcount);
if (!fbc)
fail("Failed to retrieve a framebuffer config\n");
printf("Found %d matching FB configs.\n", fbcount);
// Pick the FB config/visual with the most samples per pixel
printf("Getting XVisualInfos\n");
int best_fbc = -1, worst_fbc = -1, best_num_samp = -1,
worst_num_samp = 999;
for (int i = 0; i < fbcount; ++i) {
XVisualInfo *vi = glXGetVisualFromFBConfig(display, fbc[i]);
if (vi) {
int samp_buf, samples;
glXGetFBConfigAttrib(display, fbc[i], GLX_SAMPLE_BUFFERS,
&samp_buf);
glXGetFBConfigAttrib(display, fbc[i], GLX_SAMPLES, &samples);
printf("\tMatching fbconfig %d, visual ID 0x%2lx: "
"SAMPLE_BUFFERS = %d, SAMPLES = %d\n",
i, vi -> visualid, samp_buf, samples);
if (best_fbc < 0 || (samp_buf && samples) > best_num_samp)
best_fbc = i, best_num_samp = samples;
if (worst_fbc < 0 || !samp_buf || samples < worst_num_samp)
worst_fbc = i, worst_num_samp = samples;
}
XFree(vi);
}
XFree(fbc);
return fbc[best_fbc];
}
GLXFBConfig get_gl_bestFbc(Display *display,int screen) {
int visual_attribs[] ={
GLX_X_RENDERABLE,True,
GLX_DRAWABLE_TYPE,GLX_WINDOW_BIT,
GLX_RENDER_TYPE,GLX_RGBA_BIT,
GLX_X_VISUAL_TYPE,GLX_TRUE_COLOR,
GLX_RED_SIZE,8,
GLX_GREEN_SIZE,8,
GLX_BLUE_SIZE,8,
GLX_ALPHA_SIZE,8,
GLX_DEPTH_SIZE,24,
GLX_STENCIL_SIZE,8,
GLX_DOUBLEBUFFER,True,
//GLX_SAMPLE_BUFFERS , 1,
//GLX_SAMPLES , 4,
None
};
int fbcount;
GLXFBConfig *fbc=glXChooseFBConfig(display,screen,visual_attribs,&fbcount);
if(!fbc) {
fprintf(stderr,"window_create: Failed to retrieve a framebuffer config.\n");
return 0;
}
int best_fbc = -1,worst_fbc = -1,best_num_samp = -1,worst_num_samp = 999;
int i;
for(i=0; i<fbcount; ++i) {
XVisualInfo *vi = glXGetVisualFromFBConfig(display,fbc[i]);
if(vi) {
int samp_buf,samples;
glXGetFBConfigAttrib(display,fbc[i],GLX_SAMPLE_BUFFERS,&samp_buf);
glXGetFBConfigAttrib(display,fbc[i],GLX_SAMPLES,&samples);
fprintf(stderr,"Matching fbconfig %d, visual ID 0x%d: SAMPLE_BUFFERS=%d,SAMPLES=%d.\n",
i,vi->visualid,samp_buf,samples);
if(best_fbc < 0 || samp_buf && samples > best_num_samp) {
best_fbc = i;
best_num_samp = samples;
}
if(worst_fbc < 0 || !samp_buf || samples < worst_num_samp) {
worst_fbc = i;
worst_num_samp = samples;
}
}
XFree(vi);
}
GLXFBConfig bestFbc = fbc[best_fbc];
XFree(fbc);
return bestFbc;
}
bool checkPixmapPixelFormatMatch(EGLNativeDisplayType dpy,EGLNativePixmapType pix,EglConfig* cfg,unsigned int* width,unsigned int* height) {
unsigned int depth,configDepth,border;
int r,g,b,x,y;
IS_SUCCESS(glXGetFBConfigAttrib(dpy,cfg->nativeConfig(),GLX_RED_SIZE,&r));
IS_SUCCESS(glXGetFBConfigAttrib(dpy,cfg->nativeConfig(),GLX_GREEN_SIZE,&g));
IS_SUCCESS(glXGetFBConfigAttrib(dpy,cfg->nativeConfig(),GLX_BLUE_SIZE,&b));
configDepth = r + g + b;
Window root;
if(!XGetGeometry(dpy,pix,&root,&x,&y,width,height,&border,&depth)) return false;
return depth >= configDepth;
}
bool checkWindowPixelFormatMatch(EGLNativeDisplayType dpy,EGLNativeWindowType win,EglConfig* cfg,unsigned int* width,unsigned int* height) {
//TODO: to check what does ATI & NVIDIA enforce on win pixelformat
unsigned int depth,configDepth,border;
int r,g,b,x,y;
IS_SUCCESS(glXGetFBConfigAttrib(dpy,cfg->nativeConfig(),GLX_RED_SIZE,&r));
IS_SUCCESS(glXGetFBConfigAttrib(dpy,cfg->nativeConfig(),GLX_GREEN_SIZE,&g));
IS_SUCCESS(glXGetFBConfigAttrib(dpy,cfg->nativeConfig(),GLX_BLUE_SIZE,&b));
configDepth = r + g + b;
Window root;
if(!XGetGeometry(dpy,win,&root,&x,&y,width,height,&border,&depth)) return false;
return depth >= configDepth;
}
static GLXFBConfig
ChoosePixmapFBConfig(Display *display)
{
int screen = DefaultScreen(display);
GLXFBConfig *fbconfigs;
int i, nfbconfigs, value;
fbconfigs = glXGetFBConfigs(display, screen, &nfbconfigs);
for (i = 0; i < nfbconfigs; i++) {
glXGetFBConfigAttrib(display, fbconfigs[i], GLX_DRAWABLE_TYPE, &value);
if (!(value & GLX_PIXMAP_BIT))
continue;
glXGetFBConfigAttrib(display, fbconfigs[i],
GLX_BIND_TO_TEXTURE_TARGETS_EXT, &value);
if (!(value & GLX_TEXTURE_2D_BIT_EXT))
continue;
glXGetFBConfigAttrib(display, fbconfigs[i],
GLX_BIND_TO_TEXTURE_RGBA_EXT, &value);
if (value == False) {
glXGetFBConfigAttrib(display, fbconfigs[i],
GLX_BIND_TO_TEXTURE_RGB_EXT, &value);
if (value == False)
continue;
}
glXGetFBConfigAttrib(display, fbconfigs[i],
GLX_Y_INVERTED_EXT, &value);
if (value == True) {
top = 0.0f;
bottom = 1.0f;
}
else {
top = 1.0f;
bottom = 0.0f;
}
break;
}
if (i == nfbconfigs) {
printf("Unable to find FBconfig for texturing\n");
exit(1);
}
return fbconfigs[i];
}
GLXFBConfig FWindow::GetBestFrameBufferConfig()
{
const GLint VisualAttributes[]=
{
GLX_X_RENDERABLE, GL_TRUE,
GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR,
GLX_RED_SIZE, ColourBits,
GLX_GREEN_SIZE, ColourBits,
GLX_BLUE_SIZE, ColourBits,
GLX_ALPHA_SIZE, ColourBits,
GLX_DEPTH_SIZE, DepthBits,
GLX_STENCIL_SIZE, StencilBits,
GLX_DOUBLEBUFFER, GL_TRUE,
None
};
GLint FrameBufferCount;
GLuint BestBufferConfig, BestNumSamples = 0;
GLXFBConfig* Configs = glXChooseFBConfig(WindowManager::GetDisplay(), 0, VisualAttributes, &FrameBufferCount);
for(GLuint CurrentConfig = 0; CurrentConfig < FrameBufferCount; CurrentConfig++)
{
XVisualInfo* VisInfo = glXGetVisualFromFBConfig(WindowManager::GetDisplay(), Configs[CurrentConfig]);
if(VisInfo)
{
//printf("%i %i %i\n", VisInfo->depth, VisInfo->bits_per_rgb, VisInfo->colormap_size);
GLint Samples, SampleBuffer;
glXGetFBConfigAttrib(WindowManager::GetDisplay(), Configs[CurrentConfig], GLX_SAMPLE_BUFFERS, &SampleBuffer);
glXGetFBConfigAttrib(WindowManager::GetDisplay(), Configs[CurrentConfig], GLX_SAMPLES, &Samples);
if(SampleBuffer && Samples > -1)
{
BestBufferConfig = CurrentConfig;
BestNumSamples = Samples;
}
}
XFree(VisInfo);
}
GLXFBConfig BestConfig = Configs[BestBufferConfig];
XFree(Configs);
return BestConfig;
}
GLXPixmap
createGLXPixmap(Display* display, Pixmap pixmap)
{
const int attribs[] = {
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT,
None
};
int numConfigs = 0;
GLXFBConfig* config = glXChooseFBConfig(display, 0, attribs, &numConfigs);
if (numConfigs == 0) {
fprintf(stderr, "Failed to find a valid GLX FBConfig.\n");
return None;
}
GLXFBConfig cfg = config[0];
if (verbose) {
GLXFBConfigID id;
glXGetFBConfigAttrib(display, cfg, GLX_FBCONFIG_ID, (int*) &id);
printf("Using FBConfig with ID 0x%X\n", id);
}
return glXCreatePixmap(display, cfg, pixmap, NULL);
}
bool GlxBackend::initBuffer()
{
if (!initFbConfig())
return false;
if (overlayWindow()->create()) {
// Try to create double-buffered window in the overlay
XVisualInfo* visual = glXGetVisualFromFBConfig(display(), fbconfig);
if (!visual) {
qCritical() << "Failed to get visual from fbconfig";
return false;
}
XSetWindowAttributes attrs;
attrs.colormap = XCreateColormap(display(), rootWindow(), visual->visual, AllocNone);
window = XCreateWindow(display(), overlayWindow()->window(), 0, 0, displayWidth(), displayHeight(),
0, visual->depth, InputOutput, visual->visual, CWColormap, &attrs);
glxWindow = glXCreateWindow(display(), fbconfig, window, NULL);
overlayWindow()->setup(window);
XFree(visual);
} else {
qCritical() << "Failed to create overlay window";
return false;
}
int vis_buffer;
glXGetFBConfigAttrib(display(), fbconfig, GLX_VISUAL_ID, &vis_buffer);
XVisualInfo* visinfo_buffer = glXGetVisualFromFBConfig(display(), fbconfig);
qDebug() << "Buffer visual (depth " << visinfo_buffer->depth << "): 0x" << QString::number(vis_buffer, 16);
XFree(visinfo_buffer);
return true;
}
GLXFBConfig qglx_findConfig(Display *display, int screen , const QPlatformWindowFormat &format, int drawableBit)
{
bool reduced = true;
GLXFBConfig chosenConfig = 0;
QPlatformWindowFormat reducedFormat = format;
while (!chosenConfig && reduced) {
QVector<int> spec = qglx_buildSpec(reducedFormat, drawableBit);
int confcount = 0;
GLXFBConfig *configs;
configs = glXChooseFBConfig(display, screen,spec.constData(),&confcount);
if (confcount)
{
for (int i = 0; i < confcount; i++) {
chosenConfig = configs[i];
// Make sure we try to get an ARGB visual if the format asked for an alpha:
if (reducedFormat.alpha()) {
int alphaSize;
glXGetFBConfigAttrib(display,configs[i],GLX_ALPHA_SIZE,&alphaSize);
if (alphaSize > 0)
break;
} else {
break; // Just choose the first in the list if there's no alpha requested
}
}
XFree(configs);
}
reducedFormat = qglx_reducePlatformWindowFormat(reducedFormat,&reduced);
}
if (!chosenConfig)
qWarning("Warning: no suitable glx confiuration found");
return chosenConfig;
}
GLXFBConfig
piglit_glx_get_fbconfig_for_visinfo(Display *dpy, XVisualInfo *visinfo)
{
int i, nconfigs;
GLXFBConfig ret = None, *configs;
configs = glXGetFBConfigs(dpy, visinfo->screen, &nconfigs);
if (!configs)
return None;
for (i = 0; i < nconfigs; i++) {
int v;
if (glXGetFBConfigAttrib(dpy, configs[i], GLX_VISUAL_ID, &v))
continue;
if (v == visinfo->visualid) {
ret = configs[i];
break;
}
}
XFree(configs);
return ret;
}
/**
* Either use glXGetFBConfigAttrib() or glXGetFBConfigAttribSGIX()
* to query an fbconfig attribute.
*/
static int
GetFBConfigAttrib(Display *dpy, int screen,
#if defined(GLX_VERSION_1_3)
const GLXFBConfig config,
#elif defined(GLX_SGIX_fbconfig)
const GLXFBConfigSGIX config,
#endif
int attrib
)
{
int pbSupport = QueryPbuffers(dpy, screen);
int value = 0;
#if defined(GLX_VERSION_1_3)
if (pbSupport == 1) {
/* ok */
if (glXGetFBConfigAttrib(dpy, config, attrib, &value) != 0) {
value = 0;
}
return value;
}
/* fall-through */
#endif
#if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer)
if (pbSupport == 2) {
if (glXGetFBConfigAttribSGIX(dpy, config, attrib, &value) != 0) {
value = 0;
}
return value;
}
#endif
return value;
}
void C4Window::EnumerateMultiSamples(std::vector<int>& samples) const
{
#ifdef GDK_WINDOWING_X11
Display * const dpy = gdk_x11_display_get_xdisplay(gdk_display_get_default());
std::map<int, int> attribs = base_attrib_map;
attribs[GLX_SAMPLE_BUFFERS_ARB] = 1;
int config_count = 0;
GLXFBConfig *configs = glXChooseFBConfig(dpy, DefaultScreen(dpy), MakeGLXAttribList(attribs).get(), &config_count);
std::set<int> multisamples;
for(int i = 0; i < config_count; ++i)
{
int v_samples;
glXGetFBConfigAttrib(dpy, configs[i], GLX_SAMPLES, &v_samples);
multisamples.insert(v_samples);
}
XFree(configs);
samples.assign(multisamples.cbegin(), multisamples.cend());
#else
if(pGL && pGL->pMainCtx)
samples = pGL->pMainCtx->EnumerateMultiSamples();
#endif
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_GLX13_nglXGetFBConfigAttrib(JNIEnv *__env, jclass clazz, jlong displayAddress, jlong configAddress, jint attribute, jlong valueAddress, jlong __functionAddress) {
Display *display = (Display *)(intptr_t)displayAddress;
GLXFBConfig config = (GLXFBConfig)(intptr_t)configAddress;
int *value = (int *)(intptr_t)valueAddress;
glXGetFBConfigAttribPROC glXGetFBConfigAttrib = (glXGetFBConfigAttribPROC)(intptr_t)__functionAddress;
UNUSED_PARAMS(__env, clazz)
return (jint)glXGetFBConfigAttrib(display, config, attribute, value);
}
void X11Win::assignBestFBC(void) {
GLXFBConfig *tmp_fbc;
XVisualInfo *vi;
int fbcount;
int best_fbc, worst_fbc, best_num_samp, worst_num_samp;
int samp_buf, samples;
static int _v_att[] = {
GLX_X_RENDERABLE, True,
GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR,
GLX_RED_SIZE, 8,
GLX_GREEN_SIZE, 8,
GLX_BLUE_SIZE, 8,
GLX_ALPHA_SIZE, 8,
GLX_DEPTH_SIZE, 24,
GLX_STENCIL_SIZE, 8,
GLX_DOUBLEBUFFER, True,
// GLX_SAMPLE_BUFFERS , 1,
// GLX_SAMPLES, 4,
None
};
tmp_fbc = glXChooseFBConfig(_d, DefaultScreen(_d), _v_att, &fbcount);
best_fbc = worst_fbc = best_num_samp = -1;
worst_num_samp = 999;
for (int i = 0; i < fbcount; ++i) {
if ((vi = glXGetVisualFromFBConfig(_d, tmp_fbc[i]))) {
glXGetFBConfigAttrib(_d, tmp_fbc[i], GLX_SAMPLE_BUFFERS, &samp_buf);
glXGetFBConfigAttrib(_d, tmp_fbc[i], GLX_SAMPLES, &samples);
if (best_fbc < 0 || (samp_buf && samples > best_num_samp)) {
best_fbc = i;
best_num_samp = samples;
}
if (worst_fbc < 0 || !samp_buf || samples < worst_num_samp) {
worst_fbc = i;
worst_num_samp = samples;
}
}
XFree(vi);
}
_fbc = tmp_fbc[best_fbc];
XFree(tmp_fbc);
}
static bool findFramebufferConfig(Display *display, int *visualAttributes, GLXFBConfig &config)
{
int glx_major, glx_minor;
// FBConfigs were added in GLX version 1.3.
if ( !glXQueryVersion( display, &glx_major, &glx_minor ) ||
( ( glx_major == 1 ) && ( glx_minor < 3 ) ) || ( glx_major < 1 ) )
{
printError("Invalid GLX version");
return false;
}
int fbcount;
GLXFBConfig* fbc = glXChooseFBConfig(display, DefaultScreen(display), visualAttributes, &fbcount);
if (!fbc)
{
printError("Failed to retrieve a framebuffer config\n" );
return false;
}
// Pick the FB config/visual with the most samples per pixel
int best_fbc = -1, worst_fbc = -1, best_num_samp = -1, worst_num_samp = 999;
int i;
for (i=0; i<fbcount; ++i)
{
XVisualInfo *vi = glXGetVisualFromFBConfig( display, fbc[i] );
if ( vi )
{
int samp_buf, samples;
glXGetFBConfigAttrib( display, fbc[i], GLX_SAMPLE_BUFFERS, &samp_buf );
glXGetFBConfigAttrib( display, fbc[i], GLX_SAMPLES , &samples );
if ( best_fbc < 0 || (samp_buf && samples > best_num_samp) )
best_fbc = i, best_num_samp = samples;
if ( worst_fbc < 0 || !samp_buf || samples < worst_num_samp )
worst_fbc = i, worst_num_samp = samples;
}
XFree( vi );
}
config = fbc[ best_fbc ];
XFree( fbc );
return true;
}
bool C4Window::ReInit(C4AbstractApp* pApp)
{
// Check whether multisampling settings was changed. If not then we
// don't need to ReInit anything.
#ifdef GDK_WINDOWING_X11
int value;
Display * const dpy = gdk_x11_display_get_xdisplay(gdk_display_get_default());
glXGetFBConfigAttrib(dpy, Info, GLX_SAMPLES, &value);
if(value == Config.Graphics.MultiSampling) return true;
// Check whether we have a visual with the requested number of samples
GLXFBConfig new_info;
if(!FindFBConfig(Config.Graphics.MultiSampling, &new_info)) return false;
GdkScreen * scr = gtk_widget_get_screen(GTK_WIDGET(render_widget));
XVisualInfo *vis_info = glXGetVisualFromFBConfig(dpy, new_info);
assert(vis_info);
GdkVisual * vis = gdk_x11_screen_lookup_visual(scr, vis_info->visualid);
XFree(vis_info);
// Un- and re-realizing the render_widget does not work, the window
// remains hidden afterwards. So we re-create it from scratch.
gtk_widget_destroy(GTK_WIDGET(render_widget));
render_widget = gtk_drawing_area_new();
#if !GTK_CHECK_VERSION(3,10,0)
gtk_widget_set_double_buffered (GTK_WIDGET(render_widget), false);
#endif
g_object_set(G_OBJECT(render_widget), "can-focus", TRUE, NULL);
gtk_widget_set_visual(GTK_WIDGET(render_widget),vis);
Info = new_info;
// Wait until window is mapped to get the window's XID
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(render_widget));
gtk_widget_show_now(GTK_WIDGET(render_widget));
if (GTK_IS_LAYOUT(render_widget))
{
GdkWindow* bin_wnd = gtk_layout_get_bin_window(GTK_LAYOUT(render_widget));
renderwnd = GDK_WINDOW_XID(bin_wnd);
}
else
{
GdkWindow* render_wnd = gtk_widget_get_window(GTK_WIDGET(render_widget));
renderwnd = GDK_WINDOW_XID(render_wnd);
}
gdk_flush();
gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(render_widget)),
gdk_cursor_new_for_display(gdk_display_get_default(), GDK_BLANK_CURSOR));
return true;
#endif
}
enum piglit_result
draw(Display *dpy, GLXFBConfig config)
{
int dbits;
float green[3] = {0.0, 1.0, 0.0};
float blue[3] = {0.0, 0.0, 1.0};
float *left, *right;
bool pass = true;
piglit_dispatch_default_init(PIGLIT_DISPATCH_GL);
glXGetFBConfigAttrib(dpy, config, GLX_DEPTH_SIZE, &dbits);
piglit_ortho_projection(piglit_width, piglit_height, false);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_ALWAYS);
/* Set half the FB to depth 0, half to 1, and everything blue */
glColor3fv(blue);
piglit_draw_rect_z(1.0,
0, 0,
piglit_width / 2, piglit_height);
piglit_draw_rect_z(0.0,
piglit_width / 2, 0,
piglit_width, piglit_height);
/* Now draw a rect trying to set just the 1 values to green. */
glColor3fv(green);
glDepthFunc(GL_LESS);
piglit_draw_rect_z(0.5,
0, 0, piglit_width, piglit_height);
/* If there was a depth buffer, then we get half the window
* set to green. Otherwise, the depth test always passes
* and the whole thing should have been set green.
*/
if (dbits) {
left = blue;
right = green;
} else {
left = green;
right = green;
}
pass = pass && piglit_probe_rect_rgb(0, 0,
piglit_width / 2, piglit_height,
left);
pass = pass && piglit_probe_rect_rgb(piglit_width / 2, 0,
piglit_width - piglit_width / 2,
piglit_height,
right);
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
void fbconfig_attrs(GLXFBConfig fbc, int* width, int* height,
GLfloat* top, GLfloat* bottom) {
int v;
XWindowAttributes xattr;
XGetWindowAttributes(dpy, overlay, &xattr);
glXGetFBConfigAttrib(dpy, fbc, GLX_Y_INVERTED_EXT, &v);
*top = (!v)? 0.0f : 1.0f;
*bottom = (!v)? 1.0f : 0.0f;
*width = xattr.width;
*height = xattr.height;
}
GLXFBConfig choose_fbconfig() {
int i, nfbc;
GLXFBConfig* fbc = glXChooseFBConfig(dpy, screen, fbconfig_attr, &nfbc);
check_gl(__LINE__);
if (fbc == NULL)
die(1, "No valid FBConfigs.\n");
for (i=0; i<nfbc; i++) {
int v;
continue;
//if (!vi || vi->visualid != vid) continue;
debug("FBConfig #%d:\n", i);
glXGetFBConfigAttrib(dpy, fbc[i], GLX_DRAWABLE_TYPE, &v);
debug("GLX_DRAWABLE_TYPE: ");
if (v & GLX_WINDOW_BIT) log("WINDOW ");
if (v & GLX_PIXMAP_BIT) log("PIXMAP ");
if (v & GLX_PBUFFER_BIT) log("PBUFFER ");
log("\n");
glXGetFBConfigAttrib(dpy, fbc[i], GLX_BIND_TO_TEXTURE_TARGETS_EXT, &v);
debug("GLX_BIND_TO_TEXTURE_TARGETS_EXT: ");
if (v & GLX_TEXTURE_1D_BIT_EXT) log("1D ");
if (v & GLX_TEXTURE_2D_BIT_EXT) log("2D ");
if (v & GLX_TEXTURE_RECTANGLE_BIT_EXT) log("RECTANGLE ");
log("\n");
glXGetFBConfigAttrib(dpy, fbc[i], GLX_BIND_TO_TEXTURE_RGBA_EXT, &v);
debug("GLX_BIND_TO_TEXTURE_RGBA_EXT: ");
if (v) log("yes ");
else log("no ");
log("\n");
glXGetFBConfigAttrib(dpy, fbc[i], GLX_BIND_TO_TEXTURE_RGB_EXT, &v);
debug("GLX_BIND_TO_TEXTURE_RGB_EXT: ");
if (v) log("yes ");
else log("no ");
log("\n");
}
i = 0;
if (i == nfbc)
die(2, "No FBCofig found!\n");
return fbc[i];
}
// Returns the specified attribute of the specified GLXFBConfig
// NOTE: Do not call this unless we have found GLX 1.3+ or GLX_SGIX_fbconfig
//
static int getFBConfigAttrib(GLXFBConfig fbconfig, int attrib) {
int value;
if (_glfw.glx.SGIX_fbconfig) {
_glfw.glx.GetFBConfigAttribSGIX(_glfw.x11.display,
fbconfig, attrib, &value);
}
else
glXGetFBConfigAttrib(_glfw.x11.display, fbconfig, attrib, &value);
return value;
}
bool GLXGraphicsystem::CheckConfigValue(Display *curDisplay,GLXFBConfig currentConfig, int attribute, int expectedValue)
{
bool result = true;
int returnedValue = 0;
glXGetFBConfigAttrib(curDisplay,currentConfig,attribute,&returnedValue);
if ((returnedValue != expectedValue))
{
result = false;
}
return result;
}
/*
* Queries the GL context about some attributes
*/
static int fghGetConfig( int attribute )
{
int returnValue = 0;
if( fgStructure.CurrentWindow )
glXGetFBConfigAttrib( fgDisplay.Display,
*(fgStructure.CurrentWindow->Window.FBConfig),
attribute,
&returnValue );
return returnValue;
}
/*
* Queries the GL context about some attributes
*/
int fgPlatformGetConfig( int attribute )
{
int returnValue = 0;
int result __fg_unused; /* Not checked */
if( fgStructure.CurrentWindow )
result = glXGetFBConfigAttrib( fgDisplay.pDisplay.Display,
fgStructure.CurrentWindow->Window.pContext.FBConfig,
attribute,
&returnValue );
return returnValue;
}
GLXFBConfig WindowImplementation::findBestFrameBufferConfig(const WindowStyle& style){
int visualAttribs[] = {
GLX_X_RENDERABLE, True,
GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR,
GLX_RED_SIZE, style.redBits, // 8
GLX_GREEN_SIZE, style.greenBits, // 8
GLX_BLUE_SIZE, style.blueBits, // 8
GLX_ALPHA_SIZE, style.alphaBits, // 8
GLX_DEPTH_SIZE, style.depthBits, // 24
GLX_STENCIL_SIZE, style.stencilBits, // 8
GLX_DOUBLEBUFFER, True,
None
};
int frameBufferConfigCount;
auto frameBufferConfigs = glXChooseFBConfig(display, DefaultScreen(display), visualAttribs, &frameBufferConfigCount); // requires XFree
if (!frameBufferConfigs){
throw std::runtime_error("Failed to get frame buffer configurations");
}
int best = -1, bestNumberSamples = -1;//,worst_fbc = -1, worst_num_samp = 999;
for(int i = 0; i < frameBufferConfigCount; ++i){
XVisualInfo *visualInfo = glXGetVisualFromFBConfig(display, frameBufferConfigs[i]);
if (visualInfo){
int sampleBuffer, samples;
glXGetFBConfigAttrib(display, frameBufferConfigs[i], GLX_SAMPLE_BUFFERS, &sampleBuffer);
glXGetFBConfigAttrib(display, frameBufferConfigs[i], GLX_SAMPLES, &samples);
if (best < 0 || (sampleBuffer && (samples > bestNumberSamples))){
best = i, bestNumberSamples = samples;
}
}
XFree(visualInfo);
}
GLXFBConfig bestFrameBufferConfig = frameBufferConfigs[best];
//GLXFBConfig bestFrameBufferConfig = frameBufferConfigs[0]; // TODO update this so that it actually looks through the array to find 'best' config
XFree (frameBufferConfigs );
return bestFrameBufferConfig;
}
static int getFBConfigAttrib(_GLFWwindow* window, GLXFBConfig fbconfig, int attrib)
{
int value;
if (_glfwLibrary.GLX.SGIX_fbconfig)
{
_glfwLibrary.GLX.GetFBConfigAttribSGIX(_glfwLibrary.X11.display,
fbconfig, attrib, &value);
}
else
glXGetFBConfigAttrib(_glfwLibrary.X11.display, fbconfig, attrib, &value);
return value;
}
int main(int argc, char *argv[]) {
Display *dpy;
int eventbase, errorbase;
int major, minor;
GLXFBConfig *configs;
int numconfigs, i;
dpy = XOpenDisplay(NULL);
if(NULL == dpy) {
fprintf(stderr, "error: unable to open display!\n");
return EXIT_FAILURE;
}
if(!glXQueryExtension(dpy, &eventbase, &errorbase)) {
fprintf(stderr, "GLX is not available!\n");
return EXIT_FAILURE;
}
printf("GLX eventbase %d errorbase %d\n", eventbase, errorbase);
if(!glXQueryVersion(dpy, &major, &minor)) {
fprintf(stderr, "GLX version query error!\n");
return EXIT_FAILURE;
}
printf("GLX version: %d.%d\n", major, minor);
configs = glXGetFBConfigs(dpy, DefaultScreen(dpy), &numconfigs);
if(NULL == configs) {
fprintf(stderr, "error: retrieving GLXFBConfigs!\n");
return EXIT_FAILURE;
}
for(i = 0; i < numconfigs; ++i) {
int value;
if(Success != glXGetFBConfigAttrib(dpy, configs[i], GLX_STEREO, &value)) {
fprintf(stderr, "unable to query GLX_STEREO!\n");
return EXIT_FAILURE;
}
printf("GLXFBConfig[%d] has stereo %d\n", i, value);
}
return EXIT_SUCCESS;
}
GLXFBConfig qglx_findConfig(Display *display, int screen , const QSurfaceFormat &format, int drawableBit)
{
bool reduced = true;
GLXFBConfig chosenConfig = 0;
QSurfaceFormat reducedFormat = format;
while (!chosenConfig && reduced) {
QVector<int> spec = qglx_buildSpec(reducedFormat, drawableBit);
int confcount = 0;
GLXFBConfig *configs;
configs = glXChooseFBConfig(display, screen,spec.constData(),&confcount);
if (confcount)
{
for (int i = 0; i < confcount; i++) {
chosenConfig = configs[i];
// Make sure we try to get an ARGB visual if the format asked for an alpha:
if (reducedFormat.hasAlpha()) {
int alphaSize;
glXGetFBConfigAttrib(display,configs[i],GLX_ALPHA_SIZE,&alphaSize);
if (alphaSize > 0) {
XVisualInfo *visual = glXGetVisualFromFBConfig(display, chosenConfig);
bool hasAlpha = false;
#if !defined(QT_NO_XRENDER)
XRenderPictFormat *pictFormat = XRenderFindVisualFormat(display, visual->visual);
hasAlpha = pictFormat->direct.alphaMask > 0;
#else
hasAlpha = visual->depth == 32;
#endif
XFree(visual);
if (hasAlpha)
break;
}
} else {
break; // Just choose the first in the list if there's no alpha requested
}
}
XFree(configs);
}
if (!chosenConfig)
reducedFormat = qglx_reduceSurfaceFormat(reducedFormat,&reduced);
}
return chosenConfig;
}
QSurfaceFormat qglx_surfaceFormatFromGLXFBConfig(Display *display, GLXFBConfig config, GLXContext)
{
QSurfaceFormat format;
int redSize = 0;
int greenSize = 0;
int blueSize = 0;
int alphaSize = 0;
int depthSize = 0;
int stencilSize = 0;
int sampleBuffers = 0;
int sampleCount = 0;
int stereo = 0;
XVisualInfo *vi = glXGetVisualFromFBConfig(display,config);
XFree(vi);
glXGetFBConfigAttrib(display, config, GLX_RED_SIZE, &redSize);
glXGetFBConfigAttrib(display, config, GLX_GREEN_SIZE, &greenSize);
glXGetFBConfigAttrib(display, config, GLX_BLUE_SIZE, &blueSize);
glXGetFBConfigAttrib(display, config, GLX_ALPHA_SIZE, &alphaSize);
glXGetFBConfigAttrib(display, config, GLX_DEPTH_SIZE, &depthSize);
glXGetFBConfigAttrib(display, config, GLX_STENCIL_SIZE, &stencilSize);
glXGetFBConfigAttrib(display, config, GLX_SAMPLES_ARB, &sampleBuffers);
glXGetFBConfigAttrib(display, config, GLX_STEREO, &stereo);
format.setRedBufferSize(redSize);
format.setGreenBufferSize(greenSize);
format.setBlueBufferSize(blueSize);
format.setAlphaBufferSize(alphaSize);
format.setDepthBufferSize(depthSize);
format.setStencilBufferSize(stencilSize);
if (sampleBuffers) {
glXGetFBConfigAttrib(display, config, GLX_SAMPLES_ARB, &sampleCount);
format.setSamples(sampleCount);
}
format.setStereo(stereo);
return format;
}
static void PrintVisual(void)
{
int r, g, b, a, d, s, v;
glXGetFBConfigAttrib (display, gl_fbconfig, GLX_RED_SIZE, &r);
glXGetFBConfigAttrib (display, gl_fbconfig, GLX_GREEN_SIZE, &g);
glXGetFBConfigAttrib (display, gl_fbconfig, GLX_BLUE_SIZE, &b);
glXGetFBConfigAttrib (display, gl_fbconfig, GLX_ALPHA_SIZE, &a);
glXGetFBConfigAttrib (display, gl_fbconfig, GLX_DEPTH_SIZE, &d);
glXGetFBConfigAttrib (display, gl_fbconfig, GLX_STENCIL_SIZE, &s);
glXGetFBConfigAttrib (display, gl_fbconfig, GLX_VISUAL_ID, &v);
printf("Visual 0x%x\n", v);
printf("A:R:G:B = %i:%i:%i:%i\n", a, r, g, b);
printf("depth = %i, stencil = %i\n", d, s);
}
