/**
* Choose a simple FB Config.
*/
static GLXFBConfig *
choose_fb_config(Display *dpy, int scrnum)
{
int fbAttribSingle[] = {
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_DOUBLEBUFFER, False,
None };
int fbAttribDouble[] = {
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_DOUBLEBUFFER, True,
None };
GLXFBConfig *configs;
int nConfigs;
configs = glXChooseFBConfig(dpy, scrnum, fbAttribSingle, &nConfigs);
if (!configs)
configs = glXChooseFBConfig(dpy, scrnum, fbAttribDouble, &nConfigs);
return configs;
}
bool GlxBackend::initFbConfig()
{
const int attribs[] = {
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_ALPHA_SIZE, 0,
GLX_DEPTH_SIZE, 0,
GLX_STENCIL_SIZE, 0,
GLX_CONFIG_CAVEAT, GLX_NONE,
GLX_DOUBLEBUFFER, true,
0
};
// Try to find a double buffered configuration
int count = 0;
GLXFBConfig *configs = glXChooseFBConfig(display(), DefaultScreen(display()), attribs, &count);
if (count > 0) {
fbconfig = configs[0];
XFree(configs);
}
if (fbconfig == NULL) {
qCritical() << "Failed to find a usable framebuffer configuration";
return false;
}
return true;
}
static Window createWindow(Display *dpy, int width, int height) {
GLXFBConfig *fbc;
XVisualInfo *vi;
Colormap cmap;
XSetWindowAttributes swa;
GLXContext cx;
XEvent event;
int nElements;
int attr[] = { GLX_DOUBLEBUFFER, True, None };
fbc = glXChooseFBConfig(dpy, DefaultScreen(dpy), attr, &nElements);
vi = glXGetVisualFromFBConfig(dpy, fbc[0]);
cx = glXCreateNewContext(dpy, fbc[0], GLX_RGBA_TYPE, 0, GL_FALSE);
cmap = XCreateColormap(dpy, RootWindow(dpy, vi->screen), vi->visual, AllocNone);
swa.colormap = cmap;
swa.border_pixel = 0;
swa.event_mask = 0;
Window win = XCreateWindow(dpy, RootWindow(dpy, vi->screen), 0, 0, width, height, 0, vi->depth, InputOutput, vi->visual, CWBorderPixel | CWColormap | CWEventMask, &swa);
XSelectInput(dpy, win, StructureNotifyMask | KeyPressMask | KeyReleaseMask);
XMapWindow(dpy, win);
XIfEvent(dpy, &event, waitMapNotify, (char *)win);
XMoveWindow(dpy, win, 100, 100);
XIfEvent(dpy, &event, waitConfigureNotify, (char *)win);
glXMakeCurrent(dpy, win, cx);
return win;
}
int createPixmapForTexture(GLXContextType *glxContext, GLuint texture, uint32_t width, uint32_t height, Pixmap *pixmap, GLXPixmap *glxPixmap)
{
int i;
if (!glxContext || !texture || !width || !height || !pixmap || !glxPixmap)
return -1;
Display *x11Display = glxContext->x11Display;
// query/choose config/attributes for GLXPixmap/Pixmap
const int pixmapAttr[] = { GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
GLX_TEXTURE_FORMAT_EXT, GLX_TEXTURE_FORMAT_RGB_EXT,
GL_NONE};
const int fbConfigAttr[] = { GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT,
GLX_BIND_TO_TEXTURE_TARGETS_EXT, GLX_TEXTURE_2D_BIT_EXT,
GLX_BIND_TO_TEXTURE_RGB_EXT, GL_TRUE,
GLX_Y_INVERTED_EXT, GL_TRUE,
GL_NONE};
int numFbConfigs;
GLXFBConfig *fbConfig = glXChooseFBConfig(x11Display, DefaultScreen(x11Display), fbConfigAttr, &numFbConfigs);
ASSERT(fbConfig && numFbConfigs);
int depth = XDefaultDepth(x11Display, DefaultScreen(x11Display));
*pixmap = XCreatePixmap(x11Display, DEFAULT_ROOT_WINDOW(x11Display), width, height, depth);
ASSERT(*pixmap);
*glxPixmap = glXCreatePixmap(x11Display, *fbConfig, *pixmap, pixmapAttr);
ASSERT(*glxPixmap);
glBindTexture(GL_TEXTURE_2D, texture);
glXBindTexImageEXT_func(x11Display, *glxPixmap, GLX_FRONT_LEFT_EXT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
ASSERT_GL_ERROR();
return 0;
}
static GLXFBConfig select_fb_config(struct vo *vo, const int *attribs, int flags)
{
int fbcount;
GLXFBConfig *fbc = glXChooseFBConfig(vo->x11->display, vo->x11->screen,
attribs, &fbcount);
if (!fbc)
return NULL;
// The list in fbc is sorted (so that the first element is the best).
GLXFBConfig fbconfig = fbcount > 0 ? fbc[0] : NULL;
if (flags & VOFLAG_ALPHA) {
for (int n = 0; n < fbcount; n++) {
XVisualInfo *v = glXGetVisualFromFBConfig(vo->x11->display, fbc[n]);
if (v) {
bool is_rgba = vo_x11_is_rgba_visual(v);
XFree(v);
if (is_rgba) {
fbconfig = fbc[n];
break;
}
}
}
}
XFree(fbc);
return fbconfig;
}
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);
}
/* static */
bool
wxGLCanvasX11::InitXVisualInfo(const int *attribList,
GLXFBConfig **pFBC,
XVisualInfo **pXVisual)
{
int data[512];
if ( !ConvertWXAttrsToGL(attribList, data, WXSIZEOF(data)) )
return false;
Display * const dpy = wxGetX11Display();
if ( GetGLXVersion() >= 13 )
{
int returned;
*pFBC = glXChooseFBConfig(dpy, DefaultScreen(dpy), data, &returned);
if ( *pFBC )
{
*pXVisual = glXGetVisualFromFBConfig(wxGetX11Display(), **pFBC);
if ( !*pXVisual )
{
XFree(*pFBC);
*pFBC = NULL;
}
}
}
else // GLX <= 1.2
{
*pFBC = NULL;
*pXVisual = glXChooseVisual(dpy, DefaultScreen(dpy), data);
}
return *pXVisual != NULL;
}
int
main(int argc, char **argv)
{
Display *dpy;
Window win;
XVisualInfo *visinfo;
int i;
int (*old_handler)(Display *, XErrorEvent *);
GLXContext ctx;
int attrib[] = {
GLX_RGBA,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_DOUBLEBUFFER,
None
};
GLXFBConfig config, *configs;
int nconfigs;
for(i = 1; i < argc; ++i) {
if (!strcmp(argv[i], "-auto"))
piglit_automatic = 1;
else
fprintf(stderr, "Unknown option: %s\n", argv[i]);
}
dpy = XOpenDisplay(NULL);
if (dpy == NULL) {
fprintf(stderr, "couldn't open display\n");
piglit_report_result(PIGLIT_FAIL);
}
visinfo = piglit_get_glx_visual(dpy);
win = piglit_get_glx_window(dpy, visinfo);
configs = glXChooseFBConfig(dpy, DefaultScreen(dpy),
attrib, &nconfigs);
assert(nconfigs > 0);
config = configs[0];
XFree(configs);
old_handler = XSetErrorHandler(expect_badvalue);
ctx = glXCreateNewContext(dpy, config, 0x1010, NULL, True);
XSync(dpy, 0);
XSetErrorHandler(old_handler);
if (!found_badvalue) {
printf("Failed to get BadValue from glXCreateContext().\n");
piglit_report_result(PIGLIT_FAIL);
}
if (ctx != NULL) {
glXMakeCurrent(dpy, win, ctx);
piglit_report_result(PIGLIT_PASS);
} else {
piglit_report_result(PIGLIT_SKIP);
}
return 0;
}
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;
}
xcb_visualtype_t *
ephyr_glamor_get_visual(void)
{
xcb_screen_t *xscreen =
xcb_aux_get_screen(XGetXCBConnection(dpy), DefaultScreen(dpy));
int attribs[] = {
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_DOUBLEBUFFER, 1,
None
};
int event_base = 0, error_base = 0, nelements;
GLXFBConfig *fbconfigs;
if (!glXQueryExtension (dpy, &error_base, &event_base))
FatalError("Couldn't find GLX extension\n");
fbconfigs = glXChooseFBConfig(dpy, DefaultScreen(dpy), attribs, &nelements);
if (!nelements)
FatalError("Couldn't choose an FBConfig\n");
fb_config = fbconfigs[0];
free(fbconfigs);
visual_info = glXGetVisualFromFBConfig(dpy, fb_config);
if (visual_info == NULL)
FatalError("Couldn't get RGB visual\n");
return xcb_aux_find_visual_by_id(xscreen, visual_info->visualid);
}
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
}
void XCompositeGLXClientBufferIntegration::bindTextureToBuffer(struct ::wl_resource *buffer)
{
XCompositeBuffer *compositorBuffer = XCompositeBuffer::fromResource(buffer);
Pixmap pixmap = XCompositeNameWindowPixmap(mDisplay, compositorBuffer->window());
QVector<int> glxConfigSpec = qglx_buildSpec();
int numberOfConfigs;
GLXFBConfig *configs = glXChooseFBConfig(mDisplay,mScreen,glxConfigSpec.constData(),&numberOfConfigs);
QVector<int> attribList;
attribList.append(GLX_TEXTURE_FORMAT_EXT);
attribList.append(GLX_TEXTURE_FORMAT_RGB_EXT);
attribList.append(GLX_TEXTURE_TARGET_EXT);
attribList.append(GLX_TEXTURE_2D_EXT);
attribList.append(0);
GLXPixmap glxPixmap = glXCreatePixmap(mDisplay,*configs,pixmap,attribList.constData());
uint inverted = 0;
glXQueryDrawable(mDisplay, glxPixmap, GLX_Y_INVERTED_EXT,&inverted);
compositorBuffer->setInvertedY(!inverted);
XFree(configs);
m_glxBindTexImageEXT(mDisplay,glxPixmap,GLX_FRONT_EXT, 0);
//Do we need to change the api so that we do bind and release in the painevent?
//The specification states that when deleting the texture the color buffer is deleted
// m_glxReleaseTexImageEXT(mDisplay,glxPixmap,GLX_FRONT_EXT);
}
GLXFBConfig GLXGLSupport::getFBConfigFromContext(::GLXContext context)
{
GLXFBConfig fbConfig = 0;
if (GLXEW_VERSION_1_3)
{
int fbConfigAttrib[] = {
GLX_FBCONFIG_ID, 0,
None
};
GLXFBConfig *fbConfigs;
int nElements = 0;
glXQueryContext(mGLDisplay, context, GLX_FBCONFIG_ID, &fbConfigAttrib[1]);
fbConfigs = glXChooseFBConfig(mGLDisplay, DefaultScreen(mGLDisplay), fbConfigAttrib, &nElements);
if (nElements)
{
fbConfig = fbConfigs[0];
XFree(fbConfigs);
}
}
else if (GLXEW_EXT_import_context && GLXEW_SGIX_fbconfig)
{
VisualID visualid;
if (glXQueryContextInfoEXT(mGLDisplay, context, GLX_VISUAL_ID, (int*)&visualid))
{
fbConfig = getFBConfigFromVisualID(visualid);
}
}
return fbConfig;
}
bool QGLPixelBuffer::hasOpenGLPbuffers()
{
bool ret = qt_resolve_pbuffer_extensions();
if (!ret)
return false;
int attribs[40];
int num_configs = 0;
qt_format_to_attrib_list(QGLFormat::defaultFormat(), attribs);
GLXFBConfig *configs = glXChooseFBConfig(X11->display, X11->defaultScreen, attribs, &num_configs);
GLXPbuffer pbuf = 0;
GLXContext ctx = 0;
if (configs && num_configs) {
int pb_attribs[] = {GLX_PBUFFER_WIDTH, 128, GLX_PBUFFER_HEIGHT, 128, XNone};
pbuf = glXCreatePbuffer(X11->display, configs[0], pb_attribs);
ctx = glXCreateNewContext(X11->display, configs[0], GLX_RGBA_TYPE, 0, true);
XFree(configs);
glXDestroyContext(X11->display, ctx);
glXDestroyPbuffer(X11->display, pbuf);
}
return pbuf && ctx;
}
GlfQGLPlatformDebugContextPrivate::GlfQGLPlatformDebugContextPrivate(
int majorVersion, int minorVersion,
bool coreProfile, bool directRendering)
: _dpy(NULL)
, _ctx(NULL)
{
Display *shareDisplay = glXGetCurrentDisplay();
GLXContext shareContext = glXGetCurrentContext();
int fbConfigId = 0;
glXQueryContext(shareDisplay, shareContext, GLX_FBCONFIG_ID, &fbConfigId);
int screen = 0;
glXQueryContext(shareDisplay, shareContext, GLX_SCREEN, &screen);
int configSpec[] = {
GLX_FBCONFIG_ID, fbConfigId,
None,
};
GLXFBConfig *configs = NULL;
int configCount = 0;
configs = glXChooseFBConfig(shareDisplay, screen, configSpec, &configCount);
if (not TF_VERIFY(configCount > 0)) {
return;
}
const int profile =
coreProfile
? GLX_CONTEXT_CORE_PROFILE_BIT_ARB
: GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
int attribs[] = {
GLX_CONTEXT_MAJOR_VERSION_ARB, majorVersion,
GLX_CONTEXT_MINOR_VERSION_ARB, minorVersion,
GLX_CONTEXT_PROFILE_MASK_ARB, profile,
GLX_CONTEXT_FLAGS_ARB, GLX_CONTEXT_DEBUG_BIT_ARB,
0,
};
// Extension entry points must be resolved at run-time.
PFNGLXCREATECONTEXTATTRIBSARBPROC createContextAttribs =
(PFNGLXCREATECONTEXTATTRIBSARBPROC)
glXGetProcAddressARB((const GLubyte*)"glXCreateContextAttribsARB");
// Create a GL context with the requested capabilities.
if (createContextAttribs) {
_ctx = (*createContextAttribs)(shareDisplay, configs[0],
shareContext, directRendering,
attribs);
} else {
TF_WARN("Unable to create GL debug context.");
XVisualInfo *vis = glXGetVisualFromFBConfig(shareDisplay, configs[0]);
_ctx = glXCreateContext(shareDisplay, vis,
shareContext, directRendering);
}
if (not TF_VERIFY(_ctx)) {
return;
}
_dpy = shareDisplay;
}
static GLXFBConfig* _gfx_x11_get_config(
Screen* screen,
const GFXColorDepth* depth,
int backBuffer)
{
/* Create buffer attribute array */
int bufferAttr[] = {
GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_DOUBLEBUFFER, backBuffer ? True : False,
GLX_RED_SIZE, depth->redBits,
GLX_GREEN_SIZE, depth->greenBits,
GLX_BLUE_SIZE, depth->blueBits,
None
};
/* Get config from screen */
int buffElements;
return glXChooseFBConfig(
_gfx_x11.display,
XScreenNumberOfScreen(screen),
bufferAttr,
&buffElements
);
}
static GLXFBConfig select_fb_config(struct vo *vo, const int *attribs, int flags)
{
int fbcount;
GLXFBConfig *fbc = glXChooseFBConfig(vo->x11->display, vo->x11->screen,
attribs, &fbcount);
if (!fbc)
return NULL;
// The list in fbc is sorted (so that the first element is the best).
GLXFBConfig fbconfig = fbc[0];
if (flags & VOFLAG_ALPHA) {
for (int n = 0; n < fbcount; n++) {
XVisualInfo *v = glXGetVisualFromFBConfig(vo->x11->display, fbc[n]);
if (!v)
continue;
// This is a heuristic at best. Note that normal 8 bit Visuals use
// a depth of 24, even if the pixels are padded to 32 bit. If the
// depth is higher than 24, the remaining bits must be alpha.
// Note: vinfo->bits_per_rgb appears to be useless (is always 8).
unsigned long mask = v->depth == 32 ?
(unsigned long)-1 : (1 << (unsigned long)v->depth) - 1;
if (mask & ~(v->red_mask | v->green_mask | v->blue_mask)) {
fbconfig = fbc[n];
break;
}
}
}
XFree(fbc);
return fbconfig;
}
Visual *
createVisual(bool doubleBuffer, unsigned samples, Profile profile) {
GlxVisual *visual = new GlxVisual(profile);
Attributes<int> attribs;
attribs.add(GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT);
attribs.add(GLX_RENDER_TYPE, GLX_RGBA_BIT);
attribs.add(GLX_RED_SIZE, 1);
attribs.add(GLX_GREEN_SIZE, 1);
attribs.add(GLX_BLUE_SIZE, 1);
attribs.add(GLX_ALPHA_SIZE, 1);
attribs.add(GLX_DOUBLEBUFFER, doubleBuffer ? GL_TRUE : GL_FALSE);
attribs.add(GLX_DEPTH_SIZE, 1);
attribs.add(GLX_STENCIL_SIZE, 1);
if (samples > 1) {
attribs.add(GLX_SAMPLE_BUFFERS, 1);
attribs.add(GLX_SAMPLES_ARB, samples);
}
attribs.end();
int num_configs = 0;
GLXFBConfig * fbconfigs;
fbconfigs = glXChooseFBConfig(display, screen, attribs, &num_configs);
if (!num_configs || !fbconfigs) {
return NULL;
}
visual->fbconfig = fbconfigs[0];
assert(visual->fbconfig);
visual->visinfo = glXGetVisualFromFBConfig(display, visual->fbconfig);
assert(visual->visinfo);
return visual;
}
void X11Window::internalChooseGLVisual()
{
#ifdef OPENGL_ES
static int attrList[] = {
#if OPENGL_ES==2
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
#else
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT,
#endif
EGL_RED_SIZE, 4,
EGL_GREEN_SIZE, 4,
EGL_BLUE_SIZE, 4,
EGL_ALPHA_SIZE, 4,
EGL_NONE
};
EGLint numConfig;
XVisualInfo visTemplate;
int numVisuals;
if(!eglChooseConfig(m_eglDisplay, attrList, &m_eglConfig, 1, &numConfig))
g_logger.fatal("Failed to choose EGL config");
if(numConfig != 1)
g_logger.warning("Didn't got the exact EGL config");
EGLint vid;
if(!eglGetConfigAttrib(m_eglDisplay, m_eglConfig, EGL_NATIVE_VISUAL_ID, &vid))
g_logger.fatal("Unable to get visual EGL visual id");
memset(&visTemplate, 0, sizeof(visTemplate));
visTemplate.visualid = vid;
m_visual = XGetVisualInfo(m_display, VisualIDMask, &visTemplate, &numVisuals);
if(!m_visual)
g_logger.fatal("Couldn't choose RGBA, double buffered visual");
m_rootWindow = DefaultRootWindow(m_display);
#else
static int attrList[] = {
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_DOUBLEBUFFER, True,
GLX_RED_SIZE, 8,
GLX_GREEN_SIZE, 8,
GLX_BLUE_SIZE, 8,
GLX_ALPHA_SIZE, 8,
None
};
int nelements;
m_fbConfig = glXChooseFBConfig(m_display, m_screen, attrList, &nelements);
if(!m_fbConfig)
g_logger.fatal("Couldn't choose RGBA, double buffered fbconfig");
m_visual = glXGetVisualFromFBConfig(m_display, *m_fbConfig);
if(!m_visual)
g_logger.fatal("Couldn't choose RGBA, double buffered visual");
m_rootWindow = RootWindow(m_display, m_visual->screen);
#endif
}
bool OglContext::initSharingContext()
{
int fb_attributes[] = {
GLX_SAMPLES_ARB, MAX_MULTISAMPLE_SAMPLES,
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT,
GLX_RED_SIZE, 8,
GLX_GREEN_SIZE, 8,
GLX_BLUE_SIZE, 8,
GLX_ALPHA_SIZE, 8,
GLX_DEPTH_SIZE, 16,
GLX_DOUBLEBUFFER, 0,
GLX_SAMPLE_BUFFERS_ARB, 1,
0
};
int num_configs = 0;
while (num_configs == 0 && fb_attributes[1] >= 0) {
configs = glXChooseFBConfig(window, DefaultScreen(window), fb_attributes, &num_configs);
fb_attributes[1] -= 2;
}
if (configs == NULL || num_configs == 0) {
msSetError(MS_OGLERR, "glXChooseFBConfig could not find any configs. Likely your video card or drivers are not supported. glError: %d", "OglContext::init()", glGetError());
return false;
}
sharingContext = glXCreateNewContext(window, *configs, GLX_RGBA_TYPE, NULL, 1);
if (sharingContext == NULL) {
msSetError(MS_OGLERR, "glXCreateNewContext failed. glError: %d", "OglContext::initSharingContext()", glGetError());
return false;
}
return true;
}
/* Java->C glue code:
* Java package: com.sun.opengl.impl.x11.glx.GLX
* Java method: java.nio.LongBuffer glXChooseFBConfig(long dpy, int screen, java.nio.IntBuffer attribList, java.nio.IntBuffer nitems)
* C function: GLXFBConfig * glXChooseFBConfig(Display * dpy, int screen, const int * attribList, int * nitems);
*/
JNIEXPORT jobject JNICALL
Java_com_sun_opengl_impl_x11_glx_GLX_glXChooseFBConfigCopied1__JILjava_lang_Object_2ILjava_lang_Object_2I(JNIEnv *env, jclass _unused, jlong dpy, jint screen, jobject attribList, jint attribList_byte_offset, jobject nitems, jint nitems_byte_offset) {
int * _ptr2 = NULL;
int * _ptr3 = NULL;
GLXFBConfig * _res;
int count;
if (attribList != NULL) {
_ptr2 = (int *) (((char*) (*env)->GetPrimitiveArrayCritical(env, attribList, NULL)) + attribList_byte_offset);
}
if (nitems != NULL) {
_ptr3 = (int *) (((char*) (*env)->GetPrimitiveArrayCritical(env, nitems, NULL)) + nitems_byte_offset);
}
_res = glXChooseFBConfig((Display *) (intptr_t) dpy, (int) screen, (int *) _ptr2, (int *) _ptr3);
count = _ptr3[0];
if (attribList != NULL) {
(*env)->ReleasePrimitiveArrayCritical(env, attribList, _ptr2, 0);
}
if (nitems != NULL) {
(*env)->ReleasePrimitiveArrayCritical(env, nitems, _ptr3, 0);
}
if (_res == NULL) return NULL;
_initClazzAccess(env);
jobject jbyteSource = (*env)->NewDirectByteBuffer(env, _res, count * sizeof(GLXFBConfig));
jobject jbyteCopy = (*env)->CallStaticObjectMethod(env,
clazzInternalBufferUtil, cstrInternalBufferUtil, jbyteSource);
// FIXME: remove reference/gc jbyteSource ??
XFree(_res);
return jbyteCopy;
}
std::unique_ptr<GLContextGLX> GLContextGLX::createPbufferContext(PlatformDisplay& platformDisplay, GLXContext sharingContext)
{
static const int fbConfigAttributes[] = {
GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT,
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_ALPHA_SIZE, 1,
GLX_DOUBLEBUFFER, GL_FALSE,
0
};
int returnedElements;
Display* display = downcast<PlatformDisplayX11>(platformDisplay).native();
XUniquePtr<GLXFBConfig> configs(glXChooseFBConfig(display, 0, fbConfigAttributes, &returnedElements));
if (!returnedElements)
return nullptr;
// We will be rendering to a texture, so our pbuffer does not need to be large.
static const int pbufferAttributes[] = { GLX_PBUFFER_WIDTH, 1, GLX_PBUFFER_HEIGHT, 1, 0 };
XUniqueGLXPbuffer pbuffer(glXCreatePbuffer(display, configs.get()[0], pbufferAttributes));
if (!pbuffer)
return nullptr;
XUniqueGLXContext context(glXCreateNewContext(display, configs.get()[0], GLX_RGBA_TYPE, sharingContext, GL_TRUE));
if (!context)
return nullptr;
return std::unique_ptr<GLContextGLX>(new GLContextGLX(platformDisplay, WTFMove(context), WTFMove(pbuffer)));
}
HeadlessDisplay::HeadlessDisplay() {
#if MBGL_USE_CGL
// TODO: test if OpenGL 4.1 with GL_ARB_ES2_compatibility is supported
// If it is, use kCGLOGLPVersion_3_2_Core and enable that extension.
CGLPixelFormatAttribute attributes[] = {
kCGLPFAOpenGLProfile,
static_cast<CGLPixelFormatAttribute>(kCGLOGLPVersion_Legacy),
kCGLPFAAccelerated,
static_cast<CGLPixelFormatAttribute>(0)
};
GLint num;
CGLError error = CGLChoosePixelFormat(attributes, &pixelFormat, &num);
if (error != kCGLNoError) {
throw std::runtime_error(std::string("Error choosing pixel format:") + CGLErrorString(error) + "\n");
return;
}
if (num <= 0) {
throw std::runtime_error("No pixel formats found.");
return;
}
#endif
#if MBGL_USE_GLX
if (!XInitThreads()) {
throw std::runtime_error("Failed to XInitThreads.");
}
xDisplay = XOpenDisplay(nullptr);
if (xDisplay == nullptr) {
throw std::runtime_error("Failed to open X display.");
}
const char *extensions = reinterpret_cast<const char *>(glXQueryServerString(xDisplay, DefaultScreen(xDisplay), GLX_EXTENSIONS));
if (!extensions) {
throw std::runtime_error("Cannot read GLX extensions.");
}
if (!strstr(extensions,"GLX_SGIX_fbconfig")) {
throw std::runtime_error("Extension GLX_SGIX_fbconfig was not found.");
}
if (!strstr(extensions, "GLX_SGIX_pbuffer")) {
throw std::runtime_error("Cannot find glXCreateContextAttribsARB.");
}
// We're creating a dummy pbuffer anyway that we're not using.
static int pixelFormat[] = {
GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT,
None
};
int configs = 0;
fbConfigs = glXChooseFBConfig(xDisplay, DefaultScreen(xDisplay), pixelFormat, &configs);
if (fbConfigs == nullptr) {
throw std::runtime_error("Failed to glXChooseFBConfig.");
}
if (configs <= 0) {
throw std::runtime_error("No Framebuffer configurations.");
}
#endif
}
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];
}
JNIEXPORT jlong JNICALL Java_org_lwjgl_opengl_GLX13_nglXChooseFBConfig(JNIEnv *__env, jclass clazz, jlong displayAddress, jint screen, jlong attrib_listAddress, jlong nelementsAddress, jlong __functionAddress) {
Display *display = (Display *)(intptr_t)displayAddress;
const int *attrib_list = (const int *)(intptr_t)attrib_listAddress;
int *nelements = (int *)(intptr_t)nelementsAddress;
glXChooseFBConfigPROC glXChooseFBConfig = (glXChooseFBConfigPROC)(intptr_t)__functionAddress;
UNUSED_PARAMS(__env, clazz)
return (jlong)(intptr_t)glXChooseFBConfig(display, screen, attrib_list, nelements);
}
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;
}
void glx_init(int scr, int w, int h, int radius, float sigma) {
int i;
configs = glXChooseFBConfig(display, scr, pixmap_config, &i);
vis = glXGetVisualFromFBConfig(display, configs[0]);
ctx = glXCreateContext(display, vis, NULL, True);
glXBindTexImageEXT_f = (PFNGLXBINDTEXIMAGEEXTPROC)glXGetProcAddress(
(GLubyte *)"glXBindTexImageEXT");
if (glXBindTexImageEXT_f == NULL) {
errx(EXIT_FAILURE, "Failed to load extension glXBindTexImageEXT.\n");
}
glXReleaseTexImageEXT_f = (PFNGLXRELEASETEXIMAGEEXTPROC)glXGetProcAddress(
(GLubyte *)"glXReleaseTexImageEXT");
if (glXReleaseTexImageEXT_f == NULL) {
errx(EXIT_FAILURE, "Failed to load extension glXReleaseTexImageEXT.\n");
}
tmp = XCreatePixmap(display, RootWindow(display, vis->screen), w, h,
vis->depth);
glx_tmp = glXCreatePixmap(display, configs[0], tmp, pixmap_attribs);
glXMakeCurrent(display, glx_tmp, ctx);
tmp1 = XCreatePixmap(display, RootWindow(display, vis->screen), w, h,
vis->depth);
glx_tmp1 = glXCreatePixmap(display, configs[0], tmp1, pixmap_attribs);
v_shader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(v_shader, 1, &VERT_SHADER, NULL);
glCompileShader(v_shader);
glGetShaderiv(v_shader, GL_COMPILE_STATUS, &i);
#if DEBUG_GL
printf("V Shader: %d\n", i);
printShaderInfoLog(v_shader);
#endif
f_shader = glCreateShader(GL_FRAGMENT_SHADER);
char *fragment_shader = generate_fragment_shader(radius, sigma);
GLchar const *files[] = {fragment_shader};
glShaderSource(f_shader, 1, files, NULL);
free(fragment_shader);
glCompileShader(f_shader);
glGetShaderiv(f_shader, GL_COMPILE_STATUS, &i);
#if DEBUG_GL
printf("F Shader: %d\n", i);
printShaderInfoLog(f_shader);
#endif
shader_prog = glCreateProgram();
glAttachShader(shader_prog, v_shader);
glAttachShader(shader_prog, f_shader);
glLinkProgram(shader_prog);
glGetShaderiv(f_shader, GL_LINK_STATUS, &i);
#if DEBUG_GL
printf("Program: %d\n", i);
printShaderInfoLog(f_shader);
printProgramInfoLog(shader_prog);
#endif
}
static bool gfx_ctx_init(void)
{
if (g_inited)
return false;
static const int visual_attribs[] = {
GLX_X_RENDERABLE , True,
GLX_DRAWABLE_TYPE , GLX_WINDOW_BIT,
GLX_RENDER_TYPE , GLX_RGBA_BIT,
GLX_DOUBLEBUFFER , True,
GLX_RED_SIZE , 8,
GLX_GREEN_SIZE , 8,
GLX_BLUE_SIZE , 8,
GLX_ALPHA_SIZE , 8,
GLX_DEPTH_SIZE , 0,
GLX_STENCIL_SIZE , 0,
None
};
GLXFBConfig *fbcs = NULL;
g_quit = 0;
init_lut();
g_dpy = XOpenDisplay(NULL);
if (!g_dpy)
goto error;
// GLX 1.3+ required.
int major, minor;
glXQueryVersion(g_dpy, &major, &minor);
if (major < 1 || (major == 1 && minor < 3))
goto error;
int nelements;
fbcs = glXChooseFBConfig(g_dpy, DefaultScreen(g_dpy),
visual_attribs, &nelements);
if (!fbcs)
goto error;
if (!nelements)
{
XFree(fbcs);
goto error;
}
g_fbc = fbcs[0];
XFree(fbcs);
return true;
error:
gfx_ctx_destroy();
return false;
}
XVisualInfo *MFRenderer_GetVisualInfo()
{
XVisualInfo *visualInfo = NULL;
if(!glXQueryExtension(xdisplay, NULL, NULL))
{
MFDebug_Error("GLX extension not available");
return NULL;
}
int glXMajor, glXMinor;
if(!glXQueryVersion(xdisplay, &glXMajor, &glXMinor) || (glXMajor == 1 && glXMinor < 3))
{
MFDebug_Error(MFStr("Unable to open display, need GLX V1, and at least version 1.3 (Have version %d.%d)", glXMajor, glXMinor));
return NULL;
}
// Try and obtain a suitable FBconfig, try for double buffering first
int numConfigs;
fbConfigs = glXChooseFBConfig(xdisplay, screen, glAttrsDouble, &numConfigs);
if(numConfigs == 0)
{
fbConfigs = glXChooseFBConfig(xdisplay, screen, glAttrsSingle, &numConfigs);
if(numConfigs == 0)
{
MFDebug_Error("Unable to obtain a suitable glX FBConfig");
return NULL;
}
}
if((visualInfo = glXGetVisualFromFBConfig(xdisplay, fbConfigs[0])) == NULL)
{
MFDebug_Error("Unable to obtain a visualInfo structure for the associated FBConfig");
return NULL;
}
if(visualInfo->depth < 16)
{
MFDebug_Error("Need at least a 16 bit screen!");
return NULL;
}
return visualInfo;
}
void* wxGLCanvas::ChooseGLFBC(int *attribList)
{
int data[512];
GetGLAttribListFromWX( attribList, data );
attribList = (int*) data;
int returned;
return glXChooseFBConfig( GDK_DISPLAY(), DefaultScreen(GDK_DISPLAY()),
attribList, &returned );
}