static GLboolean
dri_create_buffer(__DRIscreen * sPriv,
__DRIdrawable * dPriv,
const struct gl_config * visual, GLboolean isPixmap)
{
struct dri_drawable *drawable = NULL;
struct gl_framebuffer *fb;
struct dri_swrast_renderbuffer *frontrb, *backrb;
TRACE;
(void) sPriv;
(void) isPixmap;
drawable = CALLOC_STRUCT(dri_drawable);
if (drawable == NULL)
goto drawable_fail;
dPriv->driverPrivate = drawable;
drawable->dPriv = dPriv;
drawable->row = malloc(SWRAST_MAX_WIDTH * 4);
if (drawable->row == NULL)
goto drawable_fail;
fb = &drawable->Base;
/* basic framebuffer setup */
_mesa_initialize_window_framebuffer(fb, visual);
/* add front renderbuffer */
frontrb = swrast_new_renderbuffer(visual, dPriv, GL_TRUE);
_mesa_add_renderbuffer(fb, BUFFER_FRONT_LEFT, &frontrb->Base.Base);
/* add back renderbuffer */
if (visual->doubleBufferMode) {
backrb = swrast_new_renderbuffer(visual, dPriv, GL_FALSE);
_mesa_add_renderbuffer(fb, BUFFER_BACK_LEFT, &backrb->Base.Base);
}
/* add software renderbuffers */
_swrast_add_soft_renderbuffers(fb,
GL_FALSE, /* color */
visual->haveDepthBuffer,
visual->haveStencilBuffer,
visual->haveAccumBuffer,
GL_FALSE, /* alpha */
GL_FALSE /* aux bufs */);
return GL_TRUE;
drawable_fail:
if (drawable)
free(drawable->row);
free(drawable);
return GL_FALSE;
}
static GLboolean
nouveau_create_buffer(__DRIscreen *dri_screen,
__DRIdrawable *drawable,
const struct gl_config *visual,
GLboolean is_pixmap)
{
struct gl_renderbuffer *rb;
struct gl_framebuffer *fb;
GLenum color_format;
if (is_pixmap)
return GL_FALSE; /* not implemented */
if (visual->redBits == 5)
color_format = GL_RGB5;
else if (visual->alphaBits == 0)
color_format = GL_RGB8;
else
color_format = GL_RGBA8;
fb = nouveau_framebuffer_dri_new(visual);
if (!fb)
return GL_FALSE;
/* Front buffer. */
rb = nouveau_renderbuffer_dri_new(color_format, drawable);
_mesa_add_renderbuffer(fb, BUFFER_FRONT_LEFT, rb);
/* Back buffer */
if (visual->doubleBufferMode) {
rb = nouveau_renderbuffer_dri_new(color_format, drawable);
_mesa_add_renderbuffer(fb, BUFFER_BACK_LEFT, rb);
}
/* Depth/stencil buffer. */
if (visual->depthBits == 24 && visual->stencilBits == 8) {
rb = nouveau_renderbuffer_dri_new(GL_DEPTH24_STENCIL8_EXT, drawable);
_mesa_add_renderbuffer(fb, BUFFER_DEPTH, rb);
_mesa_add_renderbuffer(fb, BUFFER_STENCIL, rb);
} else if (visual->depthBits == 24) {
rb = nouveau_renderbuffer_dri_new(GL_DEPTH_COMPONENT24, drawable);
_mesa_add_renderbuffer(fb, BUFFER_DEPTH, rb);
} else if (visual->depthBits == 16) {
rb = nouveau_renderbuffer_dri_new(GL_DEPTH_COMPONENT16, drawable);
_mesa_add_renderbuffer(fb, BUFFER_DEPTH, rb);
}
/* Software renderbuffers. */
_swrast_add_soft_renderbuffers(fb, GL_FALSE, GL_FALSE, GL_FALSE,
visual->accumRedBits > 0,
GL_FALSE, GL_FALSE);
drawable->driverPrivate = fb;
return GL_TRUE;
}
/**
* This is called when we need to set up GL rendering to a new X window.
*/
static GLboolean
intelCreateBuffer(__DRIscreen * driScrnPriv,
__DRIdrawable * driDrawPriv,
const struct gl_config * mesaVis, GLboolean isPixmap)
{
struct intel_renderbuffer *rb;
struct intel_screen *screen = (struct intel_screen*) driScrnPriv->driverPrivate;
gl_format rgbFormat;
unsigned num_samples = intel_quantize_num_samples(screen, mesaVis->samples);
struct gl_framebuffer *fb;
if (isPixmap)
return false;
fb = CALLOC_STRUCT(gl_framebuffer);
if (!fb)
return false;
_mesa_initialize_window_framebuffer(fb, mesaVis);
if (mesaVis->redBits == 5)
rgbFormat = MESA_FORMAT_RGB565;
else if (mesaVis->sRGBCapable)
rgbFormat = MESA_FORMAT_SARGB8;
else if (mesaVis->alphaBits == 0)
rgbFormat = MESA_FORMAT_XRGB8888;
else
rgbFormat = MESA_FORMAT_ARGB8888;
/* setup the hardware-based renderbuffers */
rb = intel_create_renderbuffer(rgbFormat, num_samples);
_mesa_add_renderbuffer(fb, BUFFER_FRONT_LEFT, &rb->Base.Base);
if (mesaVis->doubleBufferMode) {
rb = intel_create_renderbuffer(rgbFormat, num_samples);
_mesa_add_renderbuffer(fb, BUFFER_BACK_LEFT, &rb->Base.Base);
}
/*
* Assert here that the gl_config has an expected depth/stencil bit
* combination: one of d24/s8, d16/s0, d0/s0. (See intelInitScreen2(),
* which constructs the advertised configs.)
*/
if (mesaVis->depthBits == 24) {
assert(mesaVis->stencilBits == 8);
if (screen->hw_has_separate_stencil) {
rb = intel_create_private_renderbuffer(MESA_FORMAT_X8_Z24,
num_samples);
_mesa_add_renderbuffer(fb, BUFFER_DEPTH, &rb->Base.Base);
rb = intel_create_private_renderbuffer(MESA_FORMAT_S8,
num_samples);
_mesa_add_renderbuffer(fb, BUFFER_STENCIL, &rb->Base.Base);
} else {
/*
* Use combined depth/stencil. Note that the renderbuffer is
* attached to two attachment points.
*/
rb = intel_create_private_renderbuffer(MESA_FORMAT_S8_Z24,
num_samples);
_mesa_add_renderbuffer(fb, BUFFER_DEPTH, &rb->Base.Base);
_mesa_add_renderbuffer(fb, BUFFER_STENCIL, &rb->Base.Base);
}
}
else if (mesaVis->depthBits == 16) {
assert(mesaVis->stencilBits == 0);
rb = intel_create_private_renderbuffer(MESA_FORMAT_Z16,
num_samples);
_mesa_add_renderbuffer(fb, BUFFER_DEPTH, &rb->Base.Base);
}
else {
assert(mesaVis->depthBits == 0);
assert(mesaVis->stencilBits == 0);
}
/* now add any/all software-based renderbuffers we may need */
_swrast_add_soft_renderbuffers(fb,
false, /* never sw color */
false, /* never sw depth */
false, /* never sw stencil */
mesaVis->accumRedBits > 0,
false, /* never sw alpha */
false /* never sw aux */ );
driDrawPriv->driverPrivate = fb;
return true;
}
/**
* New in Mesa 3.5
*
* Create context and specify size of ancillary buffers.
*/
GLAPI OSMesaContext GLAPIENTRY
OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits,
GLint accumBits, OSMesaContext sharelist )
{
OSMesaContext osmesa;
struct dd_function_table functions;
GLint rind, gind, bind, aind;
GLint redBits = 0, greenBits = 0, blueBits = 0, alphaBits =0;
rind = gind = bind = aind = 0;
if (format==OSMESA_RGBA) {
redBits = CHAN_BITS;
greenBits = CHAN_BITS;
blueBits = CHAN_BITS;
alphaBits = CHAN_BITS;
rind = 0;
gind = 1;
bind = 2;
aind = 3;
}
else if (format==OSMESA_BGRA) {
redBits = CHAN_BITS;
greenBits = CHAN_BITS;
blueBits = CHAN_BITS;
alphaBits = CHAN_BITS;
bind = 0;
gind = 1;
rind = 2;
aind = 3;
}
else if (format==OSMESA_ARGB) {
redBits = CHAN_BITS;
greenBits = CHAN_BITS;
blueBits = CHAN_BITS;
alphaBits = CHAN_BITS;
aind = 0;
rind = 1;
gind = 2;
bind = 3;
}
else if (format==OSMESA_RGB) {
redBits = CHAN_BITS;
greenBits = CHAN_BITS;
blueBits = CHAN_BITS;
alphaBits = 0;
rind = 0;
gind = 1;
bind = 2;
}
else if (format==OSMESA_BGR) {
redBits = CHAN_BITS;
greenBits = CHAN_BITS;
blueBits = CHAN_BITS;
alphaBits = 0;
rind = 2;
gind = 1;
bind = 0;
}
#if CHAN_TYPE == GL_UNSIGNED_BYTE
else if (format==OSMESA_RGB_565) {
redBits = 5;
greenBits = 6;
blueBits = 5;
alphaBits = 0;
rind = 0; /* not used */
gind = 0;
bind = 0;
}
#endif
else {
return NULL;
}
osmesa = (OSMesaContext) CALLOC_STRUCT(osmesa_context);
if (osmesa) {
osmesa->gl_visual = _mesa_create_visual( GL_FALSE, /* double buffer */
GL_FALSE, /* stereo */
redBits,
greenBits,
blueBits,
alphaBits,
depthBits,
stencilBits,
accumBits,
accumBits,
accumBits,
alphaBits ? accumBits : 0,
1 /* num samples */
);
if (!osmesa->gl_visual) {
free(osmesa);
return NULL;
}
/* Initialize device driver function table */
_mesa_init_driver_functions(&functions);
/* override with our functions */
functions.GetString = get_string;
functions.UpdateState = osmesa_update_state;
functions.GetBufferSize = NULL;
if (!_mesa_initialize_context(&osmesa->mesa,
API_OPENGL_COMPAT,
osmesa->gl_visual,
sharelist ? &sharelist->mesa
: (struct gl_context *) NULL,
&functions)) {
_mesa_destroy_visual( osmesa->gl_visual );
free(osmesa);
return NULL;
}
_mesa_enable_sw_extensions(&(osmesa->mesa));
_mesa_enable_1_3_extensions(&(osmesa->mesa));
_mesa_enable_1_4_extensions(&(osmesa->mesa));
_mesa_enable_1_5_extensions(&(osmesa->mesa));
_mesa_enable_2_0_extensions(&(osmesa->mesa));
_mesa_enable_2_1_extensions(&(osmesa->mesa));
osmesa->gl_buffer = _mesa_create_framebuffer(osmesa->gl_visual);
if (!osmesa->gl_buffer) {
_mesa_destroy_visual( osmesa->gl_visual );
_mesa_free_context_data( &osmesa->mesa );
free(osmesa);
return NULL;
}
/* Create depth/stencil/accum buffers. We'll create the color
* buffer later in OSMesaMakeCurrent().
*/
_swrast_add_soft_renderbuffers(osmesa->gl_buffer,
GL_FALSE, /* color */
osmesa->gl_visual->haveDepthBuffer,
osmesa->gl_visual->haveStencilBuffer,
osmesa->gl_visual->haveAccumBuffer,
GL_FALSE, /* alpha */
GL_FALSE /* aux */ );
osmesa->format = format;
osmesa->userRowLength = 0;
osmesa->yup = GL_TRUE;
osmesa->rInd = rind;
osmesa->gInd = gind;
osmesa->bInd = bind;
osmesa->aInd = aind;
_mesa_meta_init(&osmesa->mesa);
/* Initialize the software rasterizer and helper modules. */
{
struct gl_context *ctx = &osmesa->mesa;
SWcontext *swrast;
TNLcontext *tnl;
if (!_swrast_CreateContext( ctx ) ||
!_vbo_CreateContext( ctx ) ||
!_tnl_CreateContext( ctx ) ||
!_swsetup_CreateContext( ctx )) {
_mesa_destroy_visual(osmesa->gl_visual);
_mesa_free_context_data(ctx);
free(osmesa);
return NULL;
}
_swsetup_Wakeup( ctx );
/* use default TCL pipeline */
tnl = TNL_CONTEXT(ctx);
tnl->Driver.RunPipeline = _tnl_run_pipeline;
ctx->Driver.MapRenderbuffer = osmesa_MapRenderbuffer;
ctx->Driver.UnmapRenderbuffer = osmesa_UnmapRenderbuffer;
/* Extend the software rasterizer with our optimized line and triangle
* drawing functions.
*/
swrast = SWRAST_CONTEXT( ctx );
swrast->choose_line = osmesa_choose_line;
swrast->choose_triangle = osmesa_choose_triangle;
}
}
return osmesa;
}
/**
* Create the Mesa framebuffer and renderbuffers for a given window/drawable.
*
* \todo This function (and its interface) will need to be updated to support
* pbuffers.
*/
static GLboolean
radeonCreateBuffer( __DRIscreen *driScrnPriv,
__DRIdrawable *driDrawPriv,
const struct gl_config *mesaVis,
GLboolean isPixmap )
{
radeonScreenPtr screen = (radeonScreenPtr) driScrnPriv->driverPrivate;
const GLboolean swDepth = GL_FALSE;
const GLboolean swAlpha = GL_FALSE;
const GLboolean swAccum = mesaVis->accumRedBits > 0;
const GLboolean swStencil = mesaVis->stencilBits > 0 &&
mesaVis->depthBits != 24;
mesa_format rgbFormat;
struct radeon_framebuffer *rfb;
if (isPixmap)
return GL_FALSE; /* not implemented */
rfb = CALLOC_STRUCT(radeon_framebuffer);
if (!rfb)
return GL_FALSE;
_mesa_initialize_window_framebuffer(&rfb->base, mesaVis);
if (mesaVis->redBits == 5)
rgbFormat = _mesa_little_endian() ? MESA_FORMAT_B5G6R5_UNORM : MESA_FORMAT_R5G6B5_UNORM;
else if (mesaVis->alphaBits == 0)
rgbFormat = _mesa_little_endian() ? MESA_FORMAT_B8G8R8X8_UNORM : MESA_FORMAT_X8R8G8B8_UNORM;
else
rgbFormat = _mesa_little_endian() ? MESA_FORMAT_B8G8R8A8_UNORM : MESA_FORMAT_A8R8G8B8_UNORM;
/* front color renderbuffer */
rfb->color_rb[0] = radeon_create_renderbuffer(rgbFormat, driDrawPriv);
_mesa_add_renderbuffer(&rfb->base, BUFFER_FRONT_LEFT, &rfb->color_rb[0]->base.Base);
rfb->color_rb[0]->has_surface = 1;
/* back color renderbuffer */
if (mesaVis->doubleBufferMode) {
rfb->color_rb[1] = radeon_create_renderbuffer(rgbFormat, driDrawPriv);
_mesa_add_renderbuffer(&rfb->base, BUFFER_BACK_LEFT, &rfb->color_rb[1]->base.Base);
rfb->color_rb[1]->has_surface = 1;
}
if (mesaVis->depthBits == 24) {
if (mesaVis->stencilBits == 8) {
struct radeon_renderbuffer *depthStencilRb =
radeon_create_renderbuffer(MESA_FORMAT_Z24_UNORM_S8_UINT, driDrawPriv);
_mesa_add_renderbuffer(&rfb->base, BUFFER_DEPTH, &depthStencilRb->base.Base);
_mesa_add_renderbuffer(&rfb->base, BUFFER_STENCIL, &depthStencilRb->base.Base);
depthStencilRb->has_surface = screen->depthHasSurface;
} else {
/* depth renderbuffer */
struct radeon_renderbuffer *depth =
radeon_create_renderbuffer(MESA_FORMAT_Z24_UNORM_X8_UINT, driDrawPriv);
_mesa_add_renderbuffer(&rfb->base, BUFFER_DEPTH, &depth->base.Base);
depth->has_surface = screen->depthHasSurface;
}
} else if (mesaVis->depthBits == 16) {
/* just 16-bit depth buffer, no hw stencil */
struct radeon_renderbuffer *depth =
radeon_create_renderbuffer(MESA_FORMAT_Z_UNORM16, driDrawPriv);
_mesa_add_renderbuffer(&rfb->base, BUFFER_DEPTH, &depth->base.Base);
depth->has_surface = screen->depthHasSurface;
}
_swrast_add_soft_renderbuffers(&rfb->base,
GL_FALSE, /* color */
swDepth,
swStencil,
swAccum,
swAlpha,
GL_FALSE /* aux */);
driDrawPriv->driverPrivate = (void *) rfb;
return (driDrawPriv->driverPrivate != NULL);
}
/**
* New in Mesa 11.2
*
* Create context with attribute list.
*/
GLAPI OSMesaContext GLAPIENTRY
OSMesaCreateContextAttribs(const int *attribList, OSMesaContext sharelist)
{
OSMesaContext osmesa;
struct dd_function_table functions;
GLint rind, gind, bind, aind;
GLint redBits = 0, greenBits = 0, blueBits = 0, alphaBits =0;
GLenum format = OSMESA_RGBA;
GLint depthBits = 0, stencilBits = 0, accumBits = 0;
int profile = OSMESA_COMPAT_PROFILE, version_major = 1, version_minor = 0;
gl_api api_profile = API_OPENGL_COMPAT;
int i;
for (i = 0; attribList[i]; i += 2) {
switch (attribList[i]) {
case OSMESA_FORMAT:
format = attribList[i+1];
switch (format) {
case OSMESA_COLOR_INDEX:
case OSMESA_RGBA:
case OSMESA_BGRA:
case OSMESA_ARGB:
case OSMESA_RGB:
case OSMESA_BGR:
case OSMESA_RGB_565:
/* legal */
break;
default:
return NULL;
}
break;
case OSMESA_DEPTH_BITS:
depthBits = attribList[i+1];
if (depthBits < 0)
return NULL;
break;
case OSMESA_STENCIL_BITS:
stencilBits = attribList[i+1];
if (stencilBits < 0)
return NULL;
break;
case OSMESA_ACCUM_BITS:
accumBits = attribList[i+1];
if (accumBits < 0)
return NULL;
break;
case OSMESA_PROFILE:
profile = attribList[i+1];
if (profile == OSMESA_COMPAT_PROFILE)
api_profile = API_OPENGL_COMPAT;
else if (profile == OSMESA_CORE_PROFILE)
api_profile = API_OPENGL_CORE;
else
return NULL;
break;
case OSMESA_CONTEXT_MAJOR_VERSION:
version_major = attribList[i+1];
if (version_major < 1)
return NULL;
break;
case OSMESA_CONTEXT_MINOR_VERSION:
version_minor = attribList[i+1];
if (version_minor < 0)
return NULL;
break;
case 0:
/* end of list */
break;
default:
fprintf(stderr, "Bad attribute in OSMesaCreateContextAttribs()\n");
return NULL;
}
}
rind = gind = bind = aind = 0;
if (format==OSMESA_RGBA) {
redBits = CHAN_BITS;
greenBits = CHAN_BITS;
blueBits = CHAN_BITS;
alphaBits = CHAN_BITS;
rind = 0;
gind = 1;
bind = 2;
aind = 3;
}
else if (format==OSMESA_BGRA) {
redBits = CHAN_BITS;
greenBits = CHAN_BITS;
blueBits = CHAN_BITS;
alphaBits = CHAN_BITS;
bind = 0;
gind = 1;
rind = 2;
aind = 3;
}
else if (format==OSMESA_ARGB) {
redBits = CHAN_BITS;
greenBits = CHAN_BITS;
blueBits = CHAN_BITS;
alphaBits = CHAN_BITS;
aind = 0;
rind = 1;
gind = 2;
bind = 3;
}
else if (format==OSMESA_RGB) {
redBits = CHAN_BITS;
greenBits = CHAN_BITS;
blueBits = CHAN_BITS;
alphaBits = 0;
rind = 0;
gind = 1;
bind = 2;
}
else if (format==OSMESA_BGR) {
redBits = CHAN_BITS;
greenBits = CHAN_BITS;
blueBits = CHAN_BITS;
alphaBits = 0;
rind = 2;
gind = 1;
bind = 0;
}
#if CHAN_TYPE == GL_UNSIGNED_BYTE
else if (format==OSMESA_RGB_565) {
redBits = 5;
greenBits = 6;
blueBits = 5;
alphaBits = 0;
rind = 0; /* not used */
gind = 0;
bind = 0;
}
#endif
else {
return NULL;
}
osmesa = (OSMesaContext) CALLOC_STRUCT(osmesa_context);
if (osmesa) {
osmesa->gl_visual = _mesa_create_visual( GL_FALSE, /* double buffer */
GL_FALSE, /* stereo */
redBits,
greenBits,
blueBits,
alphaBits,
depthBits,
stencilBits,
accumBits,
accumBits,
accumBits,
alphaBits ? accumBits : 0,
1 /* num samples */
);
if (!osmesa->gl_visual) {
free(osmesa);
return NULL;
}
/* Initialize device driver function table */
_mesa_init_driver_functions(&functions);
/* override with our functions */
functions.GetString = get_string;
functions.UpdateState = osmesa_update_state_wrapper;
if (!_mesa_initialize_context(&osmesa->mesa,
api_profile,
osmesa->gl_visual,
sharelist ? &sharelist->mesa
: (struct gl_context *) NULL,
&functions)) {
_mesa_destroy_visual( osmesa->gl_visual );
free(osmesa);
return NULL;
}
_mesa_enable_sw_extensions(&(osmesa->mesa));
osmesa->gl_buffer = _mesa_create_framebuffer(osmesa->gl_visual);
if (!osmesa->gl_buffer) {
_mesa_destroy_visual( osmesa->gl_visual );
_mesa_free_context_data( &osmesa->mesa );
free(osmesa);
return NULL;
}
/* Create depth/stencil/accum buffers. We'll create the color
* buffer later in OSMesaMakeCurrent().
*/
_swrast_add_soft_renderbuffers(osmesa->gl_buffer,
GL_FALSE, /* color */
osmesa->gl_visual->haveDepthBuffer,
osmesa->gl_visual->haveStencilBuffer,
osmesa->gl_visual->haveAccumBuffer,
GL_FALSE, /* alpha */
GL_FALSE /* aux */ );
osmesa->format = format;
osmesa->userRowLength = 0;
osmesa->yup = GL_TRUE;
osmesa->rInd = rind;
osmesa->gInd = gind;
osmesa->bInd = bind;
osmesa->aInd = aind;
_mesa_meta_init(&osmesa->mesa);
/* Initialize the software rasterizer and helper modules. */
{
struct gl_context *ctx = &osmesa->mesa;
SWcontext *swrast;
TNLcontext *tnl;
if (!_swrast_CreateContext( ctx ) ||
!_vbo_CreateContext( ctx ) ||
!_tnl_CreateContext( ctx ) ||
!_swsetup_CreateContext( ctx )) {
_mesa_destroy_visual(osmesa->gl_visual);
_mesa_free_context_data(ctx);
free(osmesa);
return NULL;
}
_swsetup_Wakeup( ctx );
/* use default TCL pipeline */
tnl = TNL_CONTEXT(ctx);
tnl->Driver.RunPipeline = _tnl_run_pipeline;
ctx->Driver.MapRenderbuffer = osmesa_MapRenderbuffer;
ctx->Driver.UnmapRenderbuffer = osmesa_UnmapRenderbuffer;
ctx->Driver.GenerateMipmap = _mesa_generate_mipmap;
/* Extend the software rasterizer with our optimized line and triangle
* drawing functions.
*/
swrast = SWRAST_CONTEXT( ctx );
swrast->choose_line = osmesa_choose_line;
swrast->choose_triangle = osmesa_choose_triangle;
_mesa_compute_version(ctx);
if (ctx->Version < version_major * 10 + version_minor) {
_mesa_destroy_visual(osmesa->gl_visual);
_mesa_free_context_data(ctx);
free(osmesa);
return NULL;
}
/* Exec table initialization requires the version to be computed */
_mesa_initialize_dispatch_tables(ctx);
_mesa_initialize_vbo_vtxfmt(ctx);
}
}
return osmesa;
}
/**
* Allocate a new XMesaBuffer object which corresponds to the given drawable.
* Note that XMesaBuffer is derived from struct gl_framebuffer.
* The new XMesaBuffer will not have any size (Width=Height=0).
*
* \param d the corresponding X drawable (window or pixmap)
* \param type either WINDOW, PIXMAP or PBUFFER, describing d
* \param vis the buffer's visual
* \param cmap the window's colormap, if known.
* \return new XMesaBuffer or NULL if any problem
*/
static XMesaBuffer
create_xmesa_buffer(XMesaDrawable d, BufferType type,
XMesaVisual vis, XMesaColormap cmap)
{
XMesaBuffer b;
ASSERT(type == WINDOW || type == PIXMAP || type == PBUFFER);
b = (XMesaBuffer) CALLOC_STRUCT(xmesa_buffer);
if (!b)
return NULL;
b->display = vis->display;
b->xm_visual = vis;
b->type = type;
b->cmap = cmap;
_mesa_initialize_window_framebuffer(&b->mesa_buffer, &vis->mesa_visual);
b->mesa_buffer.Delete = xmesa_delete_framebuffer;
/*
* Front renderbuffer
*/
b->frontxrb = xmesa_new_renderbuffer(NULL, 0, vis, GL_FALSE);
if (!b->frontxrb) {
free(b);
return NULL;
}
b->frontxrb->Parent = b;
b->frontxrb->drawable = d;
b->frontxrb->pixmap = (XMesaPixmap) d;
_mesa_add_renderbuffer(&b->mesa_buffer, BUFFER_FRONT_LEFT,
&b->frontxrb->Base.Base);
/*
* Back renderbuffer
*/
if (vis->mesa_visual.doubleBufferMode) {
b->backxrb = xmesa_new_renderbuffer(NULL, 0, vis, GL_TRUE);
if (!b->backxrb) {
/* XXX free front xrb too */
free(b);
return NULL;
}
b->backxrb->Parent = b;
/* determine back buffer implementation */
b->db_mode = vis->ximage_flag ? BACK_XIMAGE : BACK_PIXMAP;
_mesa_add_renderbuffer(&b->mesa_buffer, BUFFER_BACK_LEFT,
&b->backxrb->Base.Base);
}
/*
* Other renderbuffer (depth, stencil, etc)
*/
_swrast_add_soft_renderbuffers(&b->mesa_buffer,
GL_FALSE, /* color */
vis->mesa_visual.haveDepthBuffer,
vis->mesa_visual.haveStencilBuffer,
vis->mesa_visual.haveAccumBuffer,
GL_FALSE, /* software alpha buffer */
vis->mesa_visual.numAuxBuffers > 0 );
/* GLX_EXT_texture_from_pixmap */
b->TextureTarget = 0;
b->TextureFormat = GLX_TEXTURE_FORMAT_NONE_EXT;
b->TextureMipmap = 0;
/* insert buffer into linked list */
b->Next = XMesaBufferList;
XMesaBufferList = b;
return b;
}
BOOL sw_SetPixelFormat(HDC hdc, struct wgl_dc_data* dc_data, INT format)
{
struct sw_framebuffer* fb;
BOOL doubleBuffered;
assert(dc_data->sw_data == NULL);
/* So, someone is crazy enough to ask for sw implementation. Announce it. */
TRACE("OpenGL software implementation START!\n");
/* allocate our structure */
fb = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, FIELD_OFFSET(struct sw_framebuffer, bmi.bmiColors[3]));
if(!fb)
{
ERR("HeapAlloc FAILED!\n");
return FALSE;
}
/* Get the format index */
fb->format_index = index_from_format(dc_data, format, &doubleBuffered);
TRACE("Using format %u - double buffered: %x.\n", fb->format_index, doubleBuffered);
fb->flags = doubleBuffered ? SW_FB_DOUBLEBUFFERED : 0;
/* Set the bitmap info describing the framebuffer */
fb->bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
fb->bmi.bmiHeader.biPlanes = 1;
fb->bmi.bmiHeader.biBitCount = pixel_formats[fb->format_index].color_bits;
fb->bmi.bmiHeader.biCompression = pixel_formats[fb->format_index].bmp_compression;
fb->bmi.bmiHeader.biSizeImage = 0;
fb->bmi.bmiHeader.biXPelsPerMeter = 0;
fb->bmi.bmiHeader.biYPelsPerMeter = 0;
fb->bmi.bmiHeader.biClrUsed = 0;
fb->bmi.bmiHeader.biClrImportant = 0;
*((DWORD*)&fb->bmi.bmiColors[0]) = pixel_formats[fb->format_index].red_mask;
*((DWORD*)&fb->bmi.bmiColors[1]) = pixel_formats[fb->format_index].green_mask;
*((DWORD*)&fb->bmi.bmiColors[2]) = pixel_formats[fb->format_index].blue_mask;
/* Save the HDC */
fb->hdc = hdc;
/* Allocate the visual structure describing the format */
fb->gl_visual = _mesa_create_visual(
!!(fb->flags & SW_FB_DOUBLEBUFFERED),
GL_FALSE, /* No stereoscopic support */
pixel_formats[fb->format_index].red_bits,
pixel_formats[fb->format_index].green_bits,
pixel_formats[fb->format_index].blue_bits,
pixel_formats[fb->format_index].alpha_bits,
pixel_formats[fb->format_index].depth_bits,
pixel_formats[fb->format_index].stencil_bits,
pixel_formats[fb->format_index].accum_bits,
pixel_formats[fb->format_index].accum_bits,
pixel_formats[fb->format_index].accum_bits,
pixel_formats[fb->format_index].alpha_bits ?
pixel_formats[fb->format_index].accum_bits : 0);
if(!fb->gl_visual)
{
ERR("Failed to allocate a GL visual.\n");
HeapFree(GetProcessHeap(), 0, fb);
return FALSE;
}
/* Allocate the framebuffer structure */
fb->gl_buffer = _mesa_create_framebuffer(fb->gl_visual);
if (!fb->gl_buffer) {
ERR("Failed to allocate the mesa framebuffer structure.\n");
_mesa_destroy_visual( fb->gl_visual );
HeapFree(GetProcessHeap(), 0, fb);
return FALSE;
}
/* Add the depth/stencil/accum buffers */
_swrast_add_soft_renderbuffers(fb->gl_buffer,
GL_FALSE, /* color */
fb->gl_visual->haveDepthBuffer,
fb->gl_visual->haveStencilBuffer,
fb->gl_visual->haveAccumBuffer,
GL_FALSE, /* alpha */
GL_FALSE /* aux */ );
/* Initialize our render buffers */
sw_init_renderbuffers(fb);
/* Everything went fine */
dc_data->sw_data = fb;
return TRUE;
}
MesaSoftwareRenderer::MesaSoftwareRenderer(BGLView* view, ulong options,
BGLDispatcher* dispatcher)
: BGLRenderer(view, options, dispatcher),
fBitmap(NULL),
fDirectModeEnabled(false),
fInfo(NULL),
fInfoLocker("info locker"),
fContext(NULL),
fVisual(NULL),
fFrameBuffer(NULL),
fFrontRenderBuffer(NULL),
fBackRenderBuffer(NULL),
fColorSpace(B_NO_COLOR_SPACE)
{
CALLED();
fClearColor[BE_RCOMP] = 0;
fClearColor[BE_GCOMP] = 0;
fClearColor[BE_BCOMP] = 0;
fClearColor[BE_ACOMP] = 0;
fClearIndex = 0;
fColorSpace = BScreen(GLView()->Window()).ColorSpace();
// We force single buffering for the time being
options &= ~BGL_DOUBLE;
const GLboolean rgbFlag = ((options & BGL_INDEX) == 0);
const GLboolean alphaFlag = ((options & BGL_ALPHA) == BGL_ALPHA);
const GLboolean dblFlag = ((options & BGL_DOUBLE) == BGL_DOUBLE);
const GLboolean stereoFlag = false;
const GLint depth = (options & BGL_DEPTH) ? 16 : 0;
const GLint stencil = (options & BGL_STENCIL) ? 8 : 0;
const GLint accum = (options & BGL_ACCUM) ? 16 : 0;
const GLint red = rgbFlag ? 8 : 0;
const GLint green = rgbFlag ? 8 : 0;
const GLint blue = rgbFlag ? 8 : 0;
const GLint alpha = alphaFlag ? 8 : 0;
fOptions = options; // | BGL_INDIRECT;
struct dd_function_table functions;
fVisual = _mesa_create_visual(dblFlag, stereoFlag, red, green,
blue, alpha, depth, stencil, accum, accum, accum,
alpha ? accum : 0, 1);
// Initialize device driver function table
_mesa_init_driver_functions(&functions);
functions.GetString = _GetString;
functions.UpdateState = _UpdateState;
functions.GetBufferSize = NULL;
functions.Error = _Error;
functions.Viewport = _Viewport;
functions.Flush = _Flush;
// create core context
#if HAIKU_MESA_VER <= 708
fContext = _mesa_create_context(fVisual, NULL, &functions, this);
#else
fContext = _mesa_create_context(API_OPENGL, fVisual, NULL,
&functions, this);
#endif
if (!fContext) {
ERROR("%s: Failed to create Mesa context!\n", __func__);
_mesa_destroy_visual(fVisual);
return;
}
/* Initialize the software rasterizer and helper modules. */
_swrast_CreateContext(fContext);
_vbo_CreateContext(fContext);
_tnl_CreateContext(fContext);
_swsetup_CreateContext(fContext);
_swsetup_Wakeup(fContext);
// Use default TCL pipeline
TNL_CONTEXT(fContext)->Driver.RunPipeline = _tnl_run_pipeline;
_mesa_meta_init(fContext);
_mesa_enable_sw_extensions(fContext);
_mesa_enable_1_3_extensions(fContext);
_mesa_enable_1_4_extensions(fContext);
_mesa_enable_1_5_extensions(fContext);
_mesa_enable_2_0_extensions(fContext);
_mesa_enable_2_1_extensions(fContext);
// create core framebuffer
fFrameBuffer = (struct msr_framebuffer*)calloc(1,
sizeof(*fFrameBuffer));
if (fFrameBuffer == NULL) {
ERROR("%s: Unable to calloc GL FrameBuffer!\n", __func__);
_mesa_destroy_visual(fVisual);
return;
}
_mesa_initialize_window_framebuffer(&fFrameBuffer->base, fVisual);
// Setup front render buffer
fFrontRenderBuffer = _NewRenderBuffer(true);
if (fFrontRenderBuffer == NULL) {
ERROR("%s: FrontRenderBuffer is requested but unallocated!\n",
__func__);
_mesa_destroy_visual(fVisual);
free(fFrameBuffer);
return;
}
_mesa_add_renderbuffer(&fFrameBuffer->base, BUFFER_FRONT_LEFT,
&fFrontRenderBuffer->base);
// Setup back render buffer (if requested)
if (fVisual->doubleBufferMode) {
fBackRenderBuffer = _NewRenderBuffer(false);
if (fBackRenderBuffer == NULL) {
ERROR("%s: BackRenderBuffer is requested but unallocated!\n",
__func__);
_mesa_destroy_visual(fVisual);
free(fFrameBuffer);
return;
}
_mesa_add_renderbuffer(&fFrameBuffer->base, BUFFER_BACK_LEFT,
&fBackRenderBuffer->base);
}
#if HAIKU_MESA_VER >= 709
// New Mesa
_swrast_add_soft_renderbuffers(&fFrameBuffer->base, GL_FALSE,
fVisual->haveDepthBuffer, fVisual->haveStencilBuffer,
fVisual->haveAccumBuffer, alphaFlag, GL_FALSE);
#else
// Old Mesa
_mesa_add_soft_renderbuffers(&fFrameBuffer->base, GL_FALSE,
fVisual->haveDepthBuffer, fVisual->haveStencilBuffer,
fVisual->haveAccumBuffer, alphaFlag, GL_FALSE);
#endif
BRect bounds = view->Bounds();
fWidth = fNewWidth = (GLint)bounds.Width();
fHeight = fNewHeight = (GLint)bounds.Height();
// some stupid applications (Quake2) don't even think about calling LockGL()
// before using glGetString and its glGet*() friends...
// so make sure there is at least a valid context.
if (!_mesa_get_current_context()) {
LockGL();
// not needed, we don't have a looper yet: UnlockLooper();
}
}
