/**
* Allocates a GLvisual structure and initializes it via
* _mesa_initialize_visual().
*
* \param rgbFlag GL_TRUE for RGB(A) mode, GL_FALSE for Color Index mode.
* \param dbFlag double buffering
* \param stereoFlag stereo buffer
* \param depthBits requested bits per depth buffer value. Any value in [0, 32]
* is acceptable but the actual depth type will be GLushort or GLuint as
* needed.
* \param stencilBits requested minimum bits per stencil buffer value
* \param accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits number of bits per color component in accum buffer.
* \param indexBits number of bits per pixel if \p rgbFlag is GL_FALSE
* \param redBits number of bits per color component in frame buffer for RGB(A)
* mode. We always use 8 in core Mesa though.
* \param greenBits same as above.
* \param blueBits same as above.
* \param alphaBits same as above.
* \param numSamples not really used.
*
* \return pointer to new GLvisual or NULL if requested parameters can't be
* met.
*
* \note Need to add params for level and numAuxBuffers (at least)
*/
GLvisual *
_mesa_create_visual( GLboolean rgbFlag,
GLboolean dbFlag,
GLboolean stereoFlag,
GLint redBits,
GLint greenBits,
GLint blueBits,
GLint alphaBits,
GLint indexBits,
GLint depthBits,
GLint stencilBits,
GLint accumRedBits,
GLint accumGreenBits,
GLint accumBlueBits,
GLint accumAlphaBits,
GLint numSamples )
{
GLvisual *vis = (GLvisual *) _mesa_calloc(sizeof(GLvisual));
if (vis) {
if (!_mesa_initialize_visual(vis, rgbFlag, dbFlag, stereoFlag,
redBits, greenBits, blueBits, alphaBits,
indexBits, depthBits, stencilBits,
accumRedBits, accumGreenBits,
accumBlueBits, accumAlphaBits,
numSamples)) {
_mesa_free(vis);
return NULL;
}
}
return vis;
}
int ggiMesaAttach(ggi_visual_t vis)
{
int rc;
GGIMESADPRINT_CORE("ggiMesaAttach() called\n");
rc = ggiExtensionAttach(vis, _ggiMesaID);
if (rc == 0)
{
int r, g, b, ci;
GLboolean rgb, db;
GLvisual *gl_visual;
/* We are creating the primary instance */
memset(LIBGGI_MESAEXT(vis), 0, sizeof(struct ggi_mesa_ext));
LIBGGI_MESAEXT(vis)->update_state = (void *)_ggi_error;
LIBGGI_MESAEXT(vis)->setup_driver = (void *)_ggi_error;
/* Initialize default mesa visual */
get_mode_info(vis, &r, &g, &b, &rgb, &db, &ci);
gl_visual = &(LIBGGI_MESAEXT(vis)->mesa_visual.gl_visual);
_mesa_initialize_visual(gl_visual,
rgb, db, 0 /* No stereo */,
r, g, b, 0 /* No alpha */, ci,
0 /* No depth */, 0 /* No stencil */,
0, 0, 0, 0 /* No accum */, 0);
/* Now fake an "API change" so the right libs get loaded */
changed(vis, GGI_CHG_APILIST);
}
return rc;
}
int ggiMesaExtendVisual(ggi_visual_t vis, GLboolean alpha_flag,
GLboolean stereo_flag, GLint depth_size,
GLint stencil_size, GLint accum_red_size,
GLint accum_green_size, GLint accum_blue_size,
GLint accum_alpha_size, GLint num_samples)
{
GLvisual *gl_vis = &(LIBGGI_MESAEXT(vis)->mesa_visual.gl_visual);
int r, g, b, ci;
GLboolean db, rgb;
get_mode_info(vis, &r, &g, &b, &rgb, &db, &ci);
/* Initialize the visual with the provided information */
_mesa_initialize_visual(gl_vis,
rgb, db, stereo_flag,
r, g, b, 0 /* FIXME */, ci,
depth_size, stencil_size,
accum_red_size, accum_green_size,
accum_blue_size, accum_alpha_size, 0);
/* Now fake an "API change" so the right libs get loaded. After all,
extending the visual by all these new buffers could be considered
a "mode change" which requires an "API change".
*/
changed(vis, GGI_CHG_APILIST);
return 0;
}
/*
* Create a new X/Mesa visual.
* Input: display - X11 display
* visinfo - an XVisualInfo pointer
* rgb_flag - GL_TRUE = RGB mode,
* GL_FALSE = color index mode
* alpha_flag - alpha buffer requested?
* db_flag - GL_TRUE = double-buffered,
* GL_FALSE = single buffered
* stereo_flag - stereo visual?
* ximage_flag - GL_TRUE = use an XImage for back buffer,
* GL_FALSE = use an off-screen pixmap for back buffer
* depth_size - requested bits/depth values, or zero
* stencil_size - requested bits/stencil values, or zero
* accum_red_size - requested bits/red accum values, or zero
* accum_green_size - requested bits/green accum values, or zero
* accum_blue_size - requested bits/blue accum values, or zero
* accum_alpha_size - requested bits/alpha accum values, or zero
* num_samples - number of samples/pixel if multisampling, or zero
* level - visual level, usually 0
* visualCaveat - ala the GLX extension, usually GLX_NONE
* Return; a new XMesaVisual or 0 if error.
*/
PUBLIC
XMesaVisual XMesaCreateVisual( XMesaDisplay *display,
XMesaVisualInfo visinfo,
GLboolean rgb_flag,
GLboolean alpha_flag,
GLboolean db_flag,
GLboolean stereo_flag,
GLboolean ximage_flag,
GLint depth_size,
GLint stencil_size,
GLint accum_red_size,
GLint accum_green_size,
GLint accum_blue_size,
GLint accum_alpha_size,
GLint num_samples,
GLint level,
GLint visualCaveat )
{
char *gamma;
XMesaVisual v;
GLint red_bits, green_bits, blue_bits, alpha_bits;
/* For debugging only */
if (_mesa_getenv("MESA_XSYNC")) {
/* This makes debugging X easier.
* In your debugger, set a breakpoint on _XError to stop when an
* X protocol error is generated.
*/
XSynchronize( display, 1 );
}
/* Color-index rendering not supported. */
if (!rgb_flag)
return NULL;
v = (XMesaVisual) CALLOC_STRUCT(xmesa_visual);
if (!v) {
return NULL;
}
v->display = display;
/* Save a copy of the XVisualInfo struct because the user may Xfree()
* the struct but we may need some of the information contained in it
* at a later time.
*/
v->visinfo = (XVisualInfo *) malloc(sizeof(*visinfo));
if(!v->visinfo) {
free(v);
return NULL;
}
memcpy(v->visinfo, visinfo, sizeof(*visinfo));
/* check for MESA_GAMMA environment variable */
gamma = _mesa_getenv("MESA_GAMMA");
if (gamma) {
v->RedGamma = v->GreenGamma = v->BlueGamma = 0.0;
sscanf( gamma, "%f %f %f", &v->RedGamma, &v->GreenGamma, &v->BlueGamma );
if (v->RedGamma<=0.0) v->RedGamma = 1.0;
if (v->GreenGamma<=0.0) v->GreenGamma = v->RedGamma;
if (v->BlueGamma<=0.0) v->BlueGamma = v->RedGamma;
}
else {
v->RedGamma = v->GreenGamma = v->BlueGamma = 1.0;
}
v->ximage_flag = ximage_flag;
v->mesa_visual.redMask = visinfo->red_mask;
v->mesa_visual.greenMask = visinfo->green_mask;
v->mesa_visual.blueMask = visinfo->blue_mask;
v->visualID = visinfo->visualid;
v->screen = visinfo->screen;
#if !(defined(__cplusplus) || defined(c_plusplus))
v->visualType = xmesa_convert_from_x_visual_type(visinfo->class);
#else
v->visualType = xmesa_convert_from_x_visual_type(visinfo->c_class);
#endif
v->mesa_visual.visualRating = visualCaveat;
if (alpha_flag)
v->mesa_visual.alphaBits = 8;
(void) initialize_visual_and_buffer( v, NULL, 0, 0 );
{
const int xclass = v->visualType;
if (xclass == GLX_TRUE_COLOR || xclass == GLX_DIRECT_COLOR) {
red_bits = _mesa_bitcount(GET_REDMASK(v));
green_bits = _mesa_bitcount(GET_GREENMASK(v));
blue_bits = _mesa_bitcount(GET_BLUEMASK(v));
}
else {
/* this is an approximation */
int depth;
depth = GET_VISUAL_DEPTH(v);
red_bits = depth / 3;
depth -= red_bits;
green_bits = depth / 2;
depth -= green_bits;
blue_bits = depth;
alpha_bits = 0;
assert( red_bits + green_bits + blue_bits == GET_VISUAL_DEPTH(v) );
}
alpha_bits = v->mesa_visual.alphaBits;
}
if (!_mesa_initialize_visual(&v->mesa_visual,
db_flag, stereo_flag,
red_bits, green_bits,
blue_bits, alpha_bits,
depth_size,
stencil_size,
accum_red_size, accum_green_size,
accum_blue_size, accum_alpha_size,
0)) {
FREE(v);
return NULL;
}
/* XXX minor hack */
v->mesa_visual.level = level;
return v;
}
GLFBDevVisualPtr
glFBDevCreateVisual( const struct fb_fix_screeninfo *fixInfo,
const struct fb_var_screeninfo *varInfo,
const int *attribs )
{
GLFBDevVisualPtr vis;
const int *attrib;
GLboolean dbFlag = GL_FALSE, stereoFlag = GL_FALSE;
GLint redBits = 0, greenBits = 0, blueBits = 0, alphaBits = 0;
GLint depthBits = 0, stencilBits = 0;
GLint accumRedBits = 0, accumGreenBits = 0;
GLint accumBlueBits = 0, accumAlphaBits = 0;
GLint numSamples = 0;
ASSERT(fixInfo);
ASSERT(varInfo);
vis = CALLOC_STRUCT(GLFBDevVisualRec);
if (!vis)
return NULL;
vis->fix = *fixInfo; /* struct assignment */
vis->var = *varInfo; /* struct assignment */
for (attrib = attribs; attrib && *attrib != GLFBDEV_NONE; attrib++) {
switch (*attrib) {
case GLFBDEV_DOUBLE_BUFFER:
dbFlag = GL_TRUE;
break;
case GLFBDEV_DEPTH_SIZE:
depthBits = attrib[1];
attrib++;
break;
case GLFBDEV_STENCIL_SIZE:
stencilBits = attrib[1];
attrib++;
break;
case GLFBDEV_ACCUM_SIZE:
accumRedBits = accumGreenBits = accumBlueBits = accumAlphaBits
= attrib[1];
attrib++;
break;
case GLFBDEV_LEVEL:
/* ignored for now */
break;
case GLFBDEV_MULTISAMPLE:
numSamples = attrib[1];
attrib++;
break;
case GLFBDEV_COLOR_INDEX:
/* Mesa no longer supports color-index rendering. */
default:
/* unexpected token */
free(vis);
return NULL;
}
}
redBits = varInfo->red.length;
greenBits = varInfo->green.length;
blueBits = varInfo->blue.length;
alphaBits = varInfo->transp.length;
if (fixInfo->visual == FB_VISUAL_TRUECOLOR ||
fixInfo->visual == FB_VISUAL_DIRECTCOLOR) {
if (varInfo->bits_per_pixel == 24
&& varInfo->red.offset == 16
&& varInfo->green.offset == 8
&& varInfo->blue.offset == 0) {
vis->pixelFormat = PF_B8G8R8;
}
else if (varInfo->bits_per_pixel == 32
&& varInfo->red.offset == 16
&& varInfo->green.offset == 8
&& varInfo->blue.offset == 0) {
vis->pixelFormat = PF_B8G8R8A8;
}
else if (varInfo->bits_per_pixel == 16
&& varInfo->red.offset == 11
&& varInfo->green.offset == 5
&& varInfo->blue.offset == 0) {
vis->pixelFormat = PF_B5G6R5;
}
else if (varInfo->bits_per_pixel == 16
&& varInfo->red.offset == 10
&& varInfo->green.offset == 5
&& varInfo->blue.offset == 0) {
vis->pixelFormat = PF_B5G5R5;
}
else {
_mesa_problem(NULL, "Unsupported fbdev RGB visual/bitdepth!\n");
free(vis);
return NULL;
}
}
if (!_mesa_initialize_visual(&vis->glvisual, dbFlag, stereoFlag,
redBits, greenBits, blueBits, alphaBits,
depthBits, stencilBits,
accumRedBits, accumGreenBits,
accumBlueBits, accumAlphaBits,
numSamples)) {
/* something was invalid */
free(vis);
return NULL;
}
return vis;
}
