static glitz_status_t
_glitz_glx_query_formats_using_fbconfigs (glitz_glx_screen_info_t *screen_info)
{
glitz_glx_static_proc_address_list_t *glx = &screen_info->glx;
Display *display;
glitz_int_drawable_format_t format;
GLXFBConfig *fbconfigs;
int i, num_configs;
display = screen_info->display_info->display;
fbconfigs = glx->get_fbconfigs (display, screen_info->screen,
&num_configs);
if (!fbconfigs)
{
/* fbconfigs are not supported, falling back to visuals */
screen_info->glx_feature_mask &= ~GLITZ_GLX_FEATURE_FBCONFIG_MASK;
screen_info->glx_feature_mask &= ~GLITZ_GLX_FEATURE_PBUFFER_MASK;
return GLITZ_STATUS_NOT_SUPPORTED;
}
for (i = 0; i < num_configs; i++)
{
int value;
XVisualInfo* vinfo;
if ((glx->get_fbconfig_attrib (display, fbconfigs[i],
GLX_RENDER_TYPE, &value) != 0) ||
(!(value & GLX_RGBA_BIT)))
continue;
/* Stereo is not supported yet */
glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_STEREO, &value);
if (value != 0)
continue;
glx->get_fbconfig_attrib (display, fbconfigs[i],
GLX_DRAWABLE_TYPE, &value);
if (!((value & GLX_WINDOW_BIT) || (value & GLX_PBUFFER_BIT)))
continue;
vinfo = glx->get_visual_from_fbconfig (display, fbconfigs[i]);
if (vinfo)
{
format.d.depth = vinfo->depth;
XFree(vinfo);
}
format.types = 0;
if (value & GLX_WINDOW_BIT)
format.types |= GLITZ_DRAWABLE_TYPE_WINDOW_MASK;
if (value & GLX_PBUFFER_BIT)
format.types |= GLITZ_DRAWABLE_TYPE_PBUFFER_MASK;
format.d.id = 0;
format.d.color.fourcc = GLITZ_FOURCC_RGB;
glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_FBCONFIG_ID,
&value);
format.u.uval = value;
glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_RED_SIZE, &value);
format.d.color.red_size = (unsigned short) value;
glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_GREEN_SIZE,
&value);
format.d.color.green_size = (unsigned short) value;
glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_BLUE_SIZE,
&value);
format.d.color.blue_size = (unsigned short) value;
glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_ALPHA_SIZE,
&value);
format.d.color.alpha_size = (unsigned short) value;
glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_DEPTH_SIZE,
&value);
format.d.depth_size = (unsigned short) value;
glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_STENCIL_SIZE,
&value);
format.d.stencil_size = (unsigned short) value;
glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_DOUBLEBUFFER,
&value);
format.d.doublebuffer = (value)? 1: 0;
glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_Y_INVERTED_EXT,
&value);
format.d.scanline_order = (value) ?
GLITZ_PIXEL_SCANLINE_ORDER_BOTTOM_UP :
GLITZ_PIXEL_SCANLINE_ORDER_TOP_DOWN;
glx->get_fbconfig_attrib (display, fbconfigs[i], GLX_CONFIG_CAVEAT,
&value);
switch (value) {
case GLX_SLOW_VISUAL_EXT:
case GLX_NON_CONFORMANT_VISUAL_EXT:
format.caveat = 1;
break;
default:
format.caveat = 0;
break;
}
if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_MULTISAMPLE_MASK)
{
glx->get_fbconfig_attrib (display, fbconfigs[i],
GLX_SAMPLE_BUFFERS_ARB, &value);
if (value)
{
glx->get_fbconfig_attrib (display, fbconfigs[i],
GLX_SAMPLES_ARB, &value);
format.d.samples = (unsigned short) (value > 1)? value: 1;
if (format.d.samples > 1)
{
if (!(screen_info->glx_feature_mask &
GLITZ_GLX_FEATURE_PBUFFER_MULTISAMPLE_MASK))
format.types &= ~GLITZ_DRAWABLE_TYPE_PBUFFER_MASK;
}
}
else
format.d.samples = 1;
}
else
format.d.samples = 1;
_glitz_add_format (screen_info, &format);
}
if (fbconfigs)
XFree (fbconfigs);
return GLITZ_STATUS_SUCCESS;
}
static glitz_status_t
_glitz_wgl_query_formats_using_pixel_format (glitz_wgl_screen_info_t *screen_info)
{
glitz_int_drawable_format_t format;
int i, num_pixel_formats;
int question, answer;
glitz_wgl_static_proc_address_list_t *wgl = &screen_info->wgl;
question = WGL_NUMBER_PIXEL_FORMATS_ARB;
if (!wgl->get_pixel_format_attrib_iv (screen_info->root_dc, 0, 0, 1,
&question, &num_pixel_formats)) {
/* wglGetPixelFormatAttribivARB didn't work, fall back to
* DescribePixelFormat.
*/
screen_info->wgl_feature_mask &= ~GLITZ_WGL_FEATURE_PIXEL_FORMAT_MASK;
return GLITZ_STATUS_NOT_SUPPORTED;
}
for (i = 1; i <= num_pixel_formats; i++) {
format.d.id = 0;
format.types = 0;
format.d.color.fourcc = GLITZ_FOURCC_RGB;
#define ASK_QUESTION(q,a) (question=(q),wgl->get_pixel_format_attrib_iv (screen_info->root_dc, i, 0, 1, &question,(a)))
if (!ASK_QUESTION(WGL_SUPPORT_OPENGL_ARB, &answer)
|| !answer)
continue;
if (!ASK_QUESTION(WGL_PIXEL_TYPE_ARB, &answer)
|| answer != WGL_TYPE_RGBA_ARB)
continue;
if (!ASK_QUESTION(WGL_ACCELERATION_ARB, &answer))
continue;
if (answer == WGL_NO_ACCELERATION_ARB)
format.caveat = 2;
else if (answer == WGL_GENERIC_ACCELERATION_ARB)
format.caveat = 1;
else
format.caveat = 0;
/* Stereo is not supported yet */
if (!ASK_QUESTION(WGL_STEREO_ARB, &answer)
|| answer != 0)
continue;
if (!ASK_QUESTION(WGL_DRAW_TO_WINDOW_ARB, &answer))
continue;
format.types |= answer ? GLITZ_DRAWABLE_TYPE_WINDOW_MASK : 0;
if (!ASK_QUESTION(WGL_DRAW_TO_PBUFFER_ARB, &answer))
continue;
format.types |= answer ? GLITZ_DRAWABLE_TYPE_PBUFFER_MASK : 0;
if (!(format.types & (GLITZ_DRAWABLE_TYPE_WINDOW_MASK |
GLITZ_DRAWABLE_TYPE_PBUFFER_MASK)))
continue;
if (!ASK_QUESTION(WGL_RED_BITS_ARB, &answer))
continue;
format.d.color.red_size = (unsigned short) answer;
if (!ASK_QUESTION(WGL_GREEN_BITS_ARB, &answer))
continue;
format.d.color.green_size = (unsigned short) answer;
if (!ASK_QUESTION(WGL_BLUE_BITS_ARB, &answer))
continue;
format.d.color.blue_size = (unsigned short) answer;
if (!ASK_QUESTION(WGL_ALPHA_BITS_ARB, &answer))
continue;
format.d.color.alpha_size = (unsigned short) answer;
if (!ASK_QUESTION(WGL_DEPTH_BITS_ARB, &answer))
continue;
format.d.depth_size = (unsigned short) answer;
if (!ASK_QUESTION(WGL_STENCIL_BITS_ARB, &answer))
continue;
format.d.stencil_size = (unsigned short) answer;
if (!ASK_QUESTION(WGL_DOUBLE_BUFFER_ARB, &answer))
continue;
format.d.doublebuffer = (answer) ? 1: 0;
format.d.samples = 1;
if (screen_info->wgl_feature_mask & GLITZ_WGL_FEATURE_MULTISAMPLE_MASK) {
if (!ASK_QUESTION(WGL_SAMPLE_BUFFERS_ARB, &answer))
continue;
if (answer) {
if (!ASK_QUESTION(WGL_SAMPLES_ARB, &answer))
continue;
format.d.samples = (unsigned short) answer;
}
}
_glitz_add_format (screen_info, &format, i);
}
return GLITZ_STATUS_SUCCESS;
}
static void
_glitz_glx_query_formats (glitz_glx_screen_info_t *screen_info)
{
Display *display;
glitz_int_drawable_format_t format;
XVisualInfo visual_templ;
XVisualInfo *visuals;
int i, num_visuals;
display = screen_info->display_info->display;
visual_templ.screen = screen_info->screen;
visuals = XGetVisualInfo (display, VisualScreenMask,
&visual_templ, &num_visuals);
/* No pbuffers without fbconfigs */
format.types = GLITZ_DRAWABLE_TYPE_WINDOW_MASK;
format.d.id = 0;
format.d.color.fourcc = GLITZ_FOURCC_RGB;
for (i = 0; i < num_visuals; i++)
{
int value;
if ((glXGetConfig (display, &visuals[i], GLX_USE_GL, &value) != 0) ||
(value == 0))
continue;
glXGetConfig (display, &visuals[i], GLX_RGBA, &value);
if (value == 0)
continue;
/* Stereo is not supported yet */
glXGetConfig (display, &visuals[i], GLX_STEREO, &value);
if (value != 0)
continue;
format.d.depth = visuals[i].depth;
glXGetConfig (display, &visuals[i], GLX_RED_SIZE, &value);
format.d.color.red_size = (unsigned short) value;
glXGetConfig (display, &visuals[i], GLX_GREEN_SIZE, &value);
format.d.color.green_size = (unsigned short) value;
glXGetConfig (display, &visuals[i], GLX_BLUE_SIZE, &value);
format.d.color.blue_size = (unsigned short) value;
glXGetConfig (display, &visuals[i], GLX_ALPHA_SIZE, &value);
format.d.color.alpha_size = (unsigned short) value;
glXGetConfig (display, &visuals[i], GLX_DEPTH_SIZE, &value);
format.d.depth_size = (unsigned short) value;
glXGetConfig (display, &visuals[i], GLX_STENCIL_SIZE, &value);
format.d.stencil_size = (unsigned short) value;
glXGetConfig (display, &visuals[i], GLX_DOUBLEBUFFER, &value);
format.d.doublebuffer = (value) ? 1: 0;
glXGetConfig (display, &visuals[i], GLX_Y_INVERTED_EXT, &value);
format.d.scanline_order = (value) ?
GLITZ_PIXEL_SCANLINE_ORDER_BOTTOM_UP :
GLITZ_PIXEL_SCANLINE_ORDER_TOP_DOWN;
if (screen_info->glx_feature_mask &
GLITZ_GLX_FEATURE_VISUAL_RATING_MASK)
{
glXGetConfig (display, &visuals[i], GLX_VISUAL_CAVEAT_EXT, &value);
switch (value) {
case GLX_SLOW_VISUAL_EXT:
case GLX_NON_CONFORMANT_VISUAL_EXT:
format.caveat = 1;
break;
default:
format.caveat = 0;
break;
}
}
else
format.caveat = 0;
if (screen_info->glx_feature_mask & GLITZ_GLX_FEATURE_MULTISAMPLE_MASK)
{
glXGetConfig (display, &visuals[i], GLX_SAMPLE_BUFFERS_ARB,
&value);
if (value)
{
glXGetConfig (display, &visuals[i], GLX_SAMPLES_ARB, &value);
format.d.samples = (unsigned short) (value > 1)? value: 1;
}
else
format.d.samples = 1;
}
else
format.d.samples = 1;
format.u.uval = visuals[i].visualid;
_glitz_add_format (screen_info, &format);
}
if (visuals)
XFree (visuals);
}
static glitz_bool_t
_glitz_wgl_query_formats (glitz_wgl_screen_info_t *screen_info)
{
glitz_int_drawable_format_t format;
int i, num_pixel_formats;
PIXELFORMATDESCRIPTOR pfd;
pfd.nSize = sizeof (PIXELFORMATDESCRIPTOR);
pfd.nVersion = 1;
num_pixel_formats =
DescribePixelFormat (screen_info->root_dc, 1,
sizeof (PIXELFORMATDESCRIPTOR), &pfd);
if (!num_pixel_formats)
return 0;
for (i = 1; i <= num_pixel_formats; i++) {
format.d.id = 0;
format.caveat = 0;
format.types = 0;
if (!DescribePixelFormat (screen_info->root_dc, i,
sizeof (PIXELFORMATDESCRIPTOR), &pfd))
{
continue;
}
#ifdef DEBUG
printf ("Pixel format %d Flags: 0x%08x\n", i, pfd.dwFlags);
#endif
if (!((pfd.dwFlags & PFD_DRAW_TO_WINDOW) &&
(pfd.dwFlags & PFD_SUPPORT_OPENGL)))
continue;
if (pfd.iPixelType != PFD_TYPE_RGBA)
continue;
if (pfd.dwFlags & (PFD_NEED_PALETTE |
PFD_NEED_SYSTEM_PALETTE |
PFD_STEREO))
continue;
#ifndef USE_MESA
/* Can't use the Windows software implementation as glitz
* unconditionally requires OpenGL 1.2, and it's only 1.1.
*/
if (pfd.dwFlags & PFD_GENERIC_FORMAT)
continue;
#endif
format.types = GLITZ_DRAWABLE_TYPE_WINDOW_MASK;
format.d.color.red_size = pfd.cRedBits;
format.d.color.green_size = pfd.cGreenBits;
format.d.color.blue_size = pfd.cBlueBits;
format.d.color.alpha_size = pfd.cAlphaBits;
format.d.color.fourcc = GLITZ_FOURCC_RGB;
format.d.depth_size = pfd.cDepthBits;
format.d.stencil_size = pfd.cStencilBits;
format.d.doublebuffer = (pfd.dwFlags & PFD_DOUBLEBUFFER) != 0;
format.d.samples = 1;
_glitz_add_format (screen_info, &format, i);
}
return 0;
}
