diff options
Diffstat (limited to 'hw/xgl/xglglx.c')
| -rw-r--r-- | hw/xgl/xglglx.c | 908 |
1 files changed, 830 insertions, 78 deletions
diff --git a/hw/xgl/xglglx.c b/hw/xgl/xglglx.c index 40d8ec5bb..108234cbd 100644 --- a/hw/xgl/xglglx.c +++ b/hw/xgl/xglglx.c @@ -92,12 +92,38 @@ typedef struct _xglGLBuffer { ScreenPtr pScreen; DrawablePtr pDrawable; PixmapPtr pPixmap; - GCPtr pGC; + GCPtr pGC, swapGC; + RegionRec damage; void *private; } xglGLBufferRec, *xglGLBufferPtr; typedef int xglGLXVisualConfigRec, *xglGLXVisualConfigPtr; +typedef struct _xglDisplayList *xglDisplayListPtr; + +#define XGL_LIST_OP_CALLS 0 +#define XGL_LIST_OP_DRAW 1 +#define XGL_LIST_OP_LIST 2 + +typedef struct _xglListOp { + int type; + union { + GLuint name; + xglDisplayListPtr list; + } u; +} xglListOpRec, *xglListOpPtr; + +typedef struct _xglDisplayList { + xglListOpPtr pOp; + int nOp; + int size; + int refcnt; +} xglDisplayListRec; + +typedef struct _xglTexObj { + GLuint name; +} xglTexObjRec, *xglTexObjPtr; + typedef struct _xglGLContext { __GLinterface iface; __GLinterface *mIface; @@ -110,6 +136,8 @@ typedef struct _xglGLContext { Bool target; glitz_surface_t *draw; int tx, ty; + GLenum drawBuffer; + xglGLBufferPtr pDrawBuffer; xRectangle viewport; xRectangle scissor; GLboolean scissorTest; @@ -117,16 +145,12 @@ typedef struct _xglGLContext { GLenum error; xglHashTablePtr texObjects; xglHashTablePtr displayLists; + GLuint list; + GLenum listMode; + xglDisplayListPtr pList; + GLuint groupList; } xglGLContextRec, *xglGLContextPtr; -typedef struct _xglTexObj { - GLuint name; -} xglTexObjRec, *xglTexObjPtr; - -typedef struct _xglDisplayList { - GLuint name; -} xglDisplayListRec, *xglDisplayListPtr; - xglGLContextPtr cctx = NULL; static void @@ -173,16 +197,11 @@ xglDisable (GLenum cap) case GL_SCISSOR_TEST: if (cctx->scissorTest) { - __GLcontext *gc = (__GLcontext *) cctx; - __GLinterface *i = cctx->mIface; - __GLdrawablePrivate *drawPriv = i->imports.getDrawablePrivate (gc); - xglGLBufferPtr pDrawBufferPriv = drawPriv->private; - DrawablePtr pDrawable = pDrawBufferPriv->pDrawable; - cctx->scissorTest = GL_FALSE; glitz_context_set_scissor (cctx->context, cctx->tx, cctx->ty, - pDrawable->width, pDrawable->height); + cctx->pDrawBuffer->pDrawable->width, + cctx->pDrawBuffer->pDrawable->height); } break; default: @@ -258,7 +277,7 @@ xglGetBooleanv (GLenum pname, params[0] = GL_TRUE; break; case GL_DRAW_BUFFER: - params[0] = ENUM_TO_BOOLEAN (GL_BACK); + params[0] = ENUM_TO_BOOLEAN (cctx->drawBuffer); break; case GL_READ_BUFFER: params[0] = ENUM_TO_BOOLEAN (GL_BACK); @@ -299,7 +318,7 @@ xglGetDoublev (GLenum pname, params[0] = BOOLEAN_TO_DOUBLE (GL_TRUE); break; case GL_DRAW_BUFFER: - params[0] = ENUM_TO_DOUBLE (GL_BACK); + params[0] = ENUM_TO_DOUBLE (cctx->drawBuffer); break; case GL_READ_BUFFER: params[0] = ENUM_TO_DOUBLE (GL_BACK); @@ -341,7 +360,7 @@ xglGetFloatv (GLenum pname, params[0] = BOOLEAN_TO_FLOAT (GL_TRUE); break; case GL_DRAW_BUFFER: - params[0] = ENUM_TO_FLOAT (GL_BACK); + params[0] = ENUM_TO_FLOAT (cctx->drawBuffer); break; case GL_READ_BUFFER: params[0] = ENUM_TO_FLOAT (GL_BACK); @@ -383,7 +402,7 @@ xglGetIntegerv (GLenum pname, params[0] = BOOLEAN_TO_INT (GL_TRUE); break; case GL_DRAW_BUFFER: - params[0] = ENUM_TO_INT (GL_BACK); + params[0] = ENUM_TO_INT (cctx->drawBuffer); break; case GL_READ_BUFFER: params[0] = ENUM_TO_INT (GL_BACK); @@ -633,33 +652,114 @@ xglPrioritizeTextures (GLsizei n, } } +static xglDisplayListPtr +xglCreateList (void) +{ + xglDisplayListPtr pDisplayList; + + pDisplayList = xalloc (sizeof (xglDisplayListRec)); + if (!pDisplayList) + return NULL; + + pDisplayList->pOp = NULL; + pDisplayList->nOp = 0; + pDisplayList->size = 0; + pDisplayList->refcnt = 1; + + return pDisplayList; +} + +static void +xglDestroyList (xglDisplayListPtr pDisplayList) +{ + xglListOpPtr pOp = pDisplayList->pOp; + int nOp = pDisplayList->nOp; + + pDisplayList->refcnt--; + if (pDisplayList->refcnt) + return; + + while (nOp--) + { + switch (pOp->type) { + case XGL_LIST_OP_CALLS: + case XGL_LIST_OP_DRAW: + glDeleteLists (pOp->u.name, 1); + break; + case XGL_LIST_OP_LIST: + xglDestroyList (pOp->u.list); + break; + } + + pOp++; + } + + if (pDisplayList->pOp) + xfree (pDisplayList->pOp); + + xfree (pDisplayList); +} + +static Bool +xglResizeList (xglDisplayListPtr pDisplayList, + int nOp) +{ + if (pDisplayList->size < nOp) + { + int size = pDisplayList->nOp ? pDisplayList->nOp : 4; + + while (size < nOp) + size <<= 1; + + pDisplayList->pOp = xrealloc (pDisplayList->pOp, + sizeof (xglListOpRec) * size); + if (!pDisplayList->pOp) + return FALSE; + + pDisplayList->size = size; + } + + return TRUE; +} + +static void +xglStartList (int type, + GLenum mode) +{ + if (!xglResizeList (cctx->pList, cctx->pList->nOp + 1)) + { + cctx->error = GL_OUT_OF_MEMORY; + return; + } + + cctx->pList->pOp[cctx->pList->nOp].type = type; + cctx->pList->pOp[cctx->pList->nOp].u.name = glGenLists (1); + + glNewList (cctx->pList->pOp[cctx->pList->nOp].u.name, mode); + + cctx->pList->nOp++; +} + static GLuint xglGenLists (GLsizei range) { xglDisplayListPtr pDisplayList; - GLuint first, name, lists; - - lists = glGenLists (range); - if (!lists) - return 0; + GLuint first, name; first = xglHashFindFreeKeyBlock (cctx->shared->displayLists, range); name = first; for (name = first; range--; name++) { - pDisplayList = xalloc (sizeof (xglDisplayListRec)); + pDisplayList = xglCreateList (); if (pDisplayList) { - pDisplayList->name = lists; xglHashInsert (cctx->shared->displayLists, name, pDisplayList); } else { - glDeleteLists (lists, 1); cctx->error = GL_OUT_OF_MEMORY; } - lists++; } return first; @@ -669,30 +769,160 @@ static void xglNewList (GLuint list, GLenum mode) { - xglDisplayListPtr pDisplayList; - if (!list) { cctx->error = GL_INVALID_VALUE; return; } - + + if (cctx->list) + { + cctx->error = GL_INVALID_OPERATION; + return; + } + + cctx->pList = xglCreateList (); + if (!cctx->pList) + { + cctx->error = GL_OUT_OF_MEMORY; + return; + } + + cctx->list = list; + cctx->listMode = mode; + + xglStartList (XGL_LIST_OP_CALLS, mode); +} + +static void +xglEndList (void) +{ + xglDisplayListPtr pDisplayList; + + if (!cctx->list) + { + cctx->error = GL_INVALID_OPERATION; + return; + } + + glEndList (); + pDisplayList = (xglDisplayListPtr) - xglHashLookup (cctx->shared->displayLists, list); - if (!pDisplayList) + xglHashLookup (cctx->shared->displayLists, cctx->list); + if (pDisplayList) + { + xglHashRemove (cctx->shared->displayLists, cctx->list); + xglDestroyList (pDisplayList); + } + + xglHashInsert (cctx->shared->displayLists, cctx->list, cctx->pList); + + cctx->list = 0; +} + +#define XGL_GLX_DRAW_DECLERATIONS(pBox, nBox) \ + GCPtr pGC = cctx->pDrawBuffer->pGC; \ + BoxPtr (pBox) = REGION_RECTS (pGC->pCompositeClip); \ + int (nBox) = REGION_NUM_RECTS (pGC->pCompositeClip); \ + DrawablePtr pDrawable = cctx->pDrawBuffer->pDrawable; \ + int scissorX1 = cctx->scissor.x; \ + int scissorX2 = scissorX1 + cctx->scissor.width; \ + int scissorY2 = pDrawable->height - cctx->scissor.y; \ + int scissorY1 = scissorY2 - cctx->scissor.height + +#define XGL_GLX_DRAW_SCISSOR_CLIP(box) \ + if ((box)->x1 < scissorX1) \ + (box)->x1 = scissorX1; \ + if ((box)->y1 < scissorY1) \ + (box)->y1 = scissorY1; \ + if ((box)->x2 > scissorX2) \ + (box)->x2 = scissorX2; \ + if ((box)->y2 > scissorY2) \ + (box)->y2 = scissorY2 + +#define XGL_GLX_DRAW_DAMAGE(pBox, pRegion) \ + if (cctx->drawBuffer == GL_FRONT) \ + { \ + REGION_INIT (pGC->pScreen, pRegion, pBox, 1); \ + REGION_UNION (pGC->pScreen, \ + &cctx->pDrawBuffer->damage, \ + &cctx->pDrawBuffer->damage, \ + pRegion); \ + REGION_UNINIT (pGC->pScreen, pRegion); \ + } + +#define XGL_GLX_DRAW_SET_SCISSOR_BOX(box) \ + glitz_context_set_scissor (cctx->context, \ + cctx->tx + (box)->x1, \ + pDrawable->height - (box)->y2 - cctx->ty, \ + (box)->x2 - (box)->x1, \ + (box)->y2 - (box)->y1) + + +static void +xglDrawList (GLuint list) +{ + RegionRec region; + BoxRec box; + + XGL_GLX_DRAW_DECLERATIONS (pBox, nBox); + + while (nBox--) + { + box = *pBox++; + + XGL_GLX_DRAW_SCISSOR_CLIP (&box); + + if (box.x1 < box.x2 && box.y1 < box.y2) + { + XGL_GLX_DRAW_SET_SCISSOR_BOX (&box); + + glCallList (list); + + XGL_GLX_DRAW_DAMAGE (&box, ®ion); + } + } +} + +static void +xglCallDisplayList (xglDisplayListPtr pDisplayList) +{ + if (cctx->list) { - pDisplayList = xalloc (sizeof (xglDisplayListRec)); - if (!pDisplayList) + if (!xglResizeList (cctx->pList, cctx->pList->nOp + 1)) { cctx->error = GL_OUT_OF_MEMORY; return; } - - pDisplayList->name = glGenLists (1); - xglHashInsert (cctx->shared->displayLists, list, pDisplayList); + + pDisplayList->refcnt++; + + cctx->pList->pOp[cctx->pList->nOp].type = XGL_LIST_OP_LIST; + cctx->pList->pOp[cctx->pList->nOp].u.list = pDisplayList; + cctx->pList->nOp++; + } + else + { + xglListOpPtr pOp = pDisplayList->pOp; + int nOp = pDisplayList->nOp; + + while (nOp--) + { + switch (pOp->type) { + case XGL_LIST_OP_CALLS: + glCallList (pOp->u.name); + break; + case XGL_LIST_OP_DRAW: + xglDrawList (pOp->u.name); + break; + case XGL_LIST_OP_LIST: + xglCallDisplayList (pOp->u.list); + break; + } + + pOp++; + } } - - glNewList (pDisplayList->name, mode); } static void @@ -709,7 +939,7 @@ xglCallList (GLuint list) pDisplayList = (xglDisplayListPtr) xglHashLookup (cctx->shared->displayLists, list); if (pDisplayList) - glCallList (pDisplayList->name); + xglCallDisplayList (pDisplayList); } static void @@ -775,7 +1005,7 @@ xglCallLists (GLsizei n, pDisplayList = (xglDisplayListPtr) xglHashLookup (cctx->shared->displayLists, base + list); if (pDisplayList) - glCallList (pDisplayList->name); + xglCallDisplayList (pDisplayList); } } @@ -798,9 +1028,8 @@ xglDeleteLists (GLuint list, xglHashLookup (cctx->shared->displayLists, list + i); if (pDisplayList) { - glDeleteLists (pDisplayList->name, 1); xglHashRemove (cctx->shared->displayLists, list + i); - xfree (pDisplayList); + xglDestroyList (pDisplayList); } } } @@ -816,21 +1045,518 @@ xglIsList (GLuint list) pDisplayList = (xglDisplayListPtr) xglHashLookup (cctx->shared->displayLists, list); if (pDisplayList) - return glIsList (pDisplayList->name); + return GL_TRUE; return GL_FALSE; } +static void +xglFlush (void) +{ + xglGLBufferPtr pBuffer = cctx->pDrawBuffer; + + glFlush (); + + if (REGION_NOTEMPTY (pBuffer->pDrawable->pScreen, &pBuffer->damage)) + { + DamageDamageRegion (pBuffer->pDrawable, &pBuffer->damage); + REGION_EMPTY (pBuffer->pDrawable->pScreen, &pBuffer->damage); + } +} + +static void +xglFinish (void) +{ + xglGLBufferPtr pBuffer = cctx->pDrawBuffer; + + glFinish (); + + if (REGION_NOTEMPTY (pBuffer->pDrawable->pScreen, &pBuffer->damage)) + { + DamageDamageRegion (pBuffer->pDrawable, &pBuffer->damage); + REGION_EMPTY (pBuffer->pDrawable->pScreen, &pBuffer->damage); + } +} + +static void +xglClear (GLbitfield mask) +{ + GLenum mode; + + if (cctx->list) + { + glEndList (); + xglStartList (XGL_LIST_OP_DRAW, GL_COMPILE); + glClear (mask); + glEndList (); + + mode = cctx->listMode; + } + else + mode = GL_COMPILE_AND_EXECUTE; + + if (mode == GL_COMPILE_AND_EXECUTE) + { + RegionRec region; + BoxRec box; + + XGL_GLX_DRAW_DECLERATIONS (pBox, nBox); + + while (nBox--) + { + box = *pBox++; + + XGL_GLX_DRAW_SCISSOR_CLIP (&box); + + if (box.x1 < box.x2 && box.y1 < box.y2) + { + XGL_GLX_DRAW_SET_SCISSOR_BOX (&box); + + glClear (mask); + + if (mask & GL_COLOR_BUFFER_BIT) + XGL_GLX_DRAW_DAMAGE (&box, ®ion); + } + } + } + + if (cctx->list) + xglStartList (XGL_LIST_OP_CALLS, cctx->listMode); +} + +static void +xglAccum (GLenum op, + GLfloat value) +{ + if (op == GL_RETURN) + { + GLenum listMode; + + if (cctx->list) + { + glEndList (); + xglStartList (XGL_LIST_OP_DRAW, GL_COMPILE); + glAccum (GL_RETURN, value); + glEndList (); + + listMode = cctx->listMode; + } + else + listMode = GL_COMPILE_AND_EXECUTE; + + if (listMode == GL_COMPILE_AND_EXECUTE) + { + RegionRec region; + BoxRec box; + + XGL_GLX_DRAW_DECLERATIONS (pBox, nBox); + + while (nBox--) + { + box = *pBox++; + + XGL_GLX_DRAW_SCISSOR_CLIP (&box); + + if (box.x1 < box.x2 && box.y1 < box.y2) + { + XGL_GLX_DRAW_SET_SCISSOR_BOX (&box); + + glAccum (GL_RETURN, value); + + XGL_GLX_DRAW_DAMAGE (&box, ®ion); + } + } + } + + if (cctx->list) + xglStartList (XGL_LIST_OP_CALLS, cctx->listMode); + } + else + glAccum (op, value); +} + +static void +xglDrawArrays (GLenum mode, + GLint first, + GLsizei count) +{ + GLenum listMode; + + if (cctx->list) + { + glEndList (); + xglStartList (XGL_LIST_OP_DRAW, GL_COMPILE); + glDrawArrays (mode, first, count); + glEndList (); + + listMode = cctx->listMode; + } + else + listMode = GL_COMPILE_AND_EXECUTE; + + if (listMode == GL_COMPILE_AND_EXECUTE) + { + RegionRec region; + BoxRec box; + + XGL_GLX_DRAW_DECLERATIONS (pBox, nBox); + + while (nBox--) + { + box = *pBox++; + + XGL_GLX_DRAW_SCISSOR_CLIP (&box); + + if (box.x1 < box.x2 && box.y1 < box.y2) + { + XGL_GLX_DRAW_SET_SCISSOR_BOX (&box); + + glDrawArrays (mode, first, count); + + XGL_GLX_DRAW_DAMAGE (&box, ®ion); + } + } + } + + if (cctx->list) + xglStartList (XGL_LIST_OP_CALLS, cctx->listMode); +} + +static void +xglDrawElements (GLenum mode, + GLsizei count, + GLenum type, + const GLvoid *indices) +{ + GLenum listMode; + + if (cctx->list) + { + glEndList (); + xglStartList (XGL_LIST_OP_DRAW, GL_COMPILE); + glDrawElements (mode, count, type, indices); + glEndList (); + + listMode = cctx->listMode; + } + else + listMode = GL_COMPILE_AND_EXECUTE; + + if (listMode == GL_COMPILE_AND_EXECUTE) + { + RegionRec region; + BoxRec box; + + XGL_GLX_DRAW_DECLERATIONS (pBox, nBox); + + while (nBox--) + { + box = *pBox++; + + XGL_GLX_DRAW_SCISSOR_CLIP (&box); + + if (box.x1 < box.x2 && box.y1 < box.y2) + { + XGL_GLX_DRAW_SET_SCISSOR_BOX (&box); + + glDrawElements (mode, count, type, indices); + + XGL_GLX_DRAW_DAMAGE (&box, ®ion); + } + } + } + + if (cctx->list) + xglStartList (XGL_LIST_OP_CALLS, cctx->listMode); +} + +static void +xglDrawPixels (GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + const GLvoid *pixels) +{ + GLenum listMode; + + if (cctx->list) + { + glEndList (); + xglStartList (XGL_LIST_OP_DRAW, GL_COMPILE); + glDrawPixels (width, height, format, type, pixels); + glEndList (); + + listMode = cctx->listMode; + } + else + listMode = GL_COMPILE_AND_EXECUTE; + + if (listMode == GL_COMPILE_AND_EXECUTE) + { + RegionRec region; + BoxRec box; + + XGL_GLX_DRAW_DECLERATIONS (pBox, nBox); + + while (nBox--) + { + box = *pBox++; + + XGL_GLX_DRAW_SCISSOR_CLIP (&box); + + if (box.x1 < box.x2 && box.y1 < box.y2) + { + XGL_GLX_DRAW_SET_SCISSOR_BOX (&box); + + glDrawPixels (width, height, format, type, pixels); + + XGL_GLX_DRAW_DAMAGE (&box, ®ion); + } + } + } + + if (cctx->list) + xglStartList (XGL_LIST_OP_CALLS, cctx->listMode); +} + +static void +xglBitmap (GLsizei width, + GLsizei height, + GLfloat xorig, + GLfloat yorig, + GLfloat xmove, + GLfloat ymove, + const GLubyte *bitmap) +{ + GLenum listMode; + + if (cctx->list) + { + glEndList (); + xglStartList (XGL_LIST_OP_DRAW, GL_COMPILE); + glBitmap (width, height, xorig, yorig, xmove, ymove, bitmap); + glEndList (); + + listMode = cctx->listMode; + } + else + listMode = GL_COMPILE_AND_EXECUTE; + + if (listMode == GL_COMPILE_AND_EXECUTE) + { + RegionRec region; + BoxRec box; + + XGL_GLX_DRAW_DECLERATIONS (pBox, nBox); + + while (nBox--) + { + box = *pBox++; + + XGL_GLX_DRAW_SCISSOR_CLIP (&box); + + if (box.x1 < box.x2 && box.y1 < box.y2) + { + XGL_GLX_DRAW_SET_SCISSOR_BOX (&box); + + glBitmap (width, height, xorig, yorig, xmove, ymove, bitmap); + + XGL_GLX_DRAW_DAMAGE (&box, ®ion); + } + } + } + + if (cctx->list) + xglStartList (XGL_LIST_OP_CALLS, cctx->listMode); +} + +static void +xglRectdv (const GLdouble *v1, + const GLdouble *v2) +{ + GLenum listMode; + + if (cctx->list) + { + glEndList (); + xglStartList (XGL_LIST_OP_DRAW, GL_COMPILE); + glRectdv (v1, v2); + glEndList (); + + listMode = cctx->listMode; + } + else + listMode = GL_COMPILE_AND_EXECUTE; + + if (listMode == GL_COMPILE_AND_EXECUTE) + { + RegionRec region; + BoxRec box; + + XGL_GLX_DRAW_DECLERATIONS (pBox, nBox); + + while (nBox--) + { + box = *pBox++; + + XGL_GLX_DRAW_SCISSOR_CLIP (&box); + + if (box.x1 < box.x2 && box.y1 < box.y2) + { + XGL_GLX_DRAW_SET_SCISSOR_BOX (&box); + + glRectdv (v1, v2); + + XGL_GLX_DRAW_DAMAGE (&box, ®ion); + } + } + } + + if (cctx->list) + xglStartList (XGL_LIST_OP_CALLS, cctx->listMode); +} + +static void +xglRectfv (const GLfloat *v1, + const GLfloat *v2) +{ + GLdouble dv1[2]; + GLdouble dv2[2]; + + dv1[0] = (GLdouble) v1[0]; + dv1[1] = (GLdouble) v1[1]; + dv2[0] = (GLdouble) v2[0]; + dv2[1] = (GLdouble) v2[1]; + + xglRectdv (dv1, dv2); +} + +static void +xglRectiv (const GLint *v1, + const GLint *v2) +{ + GLdouble dv1[2]; + GLdouble dv2[2]; + + dv1[0] = (GLdouble) v1[0]; + dv1[1] = (GLdouble) v1[1]; + dv2[0] = (GLdouble) v2[0]; + dv2[1] = (GLdouble) v2[1]; + + xglRectdv (dv1, dv2); +} + +static void +xglRectsv (const GLshort *v1, + const GLshort *v2) +{ + GLdouble dv1[2]; + GLdouble dv2[2]; + + dv1[0] = (GLdouble) v1[0]; + dv1[1] = (GLdouble) v1[1]; + dv2[0] = (GLdouble) v2[0]; + dv2[1] = (GLdouble) v2[1]; + + xglRectdv (dv1, dv2); +} + +static void +xglBegin (GLenum mode) +{ + if (cctx->list) + { + glEndList (); + xglStartList (XGL_LIST_OP_DRAW, GL_COMPILE); + } + else + { + XGL_GLX_DRAW_DECLERATIONS (pBox, nBox); + + if (nBox == 1) + { + BoxRec box = *pBox; + + XGL_GLX_DRAW_SCISSOR_CLIP (&box); + XGL_GLX_DRAW_SET_SCISSOR_BOX (&box); + } + else + { + if (!cctx->groupList) + cctx->groupList = glGenLists (1); + + glNewList (cctx->groupList, GL_COMPILE); + } + } + + glBegin (mode); +} + +static void +xglEnd (void) +{ + glEnd (); + + if (!cctx->list || cctx->listMode == GL_COMPILE_AND_EXECUTE) + { + RegionRec region; + BoxRec box; + GLuint list; + + XGL_GLX_DRAW_DECLERATIONS (pBox, nBox); + + if (cctx->list) + { + list = cctx->pList->pOp[cctx->pList->nOp - 1].u.name; + } + else + { + if (nBox == 1) + { + box = *pBox++; + + XGL_GLX_DRAW_SCISSOR_CLIP (&box); + XGL_GLX_DRAW_DAMAGE (&box, ®ion); + return; + } + + list = cctx->groupList; + } + + glEndList (); + + while (nBox--) + { + box = *pBox++; + + XGL_GLX_DRAW_SCISSOR_CLIP (&box); + + if (box.x1 < box.x2 && box.y1 < box.y2) + { + XGL_GLX_DRAW_SET_SCISSOR_BOX (&box); + + glCallList (list); + + XGL_GLX_DRAW_DAMAGE (&box, ®ion); + } + } + } + + if (cctx->list) + xglStartList (XGL_LIST_OP_CALLS, cctx->listMode); +} + + __glProcTable __glNativeRenderTable = { xglNewList, /* glNewList */ - glEndList, + xglEndList, /* glEndList */ xglCallList, /* glCallList */ xglCallLists, /* glCallLists */ xglDeleteLists, /* glDeleteLists */ xglGenLists, /* glGenLists */ glListBase, - glBegin, - glBitmap, + xglBegin, /* glBegin */ + xglBitmap, /* glBitmap */ glColor3bv, glColor3dv, glColor3fv, @@ -848,7 +1574,7 @@ __glProcTable __glNativeRenderTable = { glColor4uiv, glColor4usv, glEdgeFlagv, - glEnd, + xglEnd, /* glEnd */ glIndexdv, glIndexfv, glIndexiv, @@ -870,10 +1596,10 @@ __glProcTable __glNativeRenderTable = { glRasterPos4fv, glRasterPos4iv, glRasterPos4sv, - glRectdv, - glRectfv, - glRectiv, - glRectsv, + xglRectdv, /* glRectdv */ + xglRectfv, /* glRectfv */ + xglRectiv, /* glRectiv */ + xglRectsv, /* glRectsv */ glTexCoord1dv, glTexCoord1fv, glTexCoord1iv, @@ -955,7 +1681,7 @@ __glProcTable __glNativeRenderTable = { glPopName, glPushName, xglDrawBuffer, /* glDrawBuffer */ - glClear, + xglClear, /* glClear */ glClearAccum, glClearIndex, glClearColor, @@ -965,11 +1691,11 @@ __glProcTable __glNativeRenderTable = { glColorMask, glDepthMask, glIndexMask, - glAccum, + xglAccum, /* glAccum */ xglDisable, /* glDisable */ xglEnable, /* glEnable */ - glFinish, - glFlush, + xglFinish, /* glFinish */ + xglFlush, /* glFlush */ glPopAttrib, glPushAttrib, glMap1d, @@ -1005,7 +1731,7 @@ __glProcTable __glNativeRenderTable = { xglReadBuffer, /* glReadBuffer */ xglCopyPixels, /* glCopyPixels */ glReadPixels, - glDrawPixels, + xglDrawPixels, /* glDrawPixels */ xglGetBooleanv, /* glGetBooleanv */ glGetClipPlane, xglGetDoublev, /* glGetDoublev */ @@ -1058,8 +1784,8 @@ __glProcTable __glNativeRenderTable = { xglBindTexture, /* glBindTexture */ glColorPointer, glDisableClientState, - glDrawArrays, - glDrawElements, + xglDrawArrays, /* glDrawArrays */ + xglDrawElements, /* glDrawElements */ glEdgeFlagPointer, glEnableClientState, glIndexPointer, @@ -1562,16 +2288,17 @@ xglFreeContext (xglGLContextPtr pContext) pDisplayList = (xglDisplayListPtr) xglHashLookup (pContext->displayLists, key); if (pDisplayList) - { - glDeleteLists (pDisplayList->name, 1); - xfree (pDisplayList); - } + xglDestroyList (pDisplayList); + xglHashRemove (pContext->displayLists, key); } } while (key); xglDeleteHashTable (pContext->displayLists); } + + if (pContext->groupList) + glDeleteLists (pContext->groupList, 1); glitz_context_destroy (pContext->context); @@ -1625,6 +2352,8 @@ xglMakeCurrent (__GLcontext *gc) { xglPixmapPtr pFront = XGL_GET_DRAWABLE_PIXMAP_PRIV (pDrawable); xglPixmapPtr pBack = XGL_GET_PIXMAP_PRIV (pPixmap); + XID value = FALSE; + int status; pContext->scissor.x = pContext->scissor.y = 0; pContext->scissor.width = pDrawable->width; @@ -1636,12 +2365,32 @@ xglMakeCurrent (__GLcontext *gc) pContext->draw = pBack->surface; pContext->tx = pContext->ty = 0; + + pContext->pDrawBuffer = pDrawBufferPriv; if (!pFront->lock) pFront->lock++; if (!pBack->lock) pBack->lock++; glitz_context_set_surface (pContext->context, pContext->draw); + if (!pDrawBufferPriv->pGC) + { + pDrawBufferPriv->pGC = + CreateGC (pDrawable, + GCGraphicsExposures, &value, + &status); + ValidateGC (pDrawable, pDrawBufferPriv->pGC); + } + + if (!pDrawBufferPriv->swapGC) + { + pDrawBufferPriv->swapGC = + CreateGC (&pPixmap->drawable, + GCGraphicsExposures, &value, + &status); + ValidateGC (&pPixmap->drawable, pDrawBufferPriv->swapGC); + } + return GL_TRUE; } } else @@ -1813,12 +2562,16 @@ xglCreateContext (__GLimports *imports, pContext->needInit = TRUE; pContext->draw = NULL; + pContext->drawBuffer = GL_BACK; pContext->target = FALSE; pContext->versionString = NULL; pContext->scissorTest = GL_FALSE; pContext->error = GL_NO_ERROR; + pContext->shared = NULL; + pContext->list = 0; + pContext->groupList = 0; + pContext->refcnt = 1; - pContext->refcnt = 1; if (shareGC) { pContext->texObjects = NULL; @@ -1881,21 +2634,13 @@ xglSwapBuffers (__GLXdrawablePrivate *glxPriv) xglGLBufferPtr pBufferPriv = glPriv->private; DrawablePtr pDrawable = pBufferPriv->pDrawable; PixmapPtr pPixmap = pBufferPriv->pPixmap; - GCPtr pGC = pBufferPriv->pGC; + GCPtr pGC = pBufferPriv->swapGC; GLboolean ret; - + if (pPixmap) { - if (!pGC) - { - int status; - XID value; - - value = FALSE; - pGC = CreateGC (pDrawable, GCGraphicsExposures, &value, &status); - ValidateGC (pDrawable, pGC); - pBufferPriv->pGC = pGC; - } + /* Discard front buffer damage */ + REGION_EMPTY (pGC->pScreen, &pBufferPriv->damage); if (pGC) { @@ -1949,6 +2694,7 @@ xglResizeBuffers (__GLdrawableBuffer *buffer, XGL_GET_PIXMAP_PRIV (pPixmap)->score = 4000; pBufferPriv->pPixmap = pPixmap; } + ValidateGC (&pPixmap->drawable, pBufferPriv->swapGC); } glPriv->private = pBufferPriv->private; @@ -1976,6 +2722,9 @@ xglFreeBuffers (__GLdrawablePrivate *glPriv) if (pBufferPriv->pGC) FreeGC (pBufferPriv->pGC, (GContext) 0); + + if (pBufferPriv->swapGC) + FreeGC (pBufferPriv->swapGC, (GContext) 0); xfree (pBufferPriv); } @@ -2001,6 +2750,9 @@ xglCreateBuffer (__GLXdrawablePrivate *glxPriv) pBufferPriv->pDrawable = pDrawable; pBufferPriv->pPixmap = NULL; pBufferPriv->pGC = NULL; + pBufferPriv->swapGC = NULL; + + REGION_INIT (pScreen, &pBufferPriv->damage, NullBox, 0); if (glxPriv->pGlxVisual->doubleBuffer) pBufferPriv->pPixmap = |