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); }