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;
}
EXTERN_C_ENTER
JNIEXPORT jlong JNICALL Java_org_lwjgl_opengl_GLX13_nglXGetFBConfigs(JNIEnv *__env, jclass clazz, jlong displayAddress, jint screen, jlong nelementsAddress, jlong __functionAddress) {
Display *display = (Display *)(intptr_t)displayAddress;
int *nelements = (int *)(intptr_t)nelementsAddress;
glXGetFBConfigsPROC glXGetFBConfigs = (glXGetFBConfigsPROC)(intptr_t)__functionAddress;
UNUSED_PARAMS(__env, clazz)
return (jlong)(intptr_t)glXGetFBConfigs(display, screen, nelements);
}
void queryConfigs(EGLNativeDisplayType dpy,int renderableType,ConfigsList& listOut) {
int n;
EGLNativePixelFormatType* frmtList = glXGetFBConfigs(dpy,0,&n);
for(int i =0 ;i < n ; i++) {
EglConfig* conf = pixelFormatToConfig(dpy,renderableType,&frmtList[i]);
if(conf) listOut.push_back(conf);
}
XFree(frmtList);
}
enum piglit_result
piglit_glx_iterate_visuals(enum piglit_result (*draw)(Display *dpy,
GLXFBConfig config))
{
int screen;
GLXFBConfig *configs;
int n_configs;
int i;
bool any_fail = false;
bool any_pass = false;
Display *dpy = XOpenDisplay(NULL);
if (!dpy) {
fprintf(stderr, "couldn't open display\n");
piglit_report_result(PIGLIT_FAIL);
}
screen = DefaultScreen(dpy);
configs = glXGetFBConfigs(dpy, screen, &n_configs);
if (!configs) {
fprintf(stderr, "No GLX FB configs\n");
piglit_report_result(PIGLIT_SKIP);
}
for (i = 0; i < n_configs; i++) {
enum piglit_result result;
XVisualInfo *visinfo;
GLXContext ctx;
GLXDrawable d;
visinfo = glXGetVisualFromFBConfig(dpy, configs[i]);
if (!visinfo)
continue;
ctx = piglit_get_glx_context(dpy, visinfo);
d = piglit_get_glx_window(dpy, visinfo);
glXMakeCurrent(dpy, d, ctx);
XFree(visinfo);
result = piglit_iterate_visuals_event_loop(dpy, draw,
configs[i]);
if (result == PIGLIT_FAIL)
any_fail = true;
else if (result == PIGLIT_PASS)
any_pass = true;
XDestroyWindow(dpy, d);
glXDestroyContext(dpy, ctx);
}
if (any_fail)
return PIGLIT_FAIL;
else if (any_pass)
return PIGLIT_PASS;
else
return PIGLIT_SKIP;
}
void initFrameBuffer() {
/* Query framebuffer configurations */
GLXFBConfig *fb_configs = 0;
int num_fb_configs = 0;
fb_configs = glXGetFBConfigs(display, default_screen, &num_fb_configs);
if (!fb_configs || num_fb_configs == 0)
printf("glXGetFBConfigs failed");
fb_config = fb_configs[0];
}
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 GLXGLSupport::selectFBConfig (const int* minAttribs, const int *maxAttribs)
{
GLXFBConfig *fbConfigs;
GLXFBConfig fbConfig = 0;
int config, nConfigs = 0;
fbConfigs = chooseFBConfig(minAttribs, &nConfigs);
// this is a fix for cases where chooseFBConfig is not supported.
// On the 10/2010 chooseFBConfig was not supported on VirtualBox
// http://www.virtualbox.org/ticket/7195
if (!nConfigs)
{
fbConfigs = glXGetFBConfigs(mGLDisplay, DefaultScreen(mGLDisplay), &nConfigs);
}
if (! nConfigs)
return 0;
fbConfig = fbConfigs[0];
if (maxAttribs)
{
FBConfigAttribs maximum(maxAttribs);
FBConfigAttribs best(maxAttribs);
FBConfigAttribs candidate(maxAttribs);
best.load(this, fbConfig);
for (config = 1; config < nConfigs; config++)
{
candidate.load(this, fbConfigs[config]);
if (candidate > maximum)
continue;
if (candidate > best)
{
fbConfig = fbConfigs[config];
best.load(this, fbConfig);
}
}
}
XFree (fbConfigs);
return fbConfig;
}
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;
}
FBCONFIG *
GetAllFBConfigs(Display *dpy, int screen, int *nConfigs)
{
int pbSupport = QueryPbuffers(dpy, screen);
#if defined(GLX_VERSION_1_3)
if (pbSupport == 1) {
return glXGetFBConfigs(dpy, screen, nConfigs);
}
#endif
#if defined(GLX_SGIX_fbconfig) && defined(GLX_SGIX_pbuffer)
if (pbSupport == 2) {
/* The GLX_SGIX_fbconfig extensions says to pass NULL to get list
* of all available configurations.
*/
return glXChooseFBConfigSGIX(dpy, screen, NULL, nConfigs);
}
#endif
return NULL;
}
/**
* Tests for existence of the GLX_SGIX_pbuffer extension,
* and creates an appropriate GLX pbuffer
*/
GLXPBuffer::GLXPBuffer(const int shadowMapSize, const bool sharedcontext, const bool shareobjects): m_pDisplay(0), m_glxPbuffer(0), m_glxContext(0), m_pOldDisplay(0), m_glxOldDrawable(0), m_glxOldContext(0), shadowMapSize(shadowMapSize), m_bSharedContext(sharedcontext), m_bShareObjects(shareobjects)
{
if (!GLX_SGIX_pbuffer)
return;
Display *pDisplay = glXGetCurrentDisplay();
int iScreen = DefaultScreen(pDisplay);
GLXContext glxContext = glXGetCurrentContext();
int iConfigCount;
GLXFBConfig *glxConfig;
if (m_bSharedContext)
glxConfig = glXGetFBConfigs(pDisplay, iScreen, &iConfigCount);
else {
int pf_attr[16] = {
GLX_DRAWABLE_TYPE,
GLX_PBUFFER_BIT,
GLX_RENDER_TYPE,
GLX_RGBA_BIT,
0
};
glxConfig = glXChooseFBConfigSGIX(pDisplay, iScreen, pf_attr, &iConfigCount);
}
if (!glxConfig)
return;
int pb_attr[16] = {
GLX_LARGEST_PBUFFER, false,
GLX_PRESERVED_CONTENTS, true,
0
};
m_glxPbuffer = glXCreateGLXPbufferSGIX(pDisplay, glxConfig[0], shadowMapSize, shadowMapSize, pb_attr);
if (!m_glxPbuffer)
return;
if (m_bSharedContext)
m_glxContext = glxContext;
else {
m_glxContext = glXCreateContextWithConfigSGIX(pDisplay, glxConfig[0], GLX_RGBA_TYPE, (m_bShareObjects?glxContext:NULL), true);
if (!glxConfig)
return;
}
m_pDisplay = pDisplay;
}
DECLEXPORT(EGLBoolean) eglGetConfigs (EGLDisplay hDisplay, EGLConfig *paConfigs, EGLint caConfigs, EGLint *pcaConfigs)
{
Display *pDisplay = (Display *)hDisplay;
GLXFBConfig *paFBConfigs;
int caFBConfigs, i;
if (!VALID_PTR(pDisplay))
return setEGLError(EGL_NOT_INITIALIZED);
if (!VALID_PTR(pcaConfigs))
return setEGLError(EGL_BAD_PARAMETER);
if (caConfigs > 0 && !VALID_PTR(paConfigs))
return setEGLError(EGL_BAD_PARAMETER);
paFBConfigs = glXGetFBConfigs(pDisplay, DefaultScreen(pDisplay), &caFBConfigs);
AssertPtrReturn(paFBConfigs, setEGLError(EGL_BAD_PARAMETER));
if (caFBConfigs > caConfigs)
caFBConfigs = caConfigs;
*pcaConfigs = caFBConfigs;
for (i = 0; i < caFBConfigs; ++i)
paConfigs[i] = (EGLConfig)paFBConfigs[i];
XFree(paFBConfigs);
return clearEGLError();
}
static void
print_fbconfig_info(Display *dpy, int scrnum, InfoMode mode)
{
int numFBConfigs = 0;
struct visual_attribs attribs;
GLXFBConfig *fbconfigs;
int i;
/* get list of all fbconfigs on this screen */
fbconfigs = glXGetFBConfigs(dpy, scrnum, &numFBConfigs);
if (numFBConfigs == 0) {
XFree(fbconfigs);
return;
}
printf("%d GLXFBConfigs:\n", numFBConfigs);
if (mode == Normal)
print_visual_attribs_short_header();
else if (mode == Wide)
print_visual_attribs_long_header();
for (i = 0; i < numFBConfigs; i++) {
get_fbconfig_attribs(dpy, fbconfigs[i], &attribs);
if (mode == Verbose)
print_visual_attribs_verbose(&attribs);
else if (mode == Normal)
print_visual_attribs_short(&attribs);
else if (mode == Wide)
print_visual_attribs_long(&attribs);
}
printf("\n");
XFree(fbconfigs);
}
struct rtb_window *
window_impl_open(struct rutabaga *rtb,
int w, int h, const char *title, intptr_t parent)
{
struct xcb_rutabaga *xrtb = (void *) rtb;
struct xrtb_window *self;
Display *dpy;
xcb_connection_t *xcb_conn;
int default_screen;
GLXFBConfig *fb_configs, fb_config;
XVisualInfo *visual;
int nfb_configs;
uint32_t event_mask =
XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_EXPOSURE |
XCB_EVENT_MASK_VISIBILITY_CHANGE | XCB_EVENT_MASK_BUTTON_PRESS |
XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_POINTER_MOTION |
XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW |
XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_KEY_RELEASE |
XCB_EVENT_MASK_KEYMAP_STATE;
uint32_t value_mask =
XCB_CW_BORDER_PIXEL | XCB_CW_BACK_PIXMAP |
XCB_CW_BIT_GRAVITY |
XCB_CW_EVENT_MASK | XCB_CW_COLORMAP;
uint32_t value_list[6];
xcb_colormap_t colormap;
xcb_void_cookie_t ck_window, ck_map;
xcb_generic_error_t *err;
assert(rtb);
assert(h > 0);
assert(w > 0);
if (!(self = calloc(1, sizeof(*self))))
goto err_malloc;
self->xrtb = xrtb;
dpy = xrtb->dpy;
xcb_conn = xrtb->xcb_conn;
default_screen = DefaultScreen(dpy);
self->screen = find_xcb_screen(xcb_conn, default_screen);
if (!self->screen) {
ERR("couldn't find XCB screen\n");
goto err_screen;
}
/**
* gl configuration
*/
fb_configs = glXGetFBConfigs(dpy, default_screen, &nfb_configs);
if (!fb_configs || !nfb_configs) {
ERR("no GL configurations, bailing out\n");
goto err_gl_config;
}
fb_config = find_reasonable_fb_config(dpy, xcb_conn, fb_configs,
nfb_configs, 0);
if (!fb_config) {
ERR("no reasonable GL configurations, bailing out\n");
goto err_gl_config;
}
visual = glXGetVisualFromFBConfig(dpy, fb_config);
self->gl_ctx = new_gl_context(dpy, fb_config);
if (!self->gl_ctx) {
ERR("couldn't create GLX context\n");
goto err_gl_ctx;
}
/**
* window setup
*/
colormap = xcb_generate_id(xcb_conn);
self->xcb_win = xcb_generate_id(xcb_conn);
xcb_create_colormap(
xcb_conn, XCB_COLORMAP_ALLOC_NONE, colormap,
self->screen->root, visual->visualid);
value_list[0] = 0;
value_list[1] = 0;
value_list[2] = XCB_GRAVITY_STATIC;
value_list[3] = event_mask;
value_list[4] = colormap;
value_list[5] = 0;
ck_window = xcb_create_window_checked(
xcb_conn, visual->depth, self->xcb_win,
parent ? (xcb_window_t) parent : self->screen->root,
0, 0,
w, h,
0,
XCB_WINDOW_CLASS_INPUT_OUTPUT,
visual->visualid, value_mask, value_list);
free(visual);
if ((err = xcb_request_check(xcb_conn, ck_window))) {
ERR("can't create XCB window: %d\n", err->error_code);
goto err_xcb_win;
}
get_dpi(dpy, default_screen, &self->dpi.x, &self->dpi.y);
self->gl_win = glXCreateWindow(dpy, fb_config, self->xcb_win, 0);
if (!self->gl_win) {
ERR("couldn't create GL window\n");
goto err_gl_win;
}
if (set_xprop(xcb_conn, self->xcb_win, XCB_ATOM_WM_NAME, title))
set_xprop(xcb_conn, self->xcb_win, XCB_ATOM_WM_NAME, "oh no");
self->gl_draw = self->gl_win;
if (!glXMakeContextCurrent(
dpy, self->gl_draw, self->gl_draw, self->gl_ctx)) {
ERR("couldn't activate GLX context\n");
goto err_gl_make_current;
}
ck_map = xcb_map_window_checked(xcb_conn, self->xcb_win);
if ((err = xcb_request_check(xcb_conn, ck_map))) {
ERR("can't map XCB window: %d\n", err->error_code);
goto err_win_map;
}
if (parent)
raise_window(xcb_conn, self->xcb_win);
else
xcb_icccm_set_wm_protocols(xcb_conn,
self->xcb_win, xrtb->atoms.wm_protocols,
1, &xrtb->atoms.wm_delete_window);
free(fb_configs);
uv_mutex_init(&self->lock);
return RTB_WINDOW(self);
err_win_map:
err_gl_make_current:
err_gl_win:
xcb_destroy_window(xcb_conn, self->xcb_win);
err_xcb_win:
glXDestroyContext(dpy, self->gl_ctx);
err_gl_ctx:
err_gl_config:
free(fb_configs);
err_screen:
free(self);
err_malloc:
return NULL;
}
// choose the best configs for the destination buffer
bool SceneOpenGL::initBufferConfigs()
{
int cnt;
GLXFBConfig *fbconfigs = glXGetFBConfigs(display(), DefaultScreen(display()), &cnt);
fbcbuffer_db = NULL;
fbcbuffer_nondb = NULL;
for (int i = 0; i < 2; i++) {
int back, stencil, depth, caveat, alpha;
back = i > 0 ? INT_MAX : 1;
stencil = INT_MAX;
depth = INT_MAX;
caveat = INT_MAX;
alpha = 0;
for (int j = 0; j < cnt; j++) {
XVisualInfo *vi;
int visual_depth;
vi = glXGetVisualFromFBConfig(display(), fbconfigs[ j ]);
if (vi == NULL)
continue;
visual_depth = vi->depth;
XFree(vi);
if (visual_depth != DefaultDepth(display(), DefaultScreen(display())))
continue;
int value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_ALPHA_SIZE, &alpha);
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_BUFFER_SIZE, &value);
if (value != visual_depth && (value - alpha) != visual_depth)
continue;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_RENDER_TYPE, &value);
if (!(value & GLX_RGBA_BIT))
continue;
int back_value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_DOUBLEBUFFER, &back_value);
if (i > 0) {
if (back_value > back)
continue;
} else {
if (back_value < back)
continue;
}
int stencil_value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_STENCIL_SIZE, &stencil_value);
if (stencil_value > stencil)
continue;
int depth_value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_DEPTH_SIZE, &depth_value);
if (depth_value > depth)
continue;
int caveat_value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_CONFIG_CAVEAT, &caveat_value);
if (caveat_value > caveat)
continue;
back = back_value;
stencil = stencil_value;
depth = depth_value;
caveat = caveat_value;
if (i > 0)
fbcbuffer_nondb = fbconfigs[ j ];
else
fbcbuffer_db = fbconfigs[ j ];
}
}
if (cnt)
XFree(fbconfigs);
if (fbcbuffer_db == NULL && fbcbuffer_nondb == NULL) {
kError(1212) << "Couldn't find framebuffer configuration for buffer!";
return false;
}
for (int i = 0; i <= 32; i++) {
if (fbcdrawableinfo[ i ].fbconfig == NULL)
continue;
int vis_drawable = 0;
glXGetFBConfigAttrib(display(), fbcdrawableinfo[ i ].fbconfig, GLX_VISUAL_ID, &vis_drawable);
kDebug(1212) << "Drawable visual (depth " << i << "): 0x" << QString::number(vis_drawable, 16);
}
return true;
}
EGLBoolean __createWindowSurface(EGLSurfaceImpl* newSurface, EGLNativeWindowType win, const EGLint *attrib_list, const EGLDisplayImpl* walkerDpy, const EGLConfigImpl* walkerConfig, EGLint* error)
{
if (!newSurface || !walkerDpy || !walkerConfig || !error)
{
return EGL_FALSE;
}
if (attrib_list)
{
EGLint indexAttribList = 0;
while (attrib_list[indexAttribList] != EGL_NONE)
{
EGLint value = attrib_list[indexAttribList + 1];
switch (attrib_list[indexAttribList])
{
case EGL_GL_COLORSPACE:
{
if (value == EGL_GL_COLORSPACE_LINEAR)
{
// Do nothing.
}
else if (value == EGL_GL_COLORSPACE_SRGB)
{
*error = EGL_BAD_MATCH;
return EGL_FALSE;
}
else
{
*error = EGL_BAD_ATTRIBUTE;
return EGL_FALSE;
}
}
break;
case EGL_RENDER_BUFFER:
{
if (value == EGL_SINGLE_BUFFER)
{
if (walkerConfig->doubleBuffer)
{
*error = EGL_BAD_MATCH;
return EGL_FALSE;
}
}
else if (value == EGL_BACK_BUFFER)
{
if (!walkerConfig->doubleBuffer)
{
*error = EGL_BAD_MATCH;
return EGL_FALSE;
}
}
else
{
*error = EGL_BAD_ATTRIBUTE;
return EGL_FALSE;
}
}
break;
case EGL_VG_ALPHA_FORMAT:
{
*error = EGL_BAD_MATCH;
return EGL_FALSE;
}
break;
case EGL_VG_COLORSPACE:
{
*error = EGL_BAD_MATCH;
return EGL_FALSE;
}
break;
}
indexAttribList += 2;
// More than 4 entries can not exist.
if (indexAttribList >= 4 * 2)
{
*error = EGL_BAD_ATTRIBUTE;
return EGL_FALSE;
}
}
}
//
EGLint numberPixelFormats;
GLXFBConfig* fbConfigs = glXGetFBConfigs(walkerDpy->display_id, DefaultScreen(walkerDpy->display_id), &numberPixelFormats);
if (!fbConfigs || numberPixelFormats == 0)
{
if (fbConfigs)
{
XFree(fbConfigs);
}
return EGL_FALSE;
}
EGLint attribute;
XVisualInfo* visualInfo;
GLXFBConfig config = 0;
for (EGLint currentPixelFormat = 0; currentPixelFormat < numberPixelFormats; currentPixelFormat++)
{
EGLint value;
attribute = GLX_VISUAL_ID;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &value))
{
XFree(fbConfigs);
return EGL_FALSE;
}
if (!value)
{
continue;
}
// No check for OpenGL.
attribute = GLX_RENDER_TYPE;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &value))
{
XFree(fbConfigs);
return EGL_FALSE;
}
if (!(value & GLX_RGBA_BIT))
{
continue;
}
attribute = GLX_TRANSPARENT_TYPE;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &value))
{
XFree(fbConfigs);
return EGL_FALSE;
}
if (value == GLX_TRANSPARENT_INDEX)
{
continue;
}
//
visualInfo = glXGetVisualFromFBConfig(walkerDpy->display_id, fbConfigs[currentPixelFormat]);
if (!visualInfo)
{
XFree(fbConfigs);
return EGL_FALSE;
}
if (walkerConfig->nativeVisualId == visualInfo->visualid)
{
config = fbConfigs[currentPixelFormat];
XFree(visualInfo);
break;
}
XFree(visualInfo);
}
XFree(fbConfigs);
if (!config)
{
return EGL_FALSE;
}
newSurface->drawToWindow = EGL_TRUE;
newSurface->drawToPixmap = EGL_FALSE;
newSurface->drawToPixmap = EGL_FALSE;
newSurface->doubleBuffer = walkerConfig->doubleBuffer;
newSurface->configId = walkerConfig->configId;
newSurface->initialized = EGL_TRUE;
newSurface->destroy = EGL_FALSE;
newSurface->win = win;
newSurface->nativeSurfaceContainer.config = config;
newSurface->nativeSurfaceContainer.drawable = win;
return EGL_TRUE;
}
enum piglit_result
piglit_glx_iterate_pixmap_fbconfigs(enum piglit_result (*draw)(Display *dpy,
GLXFBConfig config))
{
int screen;
GLXFBConfig *configs;
int n_configs;
int i;
bool any_fail = false;
bool any_pass = false;
Window root_win;
Display *dpy = XOpenDisplay(NULL);
if (!dpy) {
fprintf(stderr, "couldn't open display\n");
piglit_report_result(PIGLIT_FAIL);
}
screen = DefaultScreen(dpy);
root_win = RootWindow(dpy, screen);
configs = glXGetFBConfigs(dpy, screen, &n_configs);
if (!configs) {
fprintf(stderr, "No GLX FB configs\n");
piglit_report_result(PIGLIT_SKIP);
}
for (i = 0; i < n_configs; i++) {
GLXFBConfig config = configs[i];
enum piglit_result result;
GLXContext ctx;
Pixmap pix;
GLXPixmap glx_pix;
int draw_types;
int depth;
glXGetFBConfigAttrib(dpy, config, GLX_DRAWABLE_TYPE,
&draw_types);
if (!(draw_types & GLX_PIXMAP_BIT))
continue;
glXGetFBConfigAttrib(dpy, config, GLX_BUFFER_SIZE,
&depth);
ctx = glXCreateNewContext(dpy, config, GLX_RGBA_TYPE,
NULL, true);
pix = XCreatePixmap(dpy, root_win,
piglit_width, piglit_height, depth);
glx_pix = glXCreatePixmap(dpy, config, pix, NULL);
glXMakeCurrent(dpy, glx_pix, ctx);
result = draw(dpy, config);
if (result == PIGLIT_FAIL)
any_fail = true;
else if (result == PIGLIT_PASS)
any_pass = true;
XFreePixmap(dpy, pix);
glXDestroyContext(dpy, ctx);
}
if (any_fail)
return PIGLIT_FAIL;
else if (any_pass)
return PIGLIT_PASS;
else
return PIGLIT_SKIP;
}
static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found)
{
GLXFBConfig* fbconfigs;
_GLFWfbconfig* result;
int i, count = 0;
const char* vendor;
GLboolean trustWindowBit = GL_TRUE;
*found = 0;
if (_glfwLibrary.GLX.majorVersion == 1 && _glfwLibrary.GLX.minorVersion < 3)
{
if (!_glfwLibrary.GLX.SGIX_fbconfig)
{
_glfwSetError(GLFW_API_UNAVAILABLE,
"GLX: GLXFBConfig support not found");
return NULL;
}
}
vendor = glXGetClientString(_glfwLibrary.X11.display, GLX_VENDOR);
if (strcmp(vendor, "Chromium") == 0)
{
// HACK: This is a (hopefully temporary) workaround for Chromium
// (VirtualBox GL) not setting the window bit on any GLXFBConfigs
trustWindowBit = GL_FALSE;
}
if (_glfwLibrary.GLX.SGIX_fbconfig)
{
fbconfigs = _glfwLibrary.GLX.ChooseFBConfigSGIX(_glfwLibrary.X11.display,
_glfwLibrary.X11.screen,
NULL,
&count);
if (!count)
{
_glfwSetError(GLFW_API_UNAVAILABLE,
"GLX: No GLXFBConfigs returned");
return NULL;
}
}
else
{
fbconfigs = glXGetFBConfigs(_glfwLibrary.X11.display,
_glfwLibrary.X11.screen,
&count);
if (!count)
{
_glfwSetError(GLFW_API_UNAVAILABLE,
"GLX: No GLXFBConfigs returned");
return NULL;
}
}
result = (_GLFWfbconfig*) malloc(sizeof(_GLFWfbconfig) * count);
if (!result)
{
_glfwSetError(GLFW_OUT_OF_MEMORY, NULL);
return NULL;
}
for (i = 0; i < count; i++)
{
_GLFWfbconfig* f = result + *found;
if (!getFBConfigAttrib(window, fbconfigs[i], GLX_DOUBLEBUFFER) ||
!getFBConfigAttrib(window, fbconfigs[i], GLX_VISUAL_ID))
{
// Only consider double-buffered GLXFBConfigs with associated visuals
continue;
}
if (!(getFBConfigAttrib(window,
fbconfigs[i],
GLX_RENDER_TYPE) & GLX_RGBA_BIT))
{
// Only consider RGBA GLXFBConfigs
continue;
}
if (!(getFBConfigAttrib(window, fbconfigs[i], GLX_DRAWABLE_TYPE) & GLX_WINDOW_BIT))
{
if (trustWindowBit)
{
// Only consider window GLXFBConfigs
continue;
}
}
f->redBits = getFBConfigAttrib(window, fbconfigs[i], GLX_RED_SIZE);
f->greenBits = getFBConfigAttrib(window, fbconfigs[i], GLX_GREEN_SIZE);
f->blueBits = getFBConfigAttrib(window, fbconfigs[i], GLX_BLUE_SIZE);
f->alphaBits = getFBConfigAttrib(window, fbconfigs[i], GLX_ALPHA_SIZE);
f->depthBits = getFBConfigAttrib(window, fbconfigs[i], GLX_DEPTH_SIZE);
f->stencilBits = getFBConfigAttrib(window, fbconfigs[i], GLX_STENCIL_SIZE);
f->accumRedBits = getFBConfigAttrib(window, fbconfigs[i], GLX_ACCUM_RED_SIZE);
f->accumGreenBits = getFBConfigAttrib(window, fbconfigs[i], GLX_ACCUM_GREEN_SIZE);
f->accumBlueBits = getFBConfigAttrib(window, fbconfigs[i], GLX_ACCUM_BLUE_SIZE);
f->accumAlphaBits = getFBConfigAttrib(window, fbconfigs[i], GLX_ACCUM_ALPHA_SIZE);
f->auxBuffers = getFBConfigAttrib(window, fbconfigs[i], GLX_AUX_BUFFERS);
f->stereo = getFBConfigAttrib(window, fbconfigs[i], GLX_STEREO);
if (_glfwLibrary.GLX.ARB_multisample)
f->samples = getFBConfigAttrib(window, fbconfigs[i], GLX_SAMPLES);
else
f->samples = 0;
if (_glfwLibrary.GLX.ARB_framebuffer_sRGB)
f->sRGB = getFBConfigAttrib(window, fbconfigs[i], GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB);
else
f->sRGB = GL_FALSE;
f->platformID = (GLFWintptr) getFBConfigAttrib(window, fbconfigs[i], GLX_FBCONFIG_ID);
(*found)++;
}
XFree(fbconfigs);
return result;
}
EGLBoolean __initialize(EGLDisplayImpl* walkerDpy, const NativeLocalStorageContainer* nativeLocalStorageContainer, EGLint* error)
{
if (!walkerDpy || !nativeLocalStorageContainer || !error)
{
return EGL_FALSE;
}
// Create configuration list.
EGLint numberPixelFormats;
GLXFBConfig* fbConfigs = glXGetFBConfigs(walkerDpy->display_id, DefaultScreen(walkerDpy->display_id), &numberPixelFormats);
if (!fbConfigs || numberPixelFormats == 0)
{
if (fbConfigs)
{
XFree(fbConfigs);
}
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
EGLint attribute;
XVisualInfo* visualInfo;
EGLConfigImpl* lastConfig = 0;
for (EGLint currentPixelFormat = 0; currentPixelFormat < numberPixelFormats; currentPixelFormat++)
{
EGLint value;
attribute = GLX_VISUAL_ID;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &value))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
if (!value)
{
continue;
}
// No check for OpenGL.
attribute = GLX_RENDER_TYPE;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &value))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
if (!(value & GLX_RGBA_BIT))
{
continue;
}
attribute = GLX_TRANSPARENT_TYPE;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &value))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
if (value == GLX_TRANSPARENT_INDEX)
{
continue;
}
//
EGLConfigImpl* newConfig = (EGLConfigImpl*)malloc(sizeof(EGLConfigImpl));
if (!newConfig)
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
_eglInternalSetDefaultConfig(newConfig);
// Store in the same order as received.
newConfig->next = 0;
if (lastConfig != 0)
{
lastConfig->next = newConfig;
}
else
{
walkerDpy->rootConfig = newConfig;
}
lastConfig = newConfig;
//
attribute = GLX_DRAWABLE_TYPE;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &value))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
newConfig->drawToWindow = value & GLX_WINDOW_BIT ? EGL_TRUE : EGL_FALSE;
newConfig->drawToPixmap = value & GLX_PIXMAP_BIT ? EGL_TRUE : EGL_FALSE;
newConfig->drawToPBuffer = value & GLX_PBUFFER_BIT ? EGL_TRUE : EGL_FALSE;
attribute = GLX_DOUBLEBUFFER;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &newConfig->doubleBuffer))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
//
newConfig->conformant = EGL_OPENGL_BIT;
newConfig->renderableType = EGL_OPENGL_BIT;
newConfig->surfaceType = 0;
if (newConfig->drawToWindow)
{
newConfig->surfaceType |= EGL_WINDOW_BIT;
}
if (newConfig->drawToPixmap)
{
newConfig->surfaceType |= EGL_PIXMAP_BIT;
}
if (newConfig->drawToPBuffer)
{
newConfig->surfaceType |= EGL_PBUFFER_BIT;
}
newConfig->colorBufferType = EGL_RGB_BUFFER;
newConfig->configId = currentPixelFormat;
attribute = GLX_BUFFER_SIZE;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &newConfig->bufferSize))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
attribute = GLX_RED_SIZE;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &newConfig->redSize))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
attribute = GLX_GREEN_SIZE;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &newConfig->greenSize))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
attribute = GLX_BLUE_SIZE;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &newConfig->blueSize))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
attribute = GLX_ALPHA_SIZE;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &newConfig->alphaSize))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
attribute = GLX_DEPTH_SIZE;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &newConfig->depthSize))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
attribute = GLX_STENCIL_SIZE;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &newConfig->stencilSize))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
//
attribute = GLX_SAMPLE_BUFFERS;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &newConfig->sampleBuffers))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
attribute = GLX_SAMPLES;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &newConfig->samples))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
//
attribute = GLX_BIND_TO_TEXTURE_RGB_EXT;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &newConfig->bindToTextureRGB))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
newConfig->bindToTextureRGB = newConfig->bindToTextureRGB ? EGL_TRUE : EGL_FALSE;
attribute = GLX_BIND_TO_TEXTURE_RGBA_EXT;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &newConfig->bindToTextureRGBA))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
newConfig->bindToTextureRGBA = newConfig->bindToTextureRGBA ? EGL_TRUE : EGL_FALSE;
//
attribute = GLX_MAX_PBUFFER_PIXELS;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &newConfig->maxPBufferPixels))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
attribute = GLX_MAX_PBUFFER_WIDTH;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &newConfig->maxPBufferWidth))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
attribute = GLX_MAX_PBUFFER_HEIGHT;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &newConfig->maxPBufferHeight))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
//
attribute = GLX_TRANSPARENT_TYPE;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &newConfig->transparentType))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
newConfig->transparentType = newConfig->transparentType == GLX_TRANSPARENT_RGB ? EGL_TRANSPARENT_RGB : EGL_NONE;
attribute = GLX_TRANSPARENT_RED_VALUE;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &newConfig->transparentRedValue))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
attribute = GLX_TRANSPARENT_GREEN_VALUE;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &newConfig->transparentGreenValue))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
attribute = GLX_TRANSPARENT_BLUE_VALUE;
if (glXGetFBConfigAttrib(walkerDpy->display_id, fbConfigs[currentPixelFormat], attribute, &newConfig->transparentBlueValue))
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
//
visualInfo = glXGetVisualFromFBConfig(walkerDpy->display_id, fbConfigs[currentPixelFormat]);
if (!visualInfo)
{
XFree(fbConfigs);
*error = EGL_NOT_INITIALIZED;
return EGL_FALSE;
}
newConfig->nativeVisualId = visualInfo->visualid;
XFree(visualInfo);
// FIXME: Query and save more values.
}
XFree(fbConfigs);
return EGL_TRUE;
}
void
VisualInfo (GLContext* ctx)
{
int n_fbc;
GLXFBConfig* fbc;
int value, ret, i;
fbc = glXGetFBConfigs(ctx->dpy, DefaultScreen(ctx->dpy), &n_fbc);
if (fbc)
{
if (!verbose)
{
/* print table header */
fprintf(file, " +-----+-------------------------+-----------------+----------+-------------+-------+------+\n");
fprintf(file, " | | visual | color | ax dp st | accum | ms | cav |\n");
fprintf(file, " | id | tp xr cl fm db st lv xp | sz r g b a | bf th cl | r g b a | ns b | eat |\n");
fprintf(file, " +-----+-------------------------+-----------------+----------+-------------+-------+------+\n");
/* loop through all the fbcs */
for (i=0; i<n_fbc; i++)
{
/* print out the information for this fbc */
/* visual id */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_FBCONFIG_ID, &value);
if (ret != Success)
{
fprintf(file, "| ? |");
}
else
{
fprintf(file, " |% 4d | ", value);
}
/* visual type */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_DRAWABLE_TYPE, &value);
if (ret != Success)
{
fprintf(file, " ? ");
}
else
{
if (value & GLX_WINDOW_BIT)
{
if (value & GLX_PBUFFER_BIT)
{
fprintf(file, "wp ");
}
else
{
fprintf(file, "wn ");
}
}
else
{
if (value & GLX_PBUFFER_BIT)
{
fprintf(file, "pb ");
}
else if (value & GLX_PIXMAP_BIT)
{
fprintf(file, "pm ");
}
else
{
fprintf(file, " ? ");
}
}
}
/* x renderable */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_X_RENDERABLE, &value);
if (ret != Success)
{
fprintf(file, " ? ");
}
else
{
fprintf(file, value ? " y " : " n ");
}
/* class */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_X_VISUAL_TYPE, &value);
if (ret != Success)
{
fprintf(file, " ? ");
}
else
{
if (GLX_TRUE_COLOR == value)
fprintf(file, "tc ");
else if (GLX_DIRECT_COLOR == value)
fprintf(file, "dc ");
else if (GLX_PSEUDO_COLOR == value)
fprintf(file, "pc ");
else if (GLX_STATIC_COLOR == value)
fprintf(file, "sc ");
else if (GLX_GRAY_SCALE == value)
fprintf(file, "gs ");
else if (GLX_STATIC_GRAY == value)
fprintf(file, "sg ");
else if (GLX_X_VISUAL_TYPE == value)
fprintf(file, " . ");
else
fprintf(file, " ? ");
}
/* format */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_RENDER_TYPE, &value);
if (ret != Success)
{
fprintf(file, " ? ");
}
else
{
if (GLXEW_NV_float_buffer)
{
int ret2, value2;
ret2 = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_FLOAT_COMPONENTS_NV, &value2);
if (Success == ret2 && GL_TRUE == value2)
{
fprintf(file, " f ");
}
else if (value & GLX_RGBA_BIT)
fprintf(file, " i ");
else if (value & GLX_COLOR_INDEX_BIT)
fprintf(file, " c ");
else
fprintf(file, " ? ");
}
else
{
if (value & GLX_RGBA_FLOAT_ATI_BIT)
fprintf(file, " f ");
else if (value & GLX_RGBA_BIT)
fprintf(file, " i ");
else if (value & GLX_COLOR_INDEX_BIT)
fprintf(file, " c ");
else
fprintf(file, " ? ");
}
}
/* double buffer */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_DOUBLEBUFFER, &value);
fprintf(file, " %c ", Success != ret ? '?' : (value ? 'y' : '.'));
/* stereo */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_STEREO, &value);
fprintf(file, " %c ", Success != ret ? '?' : (value ? 'y' : '.'));
/* level */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_LEVEL, &value);
if (Success != ret)
{
fprintf(file, " ? ");
}
else
{
fprintf(file, "%2d ", value);
}
/* transparency */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_TRANSPARENT_TYPE, &value);
if (Success != ret)
{
fprintf(file, " ? | ");
}
else
{
if (GLX_TRANSPARENT_RGB == value)
fprintf(file, " r | ");
else if (GLX_TRANSPARENT_INDEX == value)
fprintf(file, " i | ");
else if (GLX_NONE == value)
fprintf(file, " . | ");
else
fprintf(file, " ? | ");
}
/* color size */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_BUFFER_SIZE, &value);
if (Success != ret)
{
fprintf(file, " ? ");
}
else
{
if (value)
fprintf(file, "%3d ", value);
else
fprintf(file, " . ");
}
/* red size */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_RED_SIZE, &value);
if (Success != ret)
{
fprintf(file, " ? ");
}
else
{
if (value)
fprintf(file, "%2d ", value);
else
fprintf(file, " . ");
}
/* green size */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_GREEN_SIZE, &value);
if (Success != ret)
{
fprintf(file, " ? ");
}
else
{
if (value)
fprintf(file, "%2d ", value);
else
fprintf(file, " . ");
}
/* blue size */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_BLUE_SIZE, &value);
if (Success != ret)
{
fprintf(file, " ? ");
}
else
{
if (value)
fprintf(file, "%2d ", value);
else
fprintf(file, " . ");
}
/* alpha size */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_ALPHA_SIZE, &value);
if (Success != ret)
{
fprintf(file, " ? | ");
}
else
{
if (value)
fprintf(file, "%2d | ", value);
else
fprintf(file, " . | ");
}
/* aux buffers */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_AUX_BUFFERS, &value);
if (Success != ret)
{
fprintf(file, " ? ");
}
else
{
if (value)
fprintf(file, "%2d ", value);
else
fprintf(file, " . ");
}
/* depth size */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_DEPTH_SIZE, &value);
if (Success != ret)
{
fprintf(file, " ? ");
}
else
{
if (value)
fprintf(file, "%2d ", value);
else
fprintf(file, " . ");
}
/* stencil size */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_STENCIL_SIZE, &value);
if (Success != ret)
{
fprintf(file, " ? | ");
}
else
{
if (value)
fprintf(file, "%2d | ", value);
else
fprintf(file, " . | ");
}
/* accum red size */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_ACCUM_RED_SIZE, &value);
if (Success != ret)
{
fprintf(file, " ? ");
}
else
{
if (value)
fprintf(file, "%2d ", value);
else
fprintf(file, " . ");
}
/* accum green size */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_ACCUM_GREEN_SIZE, &value);
if (Success != ret)
{
fprintf(file, " ? ");
}
else
{
if (value)
fprintf(file, "%2d ", value);
else
fprintf(file, " . ");
}
/* accum blue size */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_ACCUM_BLUE_SIZE, &value);
if (Success != ret)
{
fprintf(file, " ? ");
}
else
{
if (value)
fprintf(file, "%2d ", value);
else
fprintf(file, " . ");
}
/* accum alpha size */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_ACCUM_ALPHA_SIZE, &value);
if (Success != ret)
{
fprintf(file, " ? | ");
}
else
{
if (value)
fprintf(file, "%2d | ", value);
else
fprintf(file, " . | ");
}
/* multisample */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_SAMPLES, &value);
if (Success != ret)
{
fprintf(file, " ? ");
}
else
{
fprintf(file, "%2d ", value);
}
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_SAMPLE_BUFFERS, &value);
if (Success != ret)
{
fprintf(file, " ? | ");
}
else
{
fprintf(file, "%2d | ", value);
}
/* caveat */
ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_CONFIG_CAVEAT, &value);
if (Success != ret)
{
fprintf(file, "???? |");
}
else
{
if (GLX_NONE == value)
fprintf(file, "none |\n");
else if (GLX_SLOW_CONFIG == value)
fprintf(file, "slow |\n");
else if (GLX_NON_CONFORMANT_CONFIG == value)
fprintf(file, "ncft |\n");
else
fprintf(file, "???? |\n");
}
}
/* print table footer */
fprintf(file, " +-----+-------------------------+-----------------+----------+-------------+-------+------+\n");
fprintf(file, " | id | tp xr cl fm db st lv xp | sz r g b a | bf th cl | r g b a | ns b | eat |\n");
fprintf(file, " | | visual | color | ax dp st | accum | ms | cav |\n");
fprintf(file, " +-----+-------------------------+-----------------+----------+-------------+-------+------+\n");
}
}
}
SCISHARE int
OpenGLCmd(ClientData clientData, Tcl_Interp *interp,
int argc, CONST84 char **argv)
{
Tk_Window mainwin = (Tk_Window) clientData;
OpenGLClientData *OpenGLPtr;
Colormap cmap;
Tk_Window tkwin;
XVisualInfo temp_vi;
int tempid;
int n;
#ifndef _WIN32
int attributes[50];
int idx = 0;
#endif
if (argc < 2)
{
Tcl_AppendResult(interp, "wrong # args: should be \"",
argv[0], " pathName ?options?\"",
(char *) NULL);
return TCL_ERROR;
}
tkwin = Tk_CreateWindowFromPath(interp, mainwin, argv[1], (char *) NULL);
if (tkwin == NULL)
{
return TCL_ERROR;
}
Tk_SetClass(tkwin, "OpenGL");
/* Allocate and initialize the widget record. */
OpenGLPtr = (OpenGLClientData *) ckalloc(sizeof(OpenGLClientData));
OpenGLPtr->geometry = 0;
OpenGLPtr->cursor = 0;
OpenGLPtr->interp = interp;
OpenGLPtr->tkwin = tkwin;
OpenGLPtr->display = Tk_Display(tkwin);
OpenGLPtr->x11_win=0;
OpenGLPtr->screen_number = Tk_ScreenNumber(tkwin);
#ifndef _WIN32
OpenGLPtr->glx_win=0;
OpenGLPtr->fb_configs=glXGetFBConfigs(OpenGLPtr->display,
OpenGLPtr->screen_number,
&(OpenGLPtr->num_fb));
#else
OpenGLPtr->hDC = 0;
#endif
OpenGLPtr->vi=0;
OpenGLPtr->cx=0;
Tk_CreateEventHandler(OpenGLPtr->tkwin,
StructureNotifyMask,
OpenGLEventProc,
(ClientData) OpenGLPtr);
Tcl_CreateCommand(interp,
Tk_PathName(OpenGLPtr->tkwin),
OpenGLWidgetCmd,
(ClientData) OpenGLPtr,
(Tcl_CmdDeleteProc *)0);
if (OpenGLConfigure(interp, OpenGLPtr, argc-2, argv+2, 0) != TCL_OK)
{
return TCL_ERROR;
}
tempid = OpenGLPtr->visualid;
if (OpenGLPtr->visualid)
{
temp_vi.visualid = OpenGLPtr->visualid;
OpenGLPtr->vi =
XGetVisualInfo(OpenGLPtr->display, VisualIDMask, &temp_vi, &n);
if(!OpenGLPtr->vi || n!=1)
{
Tcl_AppendResult(interp, "Error finding visual", NULL);
return TCL_ERROR;
}
}
else
{
/*
* Pick the right visual...
*/
#ifndef _WIN32
attributes[idx++]=GLX_BUFFER_SIZE;
attributes[idx++]=OpenGLPtr->buffersize;
attributes[idx++]=GLX_LEVEL;
attributes[idx++]=OpenGLPtr->level;
if(OpenGLPtr->rgba)
attributes[idx++]=GLX_RGBA;
if(OpenGLPtr->doublebuffer)
attributes[idx++]=GLX_DOUBLEBUFFER;
if(OpenGLPtr->stereo)
attributes[idx++]=GLX_STEREO;
attributes[idx++]=GLX_AUX_BUFFERS;
attributes[idx++]=OpenGLPtr->auxbuffers;
attributes[idx++]=GLX_RED_SIZE;
attributes[idx++]=OpenGLPtr->redsize;
attributes[idx++]=GLX_GREEN_SIZE;
attributes[idx++]=OpenGLPtr->greensize;
attributes[idx++]=GLX_BLUE_SIZE;
attributes[idx++]=OpenGLPtr->bluesize;
attributes[idx++]=GLX_ALPHA_SIZE;
attributes[idx++]=OpenGLPtr->alphasize;
attributes[idx++]=GLX_DEPTH_SIZE;
attributes[idx++]=OpenGLPtr->depthsize;
attributes[idx++]=GLX_STENCIL_SIZE;
attributes[idx++]=OpenGLPtr->stencilsize;
attributes[idx++]=GLX_ACCUM_RED_SIZE;
attributes[idx++]=OpenGLPtr->accumredsize;
attributes[idx++]=GLX_ACCUM_GREEN_SIZE;
attributes[idx++]=OpenGLPtr->accumgreensize;
attributes[idx++]=GLX_ACCUM_BLUE_SIZE;
attributes[idx++]=OpenGLPtr->accumbluesize;
attributes[idx++]=GLX_ACCUM_ALPHA_SIZE;
attributes[idx++]=OpenGLPtr->accumalphasize;
attributes[idx++]=None;
OpenGLPtr->vi = glXChooseVisual(OpenGLPtr->display,
OpenGLPtr->screen_number,
attributes);
OpenGLPtr->visualid=tempid;
#else // WIN32
// I am using the *PixelFormat commands from win32 because according
// to the Windows page, we should prefer this to wgl*PixelFormatARB.
// Unfortunately, this means that the Windows code will differ
// substantially from that of other platforms. However, it has the
// advantage that we don't have to use the wglGetProc to get
// the procedure address, or test to see if the applicable extension
// is supported. WM:VI
HWND hWnd = TkWinGetHWND(Tk_WindowId(OpenGLPtr->tkwin));
// a little ugly, but we need this to be defined before pfd, and
// we need to follow C initialization rules
DWORD dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL |
(OpenGLPtr->doublebuffer ? PFD_DOUBLEBUFFER : 0) |
(OpenGLPtr->stereo ? PFD_STEREO : 0);
int iPixelFormat;
XVisualInfo xvi;
int n_ret;
PIXELFORMATDESCRIPTOR pfd =
{
sizeof(PIXELFORMATDESCRIPTOR), // size of this pfd
1, // version number
dwFlags,
PFD_TYPE_RGBA, // RGBA type
OpenGLPtr->buffersize, // color depth
OpenGLPtr->redsize, 0,
OpenGLPtr->greensize, 0,
OpenGLPtr->bluesize, 0, // color bits
OpenGLPtr->alphasize,0, // alpha buffer
OpenGLPtr->accumredsize+
OpenGLPtr->accumgreensize+
OpenGLPtr->accumbluesize,// accumulation buffer
OpenGLPtr->accumredsize,
OpenGLPtr->accumgreensize,
OpenGLPtr->accumbluesize,
OpenGLPtr->accumalphasize,// accum bits
OpenGLPtr->depthsize, // 32-bit z-buffer
OpenGLPtr->stencilsize,// no stencil buffer
OpenGLPtr->auxbuffers, // no auxiliary buffer
PFD_MAIN_PLANE, // main layer
0, // reserved
0, 0, 0 // layer masks ignored
};
iPixelFormat = ChoosePixelFormat(OpenGLPtr->hDC, &pfd);
SetPixelFormat(OpenGLPtr->hDC, iPixelFormat, &pfd);
OpenGLPtr->visualid = iPixelFormat;
OpenGLPtr->hDC = GetDC(hWnd);
xvi.screen = OpenGLPtr->screen_number;
n_ret=0;
OpenGLPtr->vi = XGetVisualInfo(OpenGLPtr->display,
VisualScreenMask, &xvi,
&n_ret);
#endif
if (!OpenGLPtr->vi)
{
Tcl_AppendResult(interp, "Error selecting visual", (char*)NULL);
return TCL_ERROR;
}
}
cmap = XCreateColormap(OpenGLPtr->display,
Tk_WindowId(Tk_MainWindow(OpenGLPtr->interp)),
OpenGLPtr->vi->visual,
AllocNone);
if(Tk_SetWindowVisual(OpenGLPtr->tkwin,
OpenGLPtr->vi->visual,
OpenGLPtr->vi->depth, cmap) != 1)
{
Tcl_AppendResult(interp, "Error setting visual for window", (char*)NULL);
return TCL_ERROR;
}
XSync(OpenGLPtr->display, False);
Tcl_SetResult(interp,Tk_PathName(OpenGLPtr->tkwin),TCL_STATIC);
return TCL_OK;
}
GLXFBConfig* GLXGraphicsystem::GetMatchingPixmapConfig(Display *curDisplay)
{
int neededMaskAttribute[] =
{
GLX_DRAWABLE_TYPE,GLX_PIXMAP_BIT,
GLX_DRAWABLE_TYPE,GLX_WINDOW_BIT,
GLX_BIND_TO_TEXTURE_TARGETS_EXT,GLX_TEXTURE_2D_BIT_EXT,
None
};
int neededValueAttribute[] =
{
GLX_BUFFER_SIZE,32,
GLX_ALPHA_SIZE,8,
GLX_BIND_TO_TEXTURE_RGBA_EXT,True,
None
};
LOG_DEBUG("GLXGraphicsystem", "Choose pixmap GL configuration");
int screen = DefaultScreen(curDisplay);
GLXFBConfig *currentFBconfigs;
int i = 0;
int j = 0;
int nConfigs = 0;
currentFBconfigs = glXGetFBConfigs(curDisplay, screen, &nConfigs);
for (i = 0; i < nConfigs; i++)
{
GLXFBConfig config = currentFBconfigs[i];
bool result = true;
/* check first all mask values */
j = 0;
while ( neededMaskAttribute[j] != None && result == true )
{
result = CheckConfigMask(curDisplay,config, neededMaskAttribute[j], neededMaskAttribute[j+1]);
j += 2;
}
/* no matching found in needed mask attribute, skip config take next */
if (result == false )
{
continue;
}
/* check all fixed values */
/* reset attribute counter */
j = 0;
/* check all fixed values */
while ( neededValueAttribute[j] != None && result == true )
{
result = CheckConfigValue(curDisplay,config, neededValueAttribute[j], neededValueAttribute[j+1]);
j += 2;
}
/* no matching found in needed fixed value attribute, skip config take next */
if (result == false )
{
continue;
}
break;
}
if (i == nConfigs)
{
LOG_ERROR("GLXGraphicsystem", "Unable to find FBconfig for texturing");
return NULL;
}
LOG_DEBUG("GLXGraphicsystem", "Done choosing GL Pixmap configuration");
return ¤tFBconfigs[i];
}
static int CreateWindowAndContext( Display* display, xcb_connection_t* connection, int default_screen, xcb_screen_t* screen, int width, int height, ae3d::WindowCreateFlags flags )
{
GLXFBConfig* fb_configs = nullptr;
int num_fb_configs = 0;
fb_configs = glXGetFBConfigs( display, default_screen, &num_fb_configs );
if (!fb_configs || num_fb_configs == 0)
{
std::cerr << "glXGetFBConfigs failed." << std::endl;
return -1;
}
/* Select first framebuffer config and query visualID */
int visualID = 0;
GLXFBConfig fb_config = fb_configs[ 0 ];
glXGetFBConfigAttrib( display, fb_config, GLX_VISUAL_ID, &visualID );
GLXContext context = glXCreateNewContext( display, fb_config, GLX_RGBA_TYPE, nullptr, True );
if (!context)
{
std::cerr << "glXCreateNewContext failed." << std::endl;
return -1;
}
/* Create XID's for colormap and window */
xcb_colormap_t colormap = xcb_generate_id( connection );
WindowGlobal::window = xcb_generate_id( connection );
WindowGlobal::windowWidth = width == 0 ? screen->width_in_pixels : width;
WindowGlobal::windowHeight = height == 0 ? screen->height_in_pixels : height;
xcb_create_colormap(
connection,
XCB_COLORMAP_ALLOC_NONE,
colormap,
screen->root,
visualID
);
const uint32_t eventmask = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_KEY_RELEASE |
XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_POINTER_MOTION;
const uint32_t valuelist[] = { eventmask, colormap, 0 };
const uint32_t valuemask = XCB_CW_EVENT_MASK | XCB_CW_COLORMAP;
xcb_create_window(
connection,
XCB_COPY_FROM_PARENT,
WindowGlobal::window,
screen->root,
0, 0,
WindowGlobal::windowWidth, WindowGlobal::windowHeight,
0,
XCB_WINDOW_CLASS_INPUT_OUTPUT,
visualID,
valuemask,
valuelist
);
xcb_map_window( connection, WindowGlobal::window );
if ((flags & ae3d::WindowCreateFlags::Fullscreen) != 0)
{
WindowGlobal::EWMHCookie = xcb_ewmh_init_atoms( WindowGlobal::connection, &WindowGlobal::EWMH );
if (!xcb_ewmh_init_atoms_replies( &WindowGlobal::EWMH, WindowGlobal::EWMHCookie, nullptr ))
{
std::cout << "Fullscreen not supported." << std::endl;
}
xcb_ewmh_request_change_wm_state( &WindowGlobal::EWMH, XDefaultScreen( display ), WindowGlobal::window,
XCB_EWMH_WM_STATE_ADD, WindowGlobal::EWMH._NET_WM_STATE_FULLSCREEN, 0,
XCB_EWMH_CLIENT_SOURCE_TYPE_NORMAL
);
xcb_ewmh_request_change_active_window( &WindowGlobal::EWMH, XDefaultScreen( display ), WindowGlobal::window,
XCB_EWMH_CLIENT_SOURCE_TYPE_NORMAL, XCB_CURRENT_TIME, XCB_WINDOW_NONE
);
xcb_generic_error_t* error;
xcb_get_window_attributes_reply_t* reply = xcb_get_window_attributes_reply( WindowGlobal::connection, xcb_get_window_attributes( WindowGlobal::connection, WindowGlobal::window ), &error );
if (!reply)
{
std::cerr << "Full screen reply failed" << std::endl;
}
}
//xcb_change_property( WindowGlobal::connection, XCB_PROP_MODE_REPLACE, WindowGlobal::window, WindowGlobal::EWMH._NET_WM_STATE, XCB_ATOM, 32, 1, &(WindowGlobal::EWMH._NET_WM_STATE_FULLSCREEN));
// End test
GLXWindow glxwindow = glXCreateWindow( display, fb_config, WindowGlobal::window, nullptr );
if (!glxwindow)
{
xcb_destroy_window( connection, WindowGlobal::window );
glXDestroyContext( display, context );
std::cerr << "glXDestroyContext failed" << std::endl;
return -1;
}
WindowGlobal::drawable = glxwindow;
if (!glXMakeContextCurrent( display, WindowGlobal::drawable, WindowGlobal::drawable, context ))
{
xcb_destroy_window( connection, WindowGlobal::window );
glXDestroyContext( display, context );
std::cerr << "glXMakeContextCurrent failed" << std::endl;
return -1;
}
return 0;
}
// Return the GLXFBConfig most closely matching the specified hints
//
static GLFWbool chooseGLXFBConfig(const _GLFWfbconfig* desired, GLXFBConfig* result)
{
GLXFBConfig* nativeConfigs;
_GLFWfbconfig* usableConfigs;
const _GLFWfbconfig* closest;
int i, nativeCount, usableCount;
const char* vendor;
GLFWbool trustWindowBit = GLFW_TRUE;
// HACK: This is a (hopefully temporary) workaround for Chromium
// (VirtualBox GL) not setting the window bit on any GLXFBConfigs
vendor = glXGetClientString(_glfw.x11.display, GLX_VENDOR);
if (strcmp(vendor, "Chromium") == 0)
trustWindowBit = GLFW_FALSE;
nativeConfigs =
glXGetFBConfigs(_glfw.x11.display, _glfw.x11.screen, &nativeCount);
if (!nativeCount)
{
_glfwInputError(GLFW_API_UNAVAILABLE, "GLX: No GLXFBConfigs returned");
return GLFW_FALSE;
}
usableConfigs = calloc(nativeCount, sizeof(_GLFWfbconfig));
usableCount = 0;
for (i = 0; i < nativeCount; i++)
{
const GLXFBConfig n = nativeConfigs[i];
_GLFWfbconfig* u = usableConfigs + usableCount;
// Only consider RGBA GLXFBConfigs
if (!(getGLXFBConfigAttrib(n, GLX_RENDER_TYPE) & GLX_RGBA_BIT))
continue;
// Only consider window GLXFBConfigs
if (!(getGLXFBConfigAttrib(n, GLX_DRAWABLE_TYPE) & GLX_WINDOW_BIT))
{
if (trustWindowBit)
continue;
}
u->redBits = getGLXFBConfigAttrib(n, GLX_RED_SIZE);
u->greenBits = getGLXFBConfigAttrib(n, GLX_GREEN_SIZE);
u->blueBits = getGLXFBConfigAttrib(n, GLX_BLUE_SIZE);
u->alphaBits = getGLXFBConfigAttrib(n, GLX_ALPHA_SIZE);
u->depthBits = getGLXFBConfigAttrib(n, GLX_DEPTH_SIZE);
u->stencilBits = getGLXFBConfigAttrib(n, GLX_STENCIL_SIZE);
u->accumRedBits = getGLXFBConfigAttrib(n, GLX_ACCUM_RED_SIZE);
u->accumGreenBits = getGLXFBConfigAttrib(n, GLX_ACCUM_GREEN_SIZE);
u->accumBlueBits = getGLXFBConfigAttrib(n, GLX_ACCUM_BLUE_SIZE);
u->accumAlphaBits = getGLXFBConfigAttrib(n, GLX_ACCUM_ALPHA_SIZE);
u->auxBuffers = getGLXFBConfigAttrib(n, GLX_AUX_BUFFERS);
if (getGLXFBConfigAttrib(n, GLX_STEREO))
u->stereo = GLFW_TRUE;
if (getGLXFBConfigAttrib(n, GLX_DOUBLEBUFFER))
u->doublebuffer = GLFW_TRUE;
if (_glfw.glx.ARB_multisample)
u->samples = getGLXFBConfigAttrib(n, GLX_SAMPLES);
if (_glfw.glx.ARB_framebuffer_sRGB || _glfw.glx.EXT_framebuffer_sRGB)
u->sRGB = getGLXFBConfigAttrib(n, GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB);
u->handle = (uintptr_t) n;
usableCount++;
}
closest = _glfwChooseFBConfig(desired, usableConfigs, usableCount);
if (closest)
*result = (GLXFBConfig) closest->handle;
XFree(nativeConfigs);
free(usableConfigs);
return closest != NULL;
}
static gboolean
get_fbconfig_for_depth (unsigned int depth,
GLXFBConfig *fbconfig_ret,
gboolean *can_mipmap_ret)
{
GLXFBConfig *fbconfigs;
int n_elements, i;
Display *dpy;
int db, stencil, alpha, mipmap, rgba, value;
int spare_cache_slot = 0;
gboolean found = FALSE;
_COGL_GET_CONTEXT (ctxt, FALSE);
/* Check if we've already got a cached config for this depth */
for (i = 0; i < COGL_WINSYS_N_CACHED_CONFIGS; i++)
if (ctxt->winsys.glx_cached_configs[i].depth == -1)
spare_cache_slot = i;
else if (ctxt->winsys.glx_cached_configs[i].depth == depth)
{
*fbconfig_ret = ctxt->winsys.glx_cached_configs[i].fb_config;
*can_mipmap_ret = ctxt->winsys.glx_cached_configs[i].can_mipmap;
return ctxt->winsys.glx_cached_configs[i].found;
}
dpy = _cogl_xlib_get_display ();
fbconfigs = glXGetFBConfigs (dpy, DefaultScreen (dpy),
&n_elements);
db = G_MAXSHORT;
stencil = G_MAXSHORT;
mipmap = 0;
rgba = 0;
for (i = 0; i < n_elements; i++)
{
XVisualInfo *vi;
int visual_depth;
vi = glXGetVisualFromFBConfig (dpy,
fbconfigs[i]);
if (vi == NULL)
continue;
visual_depth = vi->depth;
XFree (vi);
if (visual_depth != depth)
continue;
glXGetFBConfigAttrib (dpy,
fbconfigs[i],
GLX_ALPHA_SIZE,
&alpha);
glXGetFBConfigAttrib (dpy,
fbconfigs[i],
GLX_BUFFER_SIZE,
&value);
if (value != depth && (value - alpha) != depth)
continue;
value = 0;
if (depth == 32)
{
glXGetFBConfigAttrib (dpy,
fbconfigs[i],
GLX_BIND_TO_TEXTURE_RGBA_EXT,
&value);
if (value)
rgba = 1;
}
if (!value)
{
if (rgba)
continue;
glXGetFBConfigAttrib (dpy,
fbconfigs[i],
GLX_BIND_TO_TEXTURE_RGB_EXT,
&value);
if (!value)
continue;
}
glXGetFBConfigAttrib (dpy,
fbconfigs[i],
GLX_DOUBLEBUFFER,
&value);
if (value > db)
continue;
db = value;
glXGetFBConfigAttrib (dpy,
fbconfigs[i],
GLX_STENCIL_SIZE,
&value);
if (value > stencil)
continue;
stencil = value;
/* glGenerateMipmap is defined in the offscreen extension */
if (cogl_features_available (COGL_FEATURE_OFFSCREEN))
{
glXGetFBConfigAttrib (dpy,
fbconfigs[i],
GLX_BIND_TO_MIPMAP_TEXTURE_EXT,
&value);
if (value < mipmap)
continue;
mipmap = value;
}
*fbconfig_ret = fbconfigs[i];
*can_mipmap_ret = mipmap;
found = TRUE;
}
if (n_elements)
XFree (fbconfigs);
ctxt->winsys.glx_cached_configs[spare_cache_slot].depth = depth;
ctxt->winsys.glx_cached_configs[spare_cache_slot].found = found;
ctxt->winsys.glx_cached_configs[spare_cache_slot].fb_config = *fbconfig_ret;
ctxt->winsys.glx_cached_configs[spare_cache_slot].can_mipmap = mipmap;
return found;
}
static EGLint glx_populate_from_fbconfigs (PlatformDisplay *display,
EGLProxyConfig **config_list)
{
int value;
int n_configs = 0;
int current_config = 0;
EGLProxyConfig *egl_config = NULL;
GLXFBConfig glx_config;
GLXFBConfig *glx_configs = glXGetFBConfigs (display->x11_display,
display->screen, &n_configs);
EGLProxyConfig *list = (EGLProxyConfig *) calloc ((size_t)n_configs,
sizeof (EGLProxyConfig));
if (list == NULL) {
XFree (glx_configs);
return 0;
}
*config_list = list;
while (n_configs > 0) {
n_configs--;
glx_config = glx_configs[n_configs];
egl_config = list;
egl_config->platform = glx_config;
glXGetFBConfigAttrib (display->x11_display, glx_config, GLX_RENDER_TYPE,
&value);
value &= GLX_RGBA_BIT;
if (!value) {
continue;
}
glXGetFBConfigAttrib (display->x11_display, glx_config,
GLX_CONFIG_CAVEAT, &value);
if (value == GLX_NONE) {
egl_config->config_caveat = EGL_NONE;
} else if (value == GLX_SLOW_CONFIG) {
egl_config->config_caveat = EGL_SLOW_CONFIG;
} else {
egl_config->config_caveat = EGL_NON_CONFORMANT_CONFIG;
}
egl_config->renderable_type = EGL_OPENGL_BIT;
egl_config->renderable_type |= (display->is_ext_create_context_es_profile) ?
EGL_OPENGL_ES_BIT : 0;
egl_config->renderable_type |= (display->is_ext_create_context_es2_profile) ?
EGL_OPENGL_ES2_BIT | EGL_OPENGL_ES3_BIT : 0;
egl_config->conformant = egl_config->renderable_type;
glXGetFBConfigAttrib (display->x11_display, glx_config, GLX_RED_SIZE,
(int *)&egl_config->red_size);
glXGetFBConfigAttrib (display->x11_display, glx_config, GLX_GREEN_SIZE,
(int *)&egl_config->green_size);
glXGetFBConfigAttrib (display->x11_display, glx_config, GLX_BLUE_SIZE,
(int *)&egl_config->blue_size);
glXGetFBConfigAttrib (display->x11_display, glx_config, GLX_ALPHA_SIZE,
(int *)&egl_config->alpha_size);
if ((egl_config->red_size != 0) && (egl_config->green_size != 0)
&& (egl_config->blue_size != 0)) {
egl_config->color_buffer_type = EGL_RGB_BUFFER;
egl_config->luminance_size = 0;
egl_config->buffer_size = egl_config->red_size + egl_config->green_size +
egl_config->blue_size + egl_config->alpha_size;
} else if ((egl_config->red_size != 0) && (egl_config->green_size == 0)
&& (egl_config->blue_size == 0)) {
egl_config->color_buffer_type = EGL_LUMINANCE_BUFFER;
egl_config->luminance_size = egl_config->red_size;
egl_config->red_size = 0;
egl_config->buffer_size = egl_config->luminance_size +
egl_config->alpha_size;
} else {
continue; /* Skip configs with RX GX B0 */
}
egl_config->alpha_mask_size = 0;
glXGetFBConfigAttrib (display->x11_display, glx_config,
GLX_DOUBLEBUFFER, &value);
if (value != True) {
continue;
}
egl_config->config_id = current_config + 1;
glXGetFBConfigAttrib (display->x11_display, glx_config,
GLX_DEPTH_SIZE, (int *)&egl_config->depth_size);
glXGetFBConfigAttrib (display->x11_display, glx_config, GLX_LEVEL,
(int *)&egl_config->level);
glXGetFBConfigAttrib (display->x11_display, glx_config,
GLX_MAX_PBUFFER_WIDTH,
(int *)&egl_config->max_pbuffer_width);
glXGetFBConfigAttrib (display->x11_display, glx_config,
GLX_MAX_PBUFFER_HEIGHT,
(int *)&egl_config->max_pbuffer_height);
glXGetFBConfigAttrib (display->x11_display, glx_config,
GLX_MAX_PBUFFER_PIXELS,
(int *)&egl_config->max_pbuffer_pixels);
/* TODO: Implement via GLX_EXT_swap_control
*
* From GLX_EXT_swap_control specification:
* The current swap interval and implementation-dependent max swap
* interval for a particular drawable can be obtained by calling
* glXQueryDrawable with the attributes GLX_SWAP_INTERVAL_EXT and
* GLX_MAX_SWAP_INTERVAL_EXT respectively. The value returned by
* glXQueryDrawable is undefined if the drawable is not a GLXWindow
* and these attributes are given.
*/
egl_config->max_swap_interval = 1;
egl_config->min_swap_interval = 1;
glXGetFBConfigAttrib (display->x11_display, glx_config,
GLX_X_RENDERABLE, &value);
egl_config->native_renderable = (value == True) ? EGL_TRUE : EGL_FALSE;
glXGetFBConfigAttrib (display->x11_display, glx_config, GLX_VISUAL_ID,
(int *)&egl_config->native_visual_id);
egl_config->native_visual_type = EGL_NONE;
if (egl_config->native_visual_id != 0) {
glXGetFBConfigAttrib (display->x11_display, glx_config,
GLX_X_VISUAL_TYPE,
(int *)&egl_config->native_visual_type);
}
/* Sample buffers are supported only in GLX 1.4 */
if ((display->glx_minor > 1) ||
((display->glx_major == 1) && (display->glx_minor >= 4))) {
glXGetFBConfigAttrib (display->x11_display, glx_config,
GLX_SAMPLE_BUFFERS,
(int *)&egl_config->sample_buffers);
glXGetFBConfigAttrib (display->x11_display, glx_config, GLX_SAMPLES,
(int *)&egl_config->samples);
} else if (display->is_arb_multisample) {
XVisualInfo info_template;
int n_visualinfo = 0;
XVisualInfo *info = NULL;
info_template.visualid = (VisualID) egl_config->native_visual_id;
info = XGetVisualInfo (display->x11_display, VisualIDMask,
&info_template, &n_visualinfo);
if (info ) {
glXGetConfig (display->x11_display, info, GLX_SAMPLE_BUFFERS_ARB,
(int *)&egl_config->sample_buffers);
glXGetConfig (display->x11_display, info, GLX_SAMPLES_ARB,
(int *)&egl_config->samples);
XFree (info);
}
}
glXGetFBConfigAttrib (display->x11_display, glx_config,
GLX_STENCIL_SIZE, (int *)&egl_config->stencil_size);
glXGetFBConfigAttrib (display->x11_display, glx_config,
GLX_DRAWABLE_TYPE, &value);
egl_config->surface_type = 0;
egl_config->surface_type |= (value & GLX_WINDOW_BIT) ? EGL_WINDOW_BIT : 0;
egl_config->surface_type |= (value & GLX_PIXMAP_BIT) ? EGL_PIXMAP_BIT : 0;
egl_config->surface_type |= (value & GLX_PBUFFER_BIT) ? EGL_PBUFFER_BIT : 0;
egl_config->bind_to_texture_rgb = ((egl_config->renderable_type &
EGL_OPENGL_ES_BIT)
&& (egl_config->surface_type & EGL_PBUFFER_BIT)) ? EGL_TRUE : EGL_FALSE;
egl_config->bind_to_texture_rgba = ((egl_config->renderable_type &
EGL_OPENGL_ES_BIT)
&& (egl_config->surface_type & EGL_PBUFFER_BIT)) ? EGL_TRUE : EGL_FALSE;
glXGetFBConfigAttrib (display->x11_display, glx_config,
GLX_TRANSPARENT_TYPE,
&value);
if (value == GLX_TRANSPARENT_RGB) {
egl_config->transparent_type = EGL_TRANSPARENT_RGB;
glXGetFBConfigAttrib (display->x11_display, glx_config,
GLX_TRANSPARENT_RED_VALUE,
(int *)&egl_config->transparent_red_value);
glXGetFBConfigAttrib (display->x11_display, glx_config,
GLX_TRANSPARENT_GREEN_VALUE,
(int *)&egl_config->transparent_green_value);
glXGetFBConfigAttrib (display->x11_display, glx_config,
GLX_TRANSPARENT_BLUE_VALUE,
(int *)&egl_config->transparent_blue_value);
} else {
egl_config->transparent_type = EGL_NONE;
}
current_config++;
list++;
}
XFree (glx_configs);
return current_config;
}
// Return a list of available and usable framebuffer configs
//
static GLFWbool chooseFBConfig(
const _GLFWfbconfig* desired,
GLXFBConfig* result,
GLFWbool findTransparent)
{
GLXFBConfig* nativeConfigs;
_GLFWfbconfig* usableConfigs;
const _GLFWfbconfig* closest;
int i, nativeCount, usableCount;
const char* vendor;
GLFWbool trustWindowBit = GLFW_TRUE;
if ( !(_glfw.xrender.major || _glfw.xrender.minor) ) {
findTransparent = GLFW_FALSE;
}
// HACK: This is a (hopefully temporary) workaround for Chromium
// (VirtualBox GL) not setting the window bit on any GLXFBConfigs
vendor = glXGetClientString(_glfw.x11.display, GLX_VENDOR);
if (strcmp(vendor, "Chromium") == 0)
trustWindowBit = GLFW_FALSE;
nativeConfigs =
glXGetFBConfigs(_glfw.x11.display, _glfw.x11.screen, &nativeCount);
if (!nativeCount)
{
_glfwInputError(GLFW_API_UNAVAILABLE, "GLX: No GLXFBConfigs returned");
return GLFW_FALSE;
}
usableConfigs = calloc(nativeCount, sizeof(_GLFWfbconfig));
usableCount = 0;
selectionloop:
for (i = 0; i < nativeCount; i++)
{
const GLXFBConfig n = nativeConfigs[i];
_GLFWfbconfig* u = usableConfigs + usableCount;
// Only consider RGBA GLXFBConfigs
if (!(getFBConfigAttrib(n, GLX_RENDER_TYPE) & GLX_RGBA_BIT))
continue;
// Only consider window GLXFBConfigs
if (!(getFBConfigAttrib(n, GLX_DRAWABLE_TYPE) & GLX_WINDOW_BIT))
{
if (trustWindowBit)
continue;
}
if( findTransparent ) {
XVisualInfo *visualinfo;
XRenderPictFormat *pictFormat;
visualinfo = glXGetVisualFromFBConfig(_glfw.x11.display, n);
if (!visualinfo)
continue;
pictFormat = XRenderFindVisualFormat(_glfw.x11.display, visualinfo->visual);
if( !pictFormat ) {
XFree( visualinfo );
continue;
}
if( !pictFormat->direct.alphaMask ) {
XFree( visualinfo );
continue;
}
XFree( visualinfo );
}
u->redBits = getFBConfigAttrib(n, GLX_RED_SIZE);
u->greenBits = getFBConfigAttrib(n, GLX_GREEN_SIZE);
u->blueBits = getFBConfigAttrib(n, GLX_BLUE_SIZE);
u->alphaBits = getFBConfigAttrib(n, GLX_ALPHA_SIZE);
u->depthBits = getFBConfigAttrib(n, GLX_DEPTH_SIZE);
u->stencilBits = getFBConfigAttrib(n, GLX_STENCIL_SIZE);
u->accumRedBits = getFBConfigAttrib(n, GLX_ACCUM_RED_SIZE);
u->accumGreenBits = getFBConfigAttrib(n, GLX_ACCUM_GREEN_SIZE);
u->accumBlueBits = getFBConfigAttrib(n, GLX_ACCUM_BLUE_SIZE);
u->accumAlphaBits = getFBConfigAttrib(n, GLX_ACCUM_ALPHA_SIZE);
u->auxBuffers = getFBConfigAttrib(n, GLX_AUX_BUFFERS);
if (getFBConfigAttrib(n, GLX_STEREO))
u->stereo = GLFW_TRUE;
if (getFBConfigAttrib(n, GLX_DOUBLEBUFFER))
u->doublebuffer = GLFW_TRUE;
if (_glfw.glx.ARB_multisample)
u->samples = getFBConfigAttrib(n, GLX_SAMPLES);
if (_glfw.glx.ARB_framebuffer_sRGB || _glfw.glx.EXT_framebuffer_sRGB)
u->sRGB = getFBConfigAttrib(n, GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB);
u->glx = n;
usableCount++;
}
// reiterate the selection loop without looking for transparency supporting
// formats if no matchig FB configs for a transparent window were found.
if( findTransparent && !usableCount ) {
findTransparent = GLFW_FALSE;
goto selectionloop;
}
closest = _glfwChooseFBConfig(desired, usableConfigs, usableCount);
if (closest)
*result = closest->glx;
XFree(nativeConfigs);
free(usableConfigs);
return closest ? GLFW_TRUE : GLFW_FALSE;
}
static GLXFBConfig *
get_fbconfig_for_depth (guint depth)
{
GLXFBConfig *fbconfigs, *ret = NULL;
int n_elements, i, found;
Display *dpy;
int db, stencil, alpha, mipmap, rgba, value;
dpy = clutter_x11_get_default_display ();
fbconfigs = glXGetFBConfigs (dpy,
clutter_x11_get_default_screen (),
&n_elements);
db = G_MAXSHORT;
stencil = G_MAXSHORT;
mipmap = 0;
rgba = 0;
found = n_elements;
for (i = 0; i < n_elements; i++)
{
XVisualInfo *vi;
int visual_depth;
vi = glXGetVisualFromFBConfig (dpy,
fbconfigs[i]);
if (vi == NULL)
continue;
visual_depth = vi->depth;
XFree (vi);
if (visual_depth != depth)
continue;
glXGetFBConfigAttrib (dpy,
fbconfigs[i],
GLX_ALPHA_SIZE,
&alpha);
glXGetFBConfigAttrib (dpy,
fbconfigs[i],
GLX_BUFFER_SIZE,
&value);
if (value != depth && (value - alpha) != depth)
continue;
value = 0;
if (depth == 32)
{
glXGetFBConfigAttrib (dpy,
fbconfigs[i],
GLX_BIND_TO_TEXTURE_RGBA_EXT,
&value);
if (value)
rgba = 1;
}
if (!value)
{
if (rgba)
continue;
glXGetFBConfigAttrib (dpy,
fbconfigs[i],
GLX_BIND_TO_TEXTURE_RGB_EXT,
&value);
if (!value)
continue;
}
glXGetFBConfigAttrib (dpy,
fbconfigs[i],
GLX_DOUBLEBUFFER,
&value);
if (value > db)
continue;
db = value;
glXGetFBConfigAttrib (dpy,
fbconfigs[i],
GLX_STENCIL_SIZE,
&value);
if (value > stencil)
continue;
stencil = value;
found = i;
}
if (found != n_elements)
{
ret = g_malloc (sizeof (GLXFBConfig));
*ret = fbconfigs[found];
}
if (n_elements)
XFree (fbconfigs);
return ret;
}
int setup_and_run(Display *display, xcb_connection_t *connection, int default_screen, xcb_screen_t *screen)
{
int visualID = 0;
/*Query framebuffer configurations */
GLXFBConfig *fb_configs = 0;
int num_fb_configs = 0;
fb_configs = glXGetFBConfigs(display, default_screen, &num_fb_configs);
if (!fb_configs || num_fb_configs == 0)
{
fprintf(stderr, "glXGetFBConfigs failed\n");
return -1;
}
/* Select first framebuffer config and query visualID */
GLXFBConfig fb_config = fb_configs[0];
glXGetFBConfigAttrib(display, fb_config, GLX_VISUAL_ID, &visualID);
GLXContext context;
/* Create OpenGL context */
context = glXCreateNewContext(display, fb_config, GLX_RGBA_TYPE, 0, True);
if (!context)
{
fprintf(stderr, "glXCreateNewContext failed\n");
return -1;
}
/* Create XID's for colormap and window */
xcb_colormap_t colormap = xcb_generate_id(connection);
xcb_window_t window = xcb_generate_id(connection);
/* Create colormap */
xcb_create_colormap(
connection,
XCB_COLORMAP_ALLOC_NONE,
colormap,
screen->root,
visualID);
/* Create window */
uint32_t eventmask = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_KEY_PRESS;
uint32_t valuelist[] = {eventmask, colormap, 0};
uint32_t valuemask = XCB_CW_EVENT_MASK | XCB_CW_COLORMAP;
xcb_create_window(
connection,
XCB_COPY_FROM_PARENT,
window,
screen->root,
0, 0,
window_width, window_height,
0,
XCB_WINDOW_CLASS_INPUT_OUTPUT,
visualID,
valuemask,
valuelist);
/* NOTE: window must be mapped before glXMakeContextCurrent */
xcb_map_window(connection, window);
/* Create GLX window */
GLXDrawable drawable = 0;
GLXWindow glxwindow = glXCreateWindow(display, fb_config, window, 0);
if (!glxwindow)
{
xcb_destroy_window(connection, window);
glXDestroyContext(display, context);
fprintf(stderr, "glXCreateWindow failed\n");
return -1;
}
drawable = glxwindow;
/* make OpenGL context current */
#if 1
if (!glXMakeContextCurrent(display, drawable, drawable, context))
{
xcb_destroy_window(connection, window);
glXDestroyContext(display, context);
fprintf(stderr, "glXMakeContextCurrent failed\n");
return -1;
}
#else
if (!glXMakeCurrent(display, drawable, context))
{
xcb_destroy_window(connection, window);
glXDestroyContext(display, context);
fprintf(stderr, "glXMakeContextCurrent failed\n");
return -1;
}
#endif
/* run main loop */
int retval = main_loop (display, connection, screen, window, drawable);
/* Cleanup */
glXDestroyWindow(display, glxwindow);
xcb_destroy_window(connection, window);
glXDestroyContext(display, context);
return retval;
}
// make a list of the best configs for windows by depth
bool SceneOpenGL::initDrawableConfigs()
{
int cnt;
GLXFBConfig *fbconfigs = glXGetFBConfigs(display(), DefaultScreen(display()), &cnt);
for (int i = 0; i <= 32; i++) {
int back, stencil, depth, caveat, alpha, mipmap, rgba;
back = INT_MAX;
stencil = INT_MAX;
depth = INT_MAX;
caveat = INT_MAX;
mipmap = 0;
rgba = 0;
fbcdrawableinfo[ i ].fbconfig = NULL;
fbcdrawableinfo[ i ].bind_texture_format = 0;
fbcdrawableinfo[ i ].texture_targets = 0;
fbcdrawableinfo[ i ].y_inverted = 0;
fbcdrawableinfo[ i ].mipmap = 0;
for (int j = 0; j < cnt; j++) {
XVisualInfo *vi;
int visual_depth;
vi = glXGetVisualFromFBConfig(display(), fbconfigs[ j ]);
if (vi == NULL)
continue;
visual_depth = vi->depth;
XFree(vi);
if (visual_depth != i)
continue;
int value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_ALPHA_SIZE, &alpha);
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_BUFFER_SIZE, &value);
if (value != i && (value - alpha) != i)
continue;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_RENDER_TYPE, &value);
if (!(value & GLX_RGBA_BIT))
continue;
value = 0;
if (i == 32) {
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_BIND_TO_TEXTURE_RGBA_EXT, &value);
if (value) {
// TODO I think this should be set only after the config passes all tests
rgba = 1;
fbcdrawableinfo[ i ].bind_texture_format = GLX_TEXTURE_FORMAT_RGBA_EXT;
}
}
if (!value) {
if (rgba)
continue;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_BIND_TO_TEXTURE_RGB_EXT, &value);
if (!value)
continue;
fbcdrawableinfo[ i ].bind_texture_format = GLX_TEXTURE_FORMAT_RGB_EXT;
}
int back_value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_DOUBLEBUFFER, &back_value);
if (back_value > back)
continue;
int stencil_value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_STENCIL_SIZE, &stencil_value);
if (stencil_value > stencil)
continue;
int depth_value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_DEPTH_SIZE, &depth_value);
if (depth_value > depth)
continue;
int mipmap_value = -1;
if (GLTexture::framebufferObjectSupported()) {
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_BIND_TO_MIPMAP_TEXTURE_EXT, &mipmap_value);
if (mipmap_value < mipmap)
continue;
}
int caveat_value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_CONFIG_CAVEAT, &caveat_value);
if (caveat_value > caveat)
continue;
// ok, config passed all tests, it's the best one so far
fbcdrawableinfo[ i ].fbconfig = fbconfigs[ j ];
caveat = caveat_value;
back = back_value;
stencil = stencil_value;
depth = depth_value;
mipmap = mipmap_value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_BIND_TO_TEXTURE_TARGETS_EXT, &value);
fbcdrawableinfo[ i ].texture_targets = value;
glXGetFBConfigAttrib(display(), fbconfigs[ j ],
GLX_Y_INVERTED_EXT, &value);
fbcdrawableinfo[ i ].y_inverted = value;
fbcdrawableinfo[ i ].mipmap = mipmap;
}
}
if (cnt)
XFree(fbconfigs);
if (fbcdrawableinfo[ DefaultDepth(display(), DefaultScreen(display()))].fbconfig == NULL) {
kError(1212) << "Couldn't find framebuffer configuration for default depth!";
return false;
}
if (fbcdrawableinfo[ 32 ].fbconfig == NULL) {
kError(1212) << "Couldn't find framebuffer configuration for depth 32 (no ARGB GLX visual)!";
return false;
}
return true;
}
