/*
* Bind buffer b to context c and make c the current rendering context.
*/
PUBLIC
GLboolean XMesaMakeCurrent2( XMesaContext c, XMesaBuffer drawBuffer,
XMesaBuffer readBuffer )
{
if (c) {
if (!drawBuffer || !readBuffer)
return GL_FALSE; /* must specify buffers! */
if (&(c->mesa) == _mesa_get_current_context()
&& c->mesa.DrawBuffer == &drawBuffer->mesa_buffer
&& c->mesa.ReadBuffer == &readBuffer->mesa_buffer
&& XMESA_BUFFER(c->mesa.DrawBuffer)->wasCurrent) {
/* same context and buffer, do nothing */
return GL_TRUE;
}
c->xm_buffer = drawBuffer;
/* Call this periodically to detect when the user has begun using
* GL rendering from multiple threads.
*/
_glapi_check_multithread();
xmesa_check_and_update_buffer_size(c, drawBuffer);
if (readBuffer != drawBuffer)
xmesa_check_and_update_buffer_size(c, readBuffer);
_mesa_make_current(&(c->mesa),
&drawBuffer->mesa_buffer,
&readBuffer->mesa_buffer);
/*
* Must recompute and set these pixel values because colormap
* can be different for different windows.
*/
c->clearpixel = xmesa_color_to_pixel( &c->mesa,
c->clearcolor[0],
c->clearcolor[1],
c->clearcolor[2],
c->clearcolor[3],
c->xm_visual->undithered_pf);
XMesaSetForeground(c->display, drawBuffer->cleargc, c->clearpixel);
/* Solution to Stephane Rehel's problem with glXReleaseBuffersMESA(): */
drawBuffer->wasCurrent = GL_TRUE;
}
else {
/* Detach */
_mesa_make_current( NULL, NULL, NULL );
}
return GL_TRUE;
}
static boolean
st_api_make_current(struct st_api *stapi, struct st_context_iface *stctxi,
struct st_framebuffer_iface *stdrawi,
struct st_framebuffer_iface *streadi)
{
struct st_context *st = (struct st_context *) stctxi;
struct st_framebuffer *stdraw, *stread;
boolean ret;
_glapi_check_multithread();
if (st) {
/* reuse or create the draw fb */
stdraw = st_framebuffer_reuse_or_create(st,
st->ctx->WinSysDrawBuffer, stdrawi);
if (streadi != stdrawi) {
/* do the same for the read fb */
stread = st_framebuffer_reuse_or_create(st,
st->ctx->WinSysReadBuffer, streadi);
}
else {
stread = NULL;
/* reuse the draw fb for the read fb */
if (stdraw)
st_framebuffer_reference(&stread, stdraw);
}
if (stdraw && stread) {
st_framebuffer_validate(stdraw, st);
if (stread != stdraw)
st_framebuffer_validate(stread, st);
ret = _mesa_make_current(st->ctx, &stdraw->Base, &stread->Base);
st->draw_stamp = stdraw->stamp - 1;
st->read_stamp = stread->stamp - 1;
st_context_validate(st, stdraw, stread);
}
else {
struct gl_framebuffer *incomplete = _mesa_get_incomplete_framebuffer();
ret = _mesa_make_current(st->ctx, incomplete, incomplete);
}
st_framebuffer_reference(&stdraw, NULL);
st_framebuffer_reference(&stread, NULL);
}
else {
ret = _mesa_make_current(NULL, NULL, NULL);
}
return ret;
}
GLboolean
intelMakeCurrent(__DRIcontext * driContextPriv,
__DRIdrawable * driDrawPriv,
__DRIdrawable * driReadPriv)
{
struct brw_context *brw;
GET_CURRENT_CONTEXT(curCtx);
if (driContextPriv)
brw = (struct brw_context *) driContextPriv->driverPrivate;
else
brw = NULL;
/* According to the glXMakeCurrent() man page: "Pending commands to
* the previous context, if any, are flushed before it is released."
* But only flush if we're actually changing contexts.
*/
if (brw_context(curCtx) && brw_context(curCtx) != brw) {
_mesa_flush(curCtx);
}
if (driContextPriv) {
struct gl_context *ctx = &brw->ctx;
struct gl_framebuffer *fb, *readFb;
if (driDrawPriv == NULL && driReadPriv == NULL) {
fb = _mesa_get_incomplete_framebuffer();
readFb = _mesa_get_incomplete_framebuffer();
} else {
fb = driDrawPriv->driverPrivate;
readFb = driReadPriv->driverPrivate;
driContextPriv->dri2.draw_stamp = driDrawPriv->dri2.stamp - 1;
driContextPriv->dri2.read_stamp = driReadPriv->dri2.stamp - 1;
}
/* The sRGB workaround changes the renderbuffer's format. We must change
* the format before the renderbuffer's miptree get's allocated, otherwise
* the formats of the renderbuffer and its miptree will differ.
*/
intel_gles3_srgb_workaround(brw, fb);
intel_gles3_srgb_workaround(brw, readFb);
intel_prepare_render(brw);
_mesa_make_current(ctx, fb, readFb);
}
else {
_mesa_make_current(NULL, NULL, NULL);
}
return true;
}
GLboolean
intelMakeCurrent(__DRIcontext * driContextPriv,
__DRIdrawable * driDrawPriv,
__DRIdrawable * driReadPriv)
{
struct intel_context *intel;
GET_CURRENT_CONTEXT(curCtx);
if (driContextPriv)
intel = (struct intel_context *) driContextPriv->driverPrivate;
else
intel = NULL;
/* According to the glXMakeCurrent() man page: "Pending commands to
* the previous context, if any, are flushed before it is released."
* But only flush if we're actually changing contexts.
*/
if (intel_context(curCtx) && intel_context(curCtx) != intel) {
_mesa_flush(curCtx);
}
if (driContextPriv) {
struct gl_context *ctx = &intel->ctx;
struct gl_framebuffer *fb, *readFb;
if (driDrawPriv == NULL && driReadPriv == NULL) {
fb = _mesa_get_incomplete_framebuffer();
readFb = _mesa_get_incomplete_framebuffer();
} else {
fb = driDrawPriv->driverPrivate;
readFb = driReadPriv->driverPrivate;
driContextPriv->dri2.draw_stamp = driDrawPriv->dri2.stamp - 1;
driContextPriv->dri2.read_stamp = driReadPriv->dri2.stamp - 1;
}
intel_prepare_render(intel);
_mesa_make_current(ctx, fb, readFb);
/* We do this in intel_prepare_render() too, but intel->ctx.DrawBuffer
* is NULL at that point. We can't call _mesa_makecurrent()
* first, since we need the buffer size for the initial
* viewport. So just call intel_draw_buffer() again here. */
intel_draw_buffer(ctx);
}
else {
_mesa_make_current(NULL, NULL, NULL);
}
return true;
}
static GLboolean
dri_make_current(__DRIcontext * cPriv,
__DRIdrawable * driDrawPriv,
__DRIdrawable * driReadPriv)
{
struct gl_context *mesaCtx;
struct gl_framebuffer *mesaDraw;
struct gl_framebuffer *mesaRead;
TRACE;
if (cPriv) {
struct dri_context *ctx = dri_context(cPriv);
struct dri_drawable *draw;
struct dri_drawable *read;
if (!driDrawPriv || !driReadPriv)
return GL_FALSE;
draw = dri_drawable(driDrawPriv);
read = dri_drawable(driReadPriv);
mesaCtx = &ctx->Base;
mesaDraw = &draw->Base;
mesaRead = &read->Base;
/* check for same context and buffer */
if (mesaCtx == _mesa_get_current_context()
&& mesaCtx->DrawBuffer == mesaDraw
&& mesaCtx->ReadBuffer == mesaRead) {
return GL_TRUE;
}
_glapi_check_multithread();
swrast_check_and_update_window_size(mesaCtx, mesaDraw);
if (mesaRead != mesaDraw)
swrast_check_and_update_window_size(mesaCtx, mesaRead);
_mesa_make_current( mesaCtx,
mesaDraw,
mesaRead );
}
else {
/* unbind */
_mesa_make_current( NULL, NULL, NULL );
}
return GL_TRUE;
}
void
MesaSoftwareRenderer::LockGL()
{
CALLED();
BGLRenderer::LockGL();
_mesa_make_current(fContext, &fFrameBuffer->base, &fFrameBuffer->base);
color_space colorSpace = BScreen(GLView()->Window()).ColorSpace();
BAutolock lock(fInfoLocker);
if (fDirectModeEnabled && fInfo != NULL) {
fNewWidth = fInfo->window_bounds.right
- fInfo->window_bounds.left + 1;
fNewHeight = fInfo->window_bounds.bottom
- fInfo->window_bounds.top + 1;
}
if (fColorSpace != colorSpace) {
fColorSpace = colorSpace;
_SetupRenderBuffer(fFrontRenderBuffer, fColorSpace);
if (fVisual->doubleBufferMode)
_SetupRenderBuffer(fBackRenderBuffer, fColorSpace);
}
if (fBitmap && fNewWidth == fWidth
&& fNewHeight == fHeight)
return;
fWidth = fNewWidth;
fHeight = fNewHeight;
_AllocateBitmap();
}
/* Force the context `c' to be the current context and associate with it
* buffer `b'.
*/
GLboolean
r128MakeCurrent( __DRIcontextPrivate *driContextPriv,
__DRIdrawablePrivate *driDrawPriv,
__DRIdrawablePrivate *driReadPriv )
{
if ( driContextPriv ) {
GET_CURRENT_CONTEXT(ctx);
r128ContextPtr oldR128Ctx = ctx ? R128_CONTEXT(ctx) : NULL;
r128ContextPtr newR128Ctx = (r128ContextPtr) driContextPriv->driverPrivate;
if ( newR128Ctx != oldR128Ctx ) {
newR128Ctx->new_state |= R128_NEW_CONTEXT;
newR128Ctx->dirty = R128_UPLOAD_ALL;
}
newR128Ctx->driDrawable = driDrawPriv;
_mesa_make_current2( newR128Ctx->glCtx,
(GLframebuffer *) driDrawPriv->driverPrivate,
(GLframebuffer *) driReadPriv->driverPrivate );
newR128Ctx->new_state |= R128_NEW_WINDOW | R128_NEW_CLIP;
if ( !newR128Ctx->glCtx->Viewport.Width ) {
_mesa_set_viewport(newR128Ctx->glCtx, 0, 0,
driDrawPriv->w, driDrawPriv->h);
}
} else {
_mesa_make_current( 0, 0 );
}
return GL_TRUE;
}
/**
* Bind an OSMesaContext to an image buffer. The image buffer is just a
* block of memory which the client provides. Its size must be at least
* as large as width*height*sizeof(type). Its address should be a multiple
* of 4 if using RGBA mode.
*
* Image data is stored in the order of glDrawPixels: row-major order
* with the lower-left image pixel stored in the first array position
* (ie. bottom-to-top).
*
* If the context's viewport hasn't been initialized yet, it will now be
* initialized to (0,0,width,height).
*
* Input: osmesa - the rendering context
* buffer - the image buffer memory
* type - data type for pixel components
* Normally, only GL_UNSIGNED_BYTE and GL_UNSIGNED_SHORT_5_6_5
* are supported. But if Mesa's been compiled with CHAN_BITS==16
* then type may be GL_UNSIGNED_SHORT or GL_UNSIGNED_BYTE. And if
* Mesa's been build with CHAN_BITS==32 then type may be GL_FLOAT,
* GL_UNSIGNED_SHORT or GL_UNSIGNED_BYTE.
* width, height - size of image buffer in pixels, at least 1
* Return: GL_TRUE if success, GL_FALSE if error because of invalid osmesa,
* invalid buffer address, invalid type, width<1, height<1,
* width>internal limit or height>internal limit.
*/
GLAPI GLboolean GLAPIENTRY
OSMesaMakeCurrent( OSMesaContext osmesa, void *buffer, GLenum type,
GLsizei width, GLsizei height )
{
if (!osmesa || !buffer ||
width < 1 || height < 1 ||
width > MAX_WIDTH || height > MAX_HEIGHT) {
return GL_FALSE;
}
if (osmesa->format == OSMESA_RGB_565 && type != GL_UNSIGNED_SHORT_5_6_5) {
return GL_FALSE;
}
#if 0
if (!(type == GL_UNSIGNED_BYTE ||
(type == GL_UNSIGNED_SHORT && CHAN_BITS >= 16) ||
(type == GL_FLOAT && CHAN_BITS == 32))) {
/* i.e. is sizeof(type) * 8 > CHAN_BITS? */
return GL_FALSE;
}
#endif
osmesa_update_state( &osmesa->mesa, 0 );
/* Call this periodically to detect when the user has begun using
* GL rendering from multiple threads.
*/
_glapi_check_multithread();
/* Set renderbuffer fields. Set width/height = 0 to force
* osmesa_renderbuffer_storage() being called by _mesa_resize_framebuffer()
*/
osmesa->rb->Data = buffer;
osmesa->rb->DataType = type;
osmesa->rb->Width = osmesa->rb->Height = 0;
/* Set the framebuffer's size. This causes the
* osmesa_renderbuffer_storage() function to get called.
*/
_mesa_resize_framebuffer(&osmesa->mesa, osmesa->gl_buffer, width, height);
osmesa->gl_buffer->Initialized = GL_TRUE; /* XXX TEMPORARY? */
_mesa_make_current( &osmesa->mesa, osmesa->gl_buffer, osmesa->gl_buffer );
/* Remove renderbuffer attachment, then re-add. This installs the
* renderbuffer adaptor/wrapper if needed (for bpp conversion).
*/
_mesa_remove_renderbuffer(osmesa->gl_buffer, BUFFER_FRONT_LEFT);
_mesa_add_renderbuffer(osmesa->gl_buffer, BUFFER_FRONT_LEFT, osmesa->rb);
/* this updates the visual's red/green/blue/alphaBits fields */
_mesa_update_framebuffer_visual(osmesa->gl_buffer);
/* update the framebuffer size */
_mesa_resize_framebuffer(&osmesa->mesa, osmesa->gl_buffer, width, height);
return GL_TRUE;
}
static void
fbDestroyContext( __DRIcontextPrivate *driContextPriv )
{
GET_CURRENT_CONTEXT(ctx);
fbContextPtr fbmesa = (fbContextPtr) driContextPriv->driverPrivate;
fbContextPtr current = ctx ? FB_CONTEXT(ctx) : NULL;
/* check if we're deleting the currently bound context */
if (fbmesa == current) {
_mesa_make_current(NULL, NULL, NULL);
}
/* Free fb context resources */
if ( fbmesa ) {
_swsetup_DestroyContext( fbmesa->glCtx );
_tnl_DestroyContext( fbmesa->glCtx );
_vbo_DestroyContext( fbmesa->glCtx );
_swrast_DestroyContext( fbmesa->glCtx );
/* free the Mesa context */
fbmesa->glCtx->DriverCtx = NULL;
_mesa_destroy_context( fbmesa->glCtx );
_mesa_free( fbmesa );
}
}
void
MesaSoftwareRenderer::LockGL()
{
CALLED();
BGLRenderer::LockGL();
_mesa_make_current(fContext, &fFrameBuffer->Base, &fFrameBuffer->Base);
color_space cs = B_RGBA32;
BAutolock lock(fInfoLocker);
if (fDirectModeEnabled && fInfo != NULL) {
cs = BScreen(GLView()->Window()).ColorSpace();
fNewWidth = fInfo->window_bounds.right
- fInfo->window_bounds.left + 1;
fNewHeight = fInfo->window_bounds.bottom
- fInfo->window_bounds.top + 1;
}
if (fBitmap && cs == fColorSpace && fNewWidth == fWidth
&& fNewHeight == fHeight)
return;
if (cs != fColorSpace) {
fColorSpace = cs;
_SetSpanFuncs(fFrontRenderBuffer, fColorSpace);
_SetSpanFuncs(fBackRenderBuffer, fColorSpace);
}
fWidth = fNewWidth;
fHeight = fNewHeight;
_AllocateBitmap();
}
void MesaDriver::LockGL()
{
m_bglview->LockLooper();
UpdateState(m_glcontext, 0);
_mesa_make_current(m_glcontext, m_glframebuffer);
}
GLboolean
sisMakeCurrent( __DRIcontextPrivate *driContextPriv,
__DRIdrawablePrivate *driDrawPriv,
__DRIdrawablePrivate *driReadPriv )
{
if ( driContextPriv ) {
GET_CURRENT_CONTEXT(ctx);
sisContextPtr oldSisCtx = ctx ? SIS_CONTEXT(ctx) : NULL;
sisContextPtr newSisCtx = (sisContextPtr) driContextPriv->driverPrivate;
if ( newSisCtx != oldSisCtx) {
newSisCtx->GlobalFlag = GFLAG_ALL;
}
newSisCtx->driDrawable = driDrawPriv;
_mesa_make_current2( newSisCtx->glCtx,
(GLframebuffer *) driDrawPriv->driverPrivate,
(GLframebuffer *) driReadPriv->driverPrivate );
sisUpdateBufferSize( newSisCtx );
sisUpdateClipping( newSisCtx->glCtx );
} else {
_mesa_make_current( 0, 0 );
}
return GL_TRUE;
}
GLboolean
intelUnbindContext(__DRIcontext * driContextPriv)
{
/* Unset current context and dispath table */
_mesa_make_current(NULL, NULL, NULL);
return true;
}
/* Make context `c' the current context and bind it to the given
* drawing and reading surfaces.
*/
GLboolean
radeonMakeCurrent( __DRIcontextPrivate *driContextPriv,
__DRIdrawablePrivate *driDrawPriv,
__DRIdrawablePrivate *driReadPriv )
{
if ( driContextPriv ) {
radeonContextPtr newCtx =
(radeonContextPtr) driContextPriv->driverPrivate;
if (RADEON_DEBUG & DEBUG_DRI)
fprintf(stderr, "%s ctx %p\n", __FUNCTION__, (void *) newCtx->glCtx);
newCtx->dri.readable = driReadPriv;
if ( (newCtx->dri.drawable != driDrawPriv) ||
newCtx->lastStamp != driDrawPriv->lastStamp ) {
if (driDrawPriv->swap_interval == (unsigned)-1) {
driDrawPriv->vblFlags = (newCtx->radeonScreen->irq != 0)
? driGetDefaultVBlankFlags(&newCtx->optionCache)
: VBLANK_FLAG_NO_IRQ;
driDrawableInitVBlank( driDrawPriv );
}
newCtx->dri.drawable = driDrawPriv;
radeonSetCliprects(newCtx);
radeonUpdateViewportOffset( newCtx->glCtx );
}
_mesa_make_current( newCtx->glCtx,
(GLframebuffer *) driDrawPriv->driverPrivate,
(GLframebuffer *) driReadPriv->driverPrivate );
_mesa_update_state( newCtx->glCtx );
} else {
if (RADEON_DEBUG & DEBUG_DRI)
fprintf(stderr, "%s ctx is null\n", __FUNCTION__);
_mesa_make_current( NULL, NULL, NULL );
}
if (RADEON_DEBUG & DEBUG_DRI)
fprintf(stderr, "End %s\n", __FUNCTION__);
return GL_TRUE;
}
/* Force the context `c' to be the current context and associate with it
* buffer `b'.
*/
GLboolean
r200MakeCurrent( __DRIcontextPrivate *driContextPriv,
__DRIdrawablePrivate *driDrawPriv,
__DRIdrawablePrivate *driReadPriv )
{
if ( driContextPriv ) {
r200ContextPtr newCtx =
(r200ContextPtr) driContextPriv->driverPrivate;
if (R200_DEBUG & DEBUG_DRI)
fprintf(stderr, "%s ctx %p\n", __FUNCTION__, (void *)newCtx->glCtx);
if ( newCtx->dri.drawable != driDrawPriv ) {
driDrawableInitVBlank( driDrawPriv, newCtx->vblank_flags,
&newCtx->vbl_seq );
}
newCtx->dri.readable = driReadPriv;
if ( newCtx->dri.drawable != driDrawPriv ||
newCtx->lastStamp != driDrawPriv->lastStamp ) {
newCtx->dri.drawable = driDrawPriv;
r200SetCliprects(newCtx);
r200UpdateViewportOffset( newCtx->glCtx );
}
_mesa_make_current( newCtx->glCtx,
(GLframebuffer *) driDrawPriv->driverPrivate,
(GLframebuffer *) driReadPriv->driverPrivate );
_mesa_update_state( newCtx->glCtx );
r200ValidateState( newCtx->glCtx );
} else {
if (R200_DEBUG & DEBUG_DRI)
fprintf(stderr, "%s ctx is null\n", __FUNCTION__);
_mesa_make_current( NULL, NULL, NULL );
}
if (R200_DEBUG & DEBUG_DRI)
fprintf(stderr, "End %s\n", __FUNCTION__);
return GL_TRUE;
}
void
MesaSoftwareRenderer::UnlockGL()
{
CALLED();
_mesa_make_current(fContext, NULL, NULL);
if ((fOptions & BGL_DOUBLE) == 0) {
SwapBuffers();
}
BGLRenderer::UnlockGL();
}
/* Force the context `c' to be the current context and associate with it
* buffer `b'.
*/
static GLboolean
fbMakeCurrent( __DRIcontextPrivate *driContextPriv,
__DRIdrawablePrivate *driDrawPriv,
__DRIdrawablePrivate *driReadPriv )
{
if ( driContextPriv ) {
fbContextPtr newFbCtx =
(fbContextPtr) driContextPriv->driverPrivate;
newFbCtx->dri.drawable = driDrawPriv;
_mesa_make_current( newFbCtx->glCtx,
driDrawPriv->driverPrivate,
driReadPriv->driverPrivate);
} else {
_mesa_make_current( NULL, NULL, NULL );
}
return GL_TRUE;
}
static GLboolean
dri_unbind_context(__DRIcontext * cPriv)
{
TRACE;
(void) cPriv;
/* Unset current context and dispath table */
_mesa_make_current(NULL, NULL, NULL);
return GL_TRUE;
}
/* Force the context `c' to be the current context and associate with it
* buffer `b'.
*/
GLboolean
mach64MakeCurrent( __DRIcontext *driContextPriv,
__DRIdrawable *driDrawPriv,
__DRIdrawable *driReadPriv )
{
if ( driContextPriv ) {
GET_CURRENT_CONTEXT(ctx);
mach64ContextPtr oldMach64Ctx = ctx ? MACH64_CONTEXT(ctx) : NULL;
mach64ContextPtr newMach64Ctx = (mach64ContextPtr) driContextPriv->driverPrivate;
if ( newMach64Ctx != oldMach64Ctx ) {
newMach64Ctx->new_state |= MACH64_NEW_CONTEXT;
newMach64Ctx->dirty = MACH64_UPLOAD_ALL;
}
if ( newMach64Ctx->driDrawable != driDrawPriv ) {
if (driDrawPriv->swap_interval == (unsigned)-1) {
driDrawPriv->vblFlags = (newMach64Ctx->do_irqs)
? driGetDefaultVBlankFlags(&newMach64Ctx->optionCache)
: VBLANK_FLAG_NO_IRQ;
driDrawableInitVBlank( driDrawPriv );
}
newMach64Ctx->driDrawable = driDrawPriv;
mach64CalcViewport( newMach64Ctx->glCtx );
}
_mesa_make_current( newMach64Ctx->glCtx,
(GLframebuffer *) driDrawPriv->driverPrivate,
(GLframebuffer *) driReadPriv->driverPrivate );
newMach64Ctx->new_state |= MACH64_NEW_CLIP;
} else {
_mesa_make_current( NULL, NULL, NULL );
}
return GL_TRUE;
}
static EGLBoolean
fbMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext context)
{
fbSurface *readSurf = Lookup_fbSurface(read);
fbSurface *drawSurf = Lookup_fbSurface(draw);
fbContext *ctx = Lookup_fbContext(context);
EGLBoolean b;
b = _eglMakeCurrent(drv, dpy, draw, read, context);
if (!b)
return EGL_FALSE;
if (ctx) {
_mesa_make_current( ctx->glCtx,
drawSurf->mesa_framebuffer,
readSurf->mesa_framebuffer);
} else
_mesa_make_current( NULL, NULL, NULL );
return EGL_TRUE;
}
void ggiMesaMakeCurrent(ggi_mesa_context_t ctx, ggi_visual_t vis)
{
GGIMESADPRINT_CORE("ggiMesaMakeCurrent(ctx = %p) called\n", ctx);
/* FIXME: clean up where are ggi_vis */
if (ctx->ggi_visual != vis) {
GGIMESADPRINT_CORE("Cannot migrate GL contexts\n");
return;
}
_mesa_make_current(ctx->gl_ctx, &LIBGGI_MESAEXT(vis)->mesa_buffer);
}
void
brw_meta_fast_clear_free(struct brw_context *brw)
{
struct brw_fast_clear_state *clear = brw->fast_clear_state;
GET_CURRENT_CONTEXT(old_context);
if (clear == NULL)
return;
_mesa_make_current(&brw->ctx, NULL, NULL);
_mesa_DeleteVertexArrays(1, &clear->vao);
_mesa_DeleteBuffers(1, &clear->vbo);
_mesa_DeleteProgram(clear->shader_prog);
free(clear);
if (old_context)
_mesa_make_current(old_context, old_context->WinSysDrawBuffer, old_context->WinSysReadBuffer);
else
_mesa_make_current(NULL, NULL, NULL);
}
/*
* Make the specified FX/Mesa context the current one.
*/
void GLAPIENTRY
fxMesaMakeCurrent(fxMesaContext fxMesa)
{
if (!fxMesa) {
_mesa_make_current(NULL, NULL, NULL);
fxMesaCurrentCtx = NULL;
if (TDFX_DEBUG & VERBOSE_DRIVER) {
fprintf(stderr, "fxMesaMakeCurrent(NULL)\n");
}
return;
}
/* if this context is already the current one, we can return early */
if (fxMesaCurrentCtx == fxMesa
&& fxMesaCurrentCtx->glCtx == _mesa_get_current_context()) {
if (TDFX_DEBUG & VERBOSE_DRIVER) {
fprintf(stderr, "fxMesaMakeCurrent(NOP)\n");
}
return;
}
if (TDFX_DEBUG & VERBOSE_DRIVER) {
fprintf(stderr, "fxMesaMakeCurrent(...)\n");
}
if (fxMesaCurrentCtx)
grGlideGetState((GrState *) fxMesaCurrentCtx->state);
fxMesaCurrentCtx = fxMesa;
grSstSelect(fxMesa->board);
grGlideSetState((GrState *) fxMesa->state);
_mesa_make_current(fxMesa->glCtx, fxMesa->glBuffer, fxMesa->glBuffer);
fxSetupDDPointers(fxMesa->glCtx);
}
static GLboolean
CreateContext(void)
{
struct dd_function_table ddFuncs;
GLvisual *vis;
GLframebuffer *buf;
GLcontext *ctx;
CompilerContext *cc;
vis = _mesa_create_visual(GL_FALSE, GL_FALSE, /* RGB */
8, 8, 8, 8, /* color */
0, 0, /* z, stencil */
0, 0, 0, 0, 1); /* accum */
buf = _mesa_create_framebuffer(vis);
cc = calloc(1, sizeof(*cc));
if (!vis || !buf || !cc) {
if (vis)
_mesa_destroy_visual(vis);
if (buf)
_mesa_destroy_framebuffer(buf);
return GL_FALSE;
}
_mesa_init_driver_functions(&ddFuncs);
ddFuncs.GetString = NULL;/*get_string;*/
ddFuncs.UpdateState = UpdateState;
ddFuncs.GetBufferSize = NULL;
ctx = &cc->MesaContext;
_mesa_initialize_context(ctx, vis, NULL, &ddFuncs, cc);
_mesa_enable_sw_extensions(ctx);
if (!_swrast_CreateContext( ctx ) ||
!_vbo_CreateContext( ctx ) ||
!_tnl_CreateContext( ctx ) ||
!_swsetup_CreateContext( ctx )) {
_mesa_destroy_visual(vis);
_mesa_free_context_data(ctx);
free(cc);
return GL_FALSE;
}
TNL_CONTEXT(ctx)->Driver.RunPipeline = _tnl_run_pipeline;
_swsetup_Wakeup( ctx );
/* Override the context's default pragma settings */
ctx->Shader.DefaultPragmas = Options.Pragmas;
_mesa_make_current(ctx, buf, buf);
return GL_TRUE;
}
/*
* Make the specified context and buffer the current one.
*/
GLboolean GLAPIENTRY AMesaMakeCurrent(AMesaContext context, AMesaBuffer buffer)
{
if (context && buffer) {
context->Buffer = buffer;
buffer->Active = buffer->BackBuffer ? buffer->BackBuffer : buffer->FrontBuffer;
buffer->ReadActive = buffer->Active;
context->ClearDepth = 2 << context->Visual->GLVisual->depthBits;
context->zNear = 0.;
context->zFar = 1.;
context->ClearColor = 0;
context->ClearIndex = 0;
context->ColorIndex = 0;
AMesaUpdateState(context->GLContext, ~0);
_mesa_make_current(context->GLContext, buffer->GLBuffer);
if (context->GLContext->Viewport.Width == 0 ||
context->GLContext->Viewport.Height == 0) {
/* initialize viewport and scissor box to buffer size */
_mesa_Viewport(0, 0, buffer->Width, buffer->Height);
context->GLContext->Scissor.Width = buffer->Width;
context->GLContext->Scissor.Height = buffer->Height;
}
AMesa = context;
}
else {
if (context) {
/* Detach */
context->Buffer->Active = NULL;
context->Buffer->ReadActive = NULL;
context->Buffer = NULL;
_mesa_make_current(NULL, NULL);
AMesa = NULL;
}
else
return GL_FALSE;
}
return GL_TRUE;
}
GLboolean
intelMakeCurrent(__DRIcontext * driContextPriv,
__DRIdrawable * driDrawPriv,
__DRIdrawable * driReadPriv)
{
struct intel_context *intel;
GET_CURRENT_CONTEXT(curCtx);
if (driContextPriv)
intel = (struct intel_context *) driContextPriv->driverPrivate;
else
intel = NULL;
/* According to the glXMakeCurrent() man page: "Pending commands to
* the previous context, if any, are flushed before it is released."
* But only flush if we're actually changing contexts.
*/
if (intel_context(curCtx) && intel_context(curCtx) != intel) {
_mesa_flush(curCtx);
}
if (driContextPriv) {
struct gl_framebuffer *fb = driDrawPriv->driverPrivate;
struct gl_framebuffer *readFb = driReadPriv->driverPrivate;
intel->driReadDrawable = driReadPriv;
intel->driDrawable = driDrawPriv;
driContextPriv->dri2.draw_stamp = driDrawPriv->dri2.stamp - 1;
driContextPriv->dri2.read_stamp = driReadPriv->dri2.stamp - 1;
intel_prepare_render(intel);
_mesa_make_current(&intel->ctx, fb, readFb);
}
else {
_mesa_make_current(NULL, NULL, NULL);
}
return GL_TRUE;
}
void st_make_current(struct st_context *st,
struct st_framebuffer *draw,
struct st_framebuffer *read)
{
if (st) {
GLboolean firstTime = st->ctx->FirstTimeCurrent;
_mesa_make_current(st->ctx, &draw->Base, &read->Base);
/* Need to initialize viewport here since draw->Base->Width/Height
* will still be zero at this point.
* This could be improved, but would require rather extensive work
* elsewhere (allocate rb surface storage sooner)
*/
if (firstTime) {
GLuint w = draw->InitWidth, h = draw->InitHeight;
_mesa_set_viewport(st->ctx, 0, 0, w, h);
_mesa_set_scissor(st->ctx, 0, 0, w, h);
}
}
else {
_mesa_make_current(NULL, NULL, NULL);
}
}
void sw_ReleaseContext(DHGLRC dhglrc)
{
struct sw_context* sw_ctx = (struct sw_context*)dhglrc;
/* Forward to mesa */
_mesa_make_current(NULL, NULL, NULL);
/* Unhook */
if(sw_ctx->hook)
{
UnhookWindowsHookEx(sw_ctx->hook);
sw_ctx->hook = NULL;
}
}
/* Force the context `c' to be the current context and associate with it
* buffer `b'.
*/
GLboolean
mach64MakeCurrent( __DRIcontextPrivate *driContextPriv,
__DRIdrawablePrivate *driDrawPriv,
__DRIdrawablePrivate *driReadPriv )
{
if ( driContextPriv ) {
GET_CURRENT_CONTEXT(ctx);
mach64ContextPtr oldMach64Ctx = ctx ? MACH64_CONTEXT(ctx) : NULL;
mach64ContextPtr newMach64Ctx = (mach64ContextPtr) driContextPriv->driverPrivate;
if ( newMach64Ctx != oldMach64Ctx ) {
newMach64Ctx->new_state |= MACH64_NEW_CONTEXT;
newMach64Ctx->dirty = MACH64_UPLOAD_ALL;
}
driDrawableInitVBlank( driDrawPriv, newMach64Ctx->vblank_flags,
&newMach64Ctx->vbl_seq );
if ( newMach64Ctx->driDrawable != driDrawPriv ) {
newMach64Ctx->driDrawable = driDrawPriv;
mach64CalcViewport( newMach64Ctx->glCtx );
}
_mesa_make_current( newMach64Ctx->glCtx,
(GLframebuffer *) driDrawPriv->driverPrivate,
(GLframebuffer *) driReadPriv->driverPrivate );
newMach64Ctx->new_state |= MACH64_NEW_CLIP;
} else {
_mesa_make_current( NULL, NULL, NULL );
}
return GL_TRUE;
}
/*
* Bind an OSMesaContext to an image buffer. The image buffer is just a
* block of memory which the client provides. Its size must be at least
* as large as width*height*sizeof(type). Its address should be a multiple
* of 4 if using RGBA mode.
*
* Image data is stored in the order of glDrawPixels: row-major order
* with the lower-left image pixel stored in the first array position
* (ie. bottom-to-top).
*
* If the context's viewport hasn't been initialized yet, it will now be
* initialized to (0,0,width,height).
*
* Input: ctx - the rendering context
* buffer - the image buffer memory
* type - data type for pixel components
* Normally, only GL_UNSIGNED_BYTE and GL_UNSIGNED_SHORT_5_6_5
* are supported. But if Mesa's been compiled with CHAN_BITS==16
* then type must be GL_UNSIGNED_SHORT. And if Mesa's been build
* with CHAN_BITS==32 then type must be GL_FLOAT.
* width, height - size of image buffer in pixels, at least 1
* Return: GL_TRUE if success, GL_FALSE if error because of invalid ctx,
* invalid buffer address, invalid type, width<1, height<1,
* width>internal limit or height>internal limit.
*/
GLAPI GLboolean GLAPIENTRY
OSMesaMakeCurrent( OSMesaContext ctx, void *buffer, GLenum type,
GLsizei width, GLsizei height )
{
if (!ctx || !buffer ||
width < 1 || height < 1 ||
width > MAX_WIDTH || height > MAX_HEIGHT) {
return GL_FALSE;
}
if (ctx->format == OSMESA_RGB_565) {
if (type != GL_UNSIGNED_SHORT_5_6_5)
return GL_FALSE;
}
else if (type != CHAN_TYPE) {
return GL_FALSE;
}
/* Need to set these before calling _mesa_make_current() since the first
* time the context is bound, _mesa_make_current() will call our
* get_buffer_size() function to initialize the viewport. These are the
* values returned by get_buffer_size():
*/
ctx->buffer = buffer;
ctx->width = width;
ctx->height = height;
osmesa_update_state( &ctx->mesa, 0 );
/* Call this periodically to detect when the user has begun using
* GL rendering from multiple threads.
*/
_glapi_check_multithread();
_mesa_make_current( &ctx->mesa, ctx->gl_buffer, ctx->gl_buffer );
if (ctx->userRowLength)
ctx->rowlength = ctx->userRowLength;
else
ctx->rowlength = width;
compute_row_addresses( ctx );
/* this will make ensure we recognize the new buffer size */
_mesa_resize_framebuffer(&ctx->mesa, ctx->gl_buffer, width, height);
return GL_TRUE;
}
